Source for file tag.php

Documentation is available at tag.php

  1. <?php
  2. /**
  3.  *  Base include file for SimpleTest.
  4.  *  @package    SimpleTest
  5.  *  @subpackage WebTester
  6.  *  @version    $Id: tag.php 1723 2008-04-08 00:34:10Z lastcraft $
  7.  */
  8.     
  9. /**#@+
  10.  * include SimpleTest files
  11.  */
  12. require_once(dirname(__FILE__) . '/parser.php');
  13. require_once(dirname(__FILE__) . '/encoding.php');
  14. /**#@-*/
  15.  
  16.  *    HTML or XML tag.
  17.  *    @package SimpleTest
  18.  *    @subpackage WebTester
  19.  */
  20. class SimpleTag {
  21.     var $_name;
  22.     var $_attributes;
  23.     var $_content;
  24.     
  25.     /**
  26.      *    Starts with a named tag with attributes only.
  27.      *    @param string $name        Tag name.
  28.      *    @param hash $attributes    Attribute names and
  29.      *                                string values. Note that
  30.      *                                the keys must have been
  31.      *                                converted to lower case.
  32.      */
  33.     function SimpleTag($name, $attributes) {
  34.         $this->_name = strtolower(trim($name));
  35.         $this->_attributes = $attributes;
  36.         $this->_content = '';
  37.     }
  38.     
  39.     /**
  40.      *    Check to see if the tag can have both start and
  41.      *    end tags with content in between.
  42.      *    @return boolean        True if content allowed.
  43.      *    @access public
  44.      */
  45.     function expectEndTag() {
  46.         return true;
  47.     }
  48.     
  49.     /**
  50.      *    The current tag should not swallow all content for
  51.      *    itself as it's searchable page content. Private
  52.      *    content tags are usually widgets that contain default
  53.      *    values.
  54.      *    @return boolean        False as content is available
  55.      *                            to other tags by default.
  56.      *    @access public
  57.      */
  58.     function isPrivateContent() {
  59.         return false;
  60.     }
  61.  
  62.     /**
  63.      *    Appends string content to the current content.
  64.      *    @param string $content        Additional text.
  65.      *    @access public
  66.      */
  67.     function addContent($content) {
  68.         $this->_content .= (string)$content;
  69.     }
  70.     
  71.     /**
  72.      *    Adds an enclosed tag to the content.
  73.      *    @param SimpleTag $tag    New tag.
  74.      *    @access public
  75.      */
  76.     function addTag(&$tag) {
  77.     }
  78.     
  79.     /**
  80.      *    Accessor for tag name.
  81.      *    @return string       Name of tag.
  82.      *    @access public
  83.      */
  84.     function getTagName() {
  85.         return $this->_name;
  86.     }
  87.     
  88.     /**
  89.      *    List of legal child elements.
  90.      *    @return array        List of element names.
  91.      *    @access public
  92.      */
  93.     function getChildElements() {
  94.         return array();
  95.     }
  96.     
  97.     /**
  98.      *    Accessor for an attribute.
  99.      *    @param string $label    Attribute name.
  100.      *    @return string          Attribute value.
  101.      *    @access public
  102.      */
  103.     function getAttribute($label) {
  104.         $label = strtolower($label);
  105.         if (! isset($this->_attributes[$label])) {
  106.             return false;
  107.         }
  108.         return (string)$this->_attributes[$label];
  109.     }
  110.     
  111.     /**
  112.      *    Sets an attribute.
  113.      *    @param string $label    Attribute name.
  114.      *    @return string $value   New attribute value.
  115.      *    @access protected
  116.      */
  117.     function _setAttribute($label, $value) {
  118.         $this->_attributes[strtolower($label)] = $value;
  119.     }
  120.     
  121.     /**
  122.      *    Accessor for the whole content so far.
  123.      *    @return string       Content as big raw string.
  124.      *    @access public
  125.      */
  126.     function getContent() {
  127.         return $this->_content;
  128.     }
  129.     
  130.     /**
  131.      *    Accessor for content reduced to visible text. Acts
  132.      *    like a text mode browser, normalising space and
  133.      *    reducing images to their alt text.
  134.      *    @return string       Content as plain text.
  135.      *    @access public
  136.      */
  137.     function getText() {
  138.         return SimpleHtmlSaxParser::normalise($this->_content);
  139.     }
  140.     
  141.     /**
  142.      *    Test to see if id attribute matches.
  143.      *    @param string $id        ID to test against.
  144.      *    @return boolean          True on match.
  145.      *    @access public
  146.      */
  147.     function isId($id) {
  148.         return ($this->getAttribute('id') == $id);
  149.     }
  150. }
  151.  
  152. /**
  153.  *    Base url.
  154.  *    @package SimpleTest
  155.  *    @subpackage WebTester
  156.  */
  157. class SimpleBaseTag extends SimpleTag {
  158.     
  159.     /**
  160.      *    Starts with a named tag with attributes only.
  161.      *    @param hash $attributes    Attribute names and
  162.      *                                string values.
  163.      */
  164.     function SimpleBaseTag($attributes) {
  165.         $this->SimpleTag('base', $attributes);
  166.     }
  167.  
  168.     /**
  169.      *    Base tag is not a block tag.
  170.      *    @return boolean       false
  171.      *    @access public
  172.      */
  173.     function expectEndTag() {
  174.         return false;
  175.     }
  176. }
  177.  
  178. /**
  179.  *    Page title.
  180.  *    @package SimpleTest
  181.  *    @subpackage WebTester
  182.  */
  183. class SimpleTitleTag extends SimpleTag {
  184.     
  185.     /**
  186.      *    Starts with a named tag with attributes only.
  187.      *    @param hash $attributes    Attribute names and
  188.      *                                string values.
  189.      */
  190.     function SimpleTitleTag($attributes) {
  191.         $this->SimpleTag('title', $attributes);
  192.     }
  193. }
  194.  
  195. /**
  196.  *    Link.
  197.  *    @package SimpleTest
  198.  *    @subpackage WebTester
  199.  */
  200. class SimpleAnchorTag extends SimpleTag {
  201.     
  202.     /**
  203.      *    Starts with a named tag with attributes only.
  204.      *    @param hash $attributes    Attribute names and
  205.      *                                string values.
  206.      */
  207.     function SimpleAnchorTag($attributes) {
  208.         $this->SimpleTag('a', $attributes);
  209.     }
  210.     
  211.     /**
  212.      *    Accessor for URL as string.
  213.      *    @return string    Coerced as string.
  214.      *    @access public
  215.      */
  216.     function getHref() {
  217.         $url = $this->getAttribute('href');
  218.         if (is_bool($url)) {
  219.             $url = '';
  220.         }
  221.         return $url;
  222.     }
  223. }
  224.  
  225. /**
  226.  *    Form element.
  227.  *    @package SimpleTest
  228.  *    @subpackage WebTester
  229.  */
  230. class SimpleWidget extends SimpleTag {
  231.     var $_value;
  232.     var $_label;
  233.     var $_is_set;
  234.     
  235.     /**
  236.      *    Starts with a named tag with attributes only.
  237.      *    @param string $name        Tag name.
  238.      *    @param hash $attributes    Attribute names and
  239.      *                                string values.
  240.      */
  241.     function SimpleWidget($name, $attributes) {
  242.         $this->SimpleTag($name, $attributes);
  243.         $this->_value = false;
  244.         $this->_label = false;
  245.         $this->_is_set = false;
  246.     }
  247.     
  248.     /**
  249.      *    Accessor for name submitted as the key in
  250.      *    GET/POST variables hash.
  251.      *    @return string        Parsed value.
  252.      *    @access public
  253.      */
  254.     function getName() {
  255.         return $this->getAttribute('name');
  256.     }
  257.     
  258.     /**
  259.      *    Accessor for default value parsed with the tag.
  260.      *    @return string        Parsed value.
  261.      *    @access public
  262.      */
  263.     function getDefault() {
  264.         return $this->getAttribute('value');
  265.     }
  266.     
  267.     /**
  268.      *    Accessor for currently set value or default if
  269.      *    none.
  270.      *    @return string      Value set by form or default
  271.      *                         if none.
  272.      *    @access public
  273.      */
  274.     function getValue() {
  275.         if (! $this->_is_set) {
  276.             return $this->getDefault();
  277.         }
  278.         return $this->_value;
  279.     }
  280.     
  281.     /**
  282.      *    Sets the current form element value.
  283.      *    @param string $value       New value.
  284.      *    @return boolean            True if allowed.
  285.      *    @access public
  286.      */
  287.     function setValue($value) {
  288.         $this->_value = $value;
  289.         $this->_is_set = true;
  290.         return true;
  291.     }
  292.     
  293.     /**
  294.      *    Resets the form element value back to the
  295.      *    default.
  296.      *    @access public
  297.      */
  298.     function resetValue() {
  299.         $this->_is_set = false;
  300.     }
  301.     
  302.     /**
  303.      *    Allows setting of a label externally, say by a
  304.      *    label tag.
  305.      *    @param string $label    Label to attach.
  306.      *    @access public
  307.      */
  308.     function setLabel($label) {
  309.         $this->_label = trim($label);
  310.     }
  311.     
  312.     /**
  313.      *    Reads external or internal label.
  314.      *    @param string $label    Label to test.
  315.      *    @return boolean         True is match.
  316.      *    @access public
  317.      */
  318.     function isLabel($label) {
  319.         return $this->_label == trim($label);
  320.     }
  321.     
  322.     /**
  323.      *    Dispatches the value into the form encoded packet.
  324.      *    @param SimpleEncoding $encoding    Form packet.
  325.      *    @access public
  326.      */
  327.     function write(&$encoding) {
  328.         if ($this->getName()) {
  329.             $encoding->add($this->getName(), $this->getValue());
  330.         }
  331.     }
  332. }
  333.  
  334. /**
  335.  *    Text, password and hidden field.
  336.  *    @package SimpleTest
  337.  *    @subpackage WebTester
  338.  */
  339. class SimpleTextTag extends SimpleWidget {
  340.     
  341.     /**
  342.      *    Starts with a named tag with attributes only.
  343.      *    @param hash $attributes    Attribute names and
  344.      *                                string values.
  345.      */
  346.     function SimpleTextTag($attributes) {
  347.         $this->SimpleWidget('input', $attributes);
  348.         if ($this->getAttribute('value') === false) {
  349.             $this->_setAttribute('value', '');
  350.         }
  351.     }
  352.     
  353.     /**
  354.      *    Tag contains no content.
  355.      *    @return boolean        False.
  356.      *    @access public
  357.      */
  358.     function expectEndTag() {
  359.         return false;
  360.     }
  361.     
  362.     /**
  363.      *    Sets the current form element value. Cannot
  364.      *    change the value of a hidden field.
  365.      *    @param string $value       New value.
  366.      *    @return boolean            True if allowed.
  367.      *    @access public
  368.      */
  369.     function setValue($value) {
  370.         if ($this->getAttribute('type') == 'hidden') {
  371.             return false;
  372.         }
  373.         return parent::setValue($value);
  374.     }
  375. }
  376.  
  377. /**
  378.  *    Submit button as input tag.
  379.  *    @package SimpleTest
  380.  *    @subpackage WebTester
  381.  */
  382. class SimpleSubmitTag extends SimpleWidget {
  383.     
  384.     /**
  385.      *    Starts with a named tag with attributes only.
  386.      *    @param hash $attributes    Attribute names and
  387.      *                                string values.
  388.      */
  389.     function SimpleSubmitTag($attributes) {
  390.         $this->SimpleWidget('input', $attributes);
  391.         if ($this->getAttribute('value') === false) {
  392.             $this->_setAttribute('value', 'Submit');
  393.         }
  394.     }
  395.     
  396.     /**
  397.      *    Tag contains no end element.
  398.      *    @return boolean        False.
  399.      *    @access public
  400.      */
  401.     function expectEndTag() {
  402.         return false;
  403.     }
  404.     
  405.     /**
  406.      *    Disables the setting of the button value.
  407.      *    @param string $value       Ignored.
  408.      *    @return boolean            True if allowed.
  409.      *    @access public
  410.      */
  411.     function setValue($value) {
  412.         return false;
  413.     }
  414.     
  415.     /**
  416.      *    Value of browser visible text.
  417.      *    @return string        Visible label.
  418.      *    @access public
  419.      */
  420.     function getLabel() {
  421.         return $this->getValue();
  422.     }
  423.     
  424.     /**
  425.      *    Test for a label match when searching.
  426.      *    @param string $label     Label to test.
  427.      *    @return boolean          True on match.
  428.      *    @access public
  429.      */
  430.     function isLabel($label) {
  431.         return trim($label) == trim($this->getLabel());
  432.     }
  433. }
  434.     
  435. /**
  436.  *    Image button as input tag.
  437.  *    @package SimpleTest
  438.  *    @subpackage WebTester
  439.  */
  440. class SimpleImageSubmitTag extends SimpleWidget {
  441.     
  442.     /**
  443.      *    Starts with a named tag with attributes only.
  444.      *    @param hash $attributes    Attribute names and
  445.      *                                string values.
  446.      */
  447.     function SimpleImageSubmitTag($attributes) {
  448.         $this->SimpleWidget('input', $attributes);
  449.     }
  450.     
  451.     /**
  452.      *    Tag contains no end element.
  453.      *    @return boolean        False.
  454.      *    @access public
  455.      */
  456.     function expectEndTag() {
  457.         return false;
  458.     }
  459.     
  460.     /**
  461.      *    Disables the setting of the button value.
  462.      *    @param string $value       Ignored.
  463.      *    @return boolean            True if allowed.
  464.      *    @access public
  465.      */
  466.     function setValue($value) {
  467.         return false;
  468.     }
  469.     
  470.     /**
  471.      *    Value of browser visible text.
  472.      *    @return string        Visible label.
  473.      *    @access public
  474.      */
  475.     function getLabel() {
  476.         if ($this->getAttribute('title')) {
  477.             return $this->getAttribute('title');
  478.         }
  479.         return $this->getAttribute('alt');
  480.     }
  481.     
  482.     /**
  483.      *    Test for a label match when searching.
  484.      *    @param string $label     Label to test.
  485.      *    @return boolean          True on match.
  486.      *    @access public
  487.      */
  488.     function isLabel($label) {
  489.         return trim($label) == trim($this->getLabel());
  490.     }
  491.     
  492.     /**
  493.      *    Dispatches the value into the form encoded packet.
  494.      *    @param SimpleEncoding $encoding    Form packet.
  495.      *    @param integer $x                  X coordinate of click.
  496.      *    @param integer $y                  Y coordinate of click.
  497.      *    @access public
  498.      */
  499.     function write(&$encoding, $x, $y) {
  500.         if ($this->getName()) {
  501.             $encoding->add($this->getName() . '.x', $x);
  502.             $encoding->add($this->getName() . '.y', $y);
  503.         } else {
  504.             $encoding->add('x', $x);
  505.             $encoding->add('y', $y);
  506.         }
  507.     }
  508. }
  509.     
  510. /**
  511.  *    Submit button as button tag.
  512.  *    @package SimpleTest
  513.  *    @subpackage WebTester
  514.  */
  515. class SimpleButtonTag extends SimpleWidget {
  516.     
  517.     /**
  518.      *    Starts with a named tag with attributes only.
  519.      *    Defaults are very browser dependent.
  520.      *    @param hash $attributes    Attribute names and
  521.      *                                string values.
  522.      */
  523.     function SimpleButtonTag($attributes) {
  524.         $this->SimpleWidget('button', $attributes);
  525.     }
  526.     
  527.     /**
  528.      *    Check to see if the tag can have both start and
  529.      *    end tags with content in between.
  530.      *    @return boolean        True if content allowed.
  531.      *    @access public
  532.      */
  533.     function expectEndTag() {
  534.         return true;
  535.     }
  536.     
  537.     /**
  538.      *    Disables the setting of the button value.
  539.      *    @param string $value       Ignored.
  540.      *    @return boolean            True if allowed.
  541.      *    @access public
  542.      */
  543.     function setValue($value) {
  544.         return false;
  545.     }
  546.     
  547.     /**
  548.      *    Value of browser visible text.
  549.      *    @return string        Visible label.
  550.      *    @access public
  551.      */
  552.     function getLabel() {
  553.         return $this->getContent();
  554.     }
  555.     
  556.     /**
  557.      *    Test for a label match when searching.
  558.      *    @param string $label     Label to test.
  559.      *    @return boolean          True on match.
  560.      *    @access public
  561.      */
  562.     function isLabel($label) {
  563.         return trim($label) == trim($this->getLabel());
  564.     }
  565. }
  566.  
  567. /**
  568.  *    Content tag for text area.
  569.  *    @package SimpleTest
  570.  *    @subpackage WebTester
  571.  */
  572. class SimpleTextAreaTag extends SimpleWidget {
  573.     
  574.     /**
  575.      *    Starts with a named tag with attributes only.
  576.      *    @param hash $attributes    Attribute names and
  577.      *                                string values.
  578.      */
  579.     function SimpleTextAreaTag($attributes) {
  580.         $this->SimpleWidget('textarea', $attributes);
  581.     }
  582.     
  583.     /**
  584.      *    Accessor for starting value.
  585.      *    @return string        Parsed value.
  586.      *    @access public
  587.      */
  588.     function getDefault() {
  589.         return $this->_wrap(SimpleHtmlSaxParser::decodeHtml($this->getContent()));
  590.     }
  591.     
  592.     /**
  593.      *    Applies word wrapping if needed.
  594.      *    @param string $value      New value.
  595.      *    @return boolean            True if allowed.
  596.      *    @access public
  597.      */
  598.     function setValue($value) {
  599.         return parent::setValue($this->_wrap($value));
  600.     }
  601.     
  602.     /**
  603.      *    Test to see if text should be wrapped.
  604.      *    @return boolean        True if wrapping on.
  605.      *    @access private
  606.      */
  607.     function _wrapIsEnabled() {
  608.         if ($this->getAttribute('cols')) {
  609.             $wrap = $this->getAttribute('wrap');
  610.             if (($wrap == 'physical') || ($wrap == 'hard')) {
  611.                 return true;
  612.             }
  613.         }
  614.         return false;
  615.     }
  616.     
  617.     /**
  618.      *    Performs the formatting that is peculiar to
  619.      *    this tag. There is strange behaviour in this
  620.      *    one, including stripping a leading new line.
  621.      *    Go figure. I am using Firefox as a guide.
  622.      *    @param string $text    Text to wrap.
  623.      *    @return string         Text wrapped with carriage
  624.      *                            returns and line feeds
  625.      *    @access private
  626.      */
  627.     function _wrap($text) {
  628.         $text = str_replace("\r\r\n", "\r\n", str_replace("\n", "\r\n", $text));
  629.         $text = str_replace("\r\n\n", "\r\n", str_replace("\r", "\r\n", $text));
  630.         if (strncmp($text, "\r\n", strlen("\r\n")) == 0) {
  631.             $text = substr($text, strlen("\r\n"));
  632.         }
  633.         if ($this->_wrapIsEnabled()) {
  634.             return wordwrap(
  635.                     $text,
  636.                     (integer)$this->getAttribute('cols'),
  637.                     "\r\n");
  638.         }
  639.         return $text;
  640.     }
  641.     
  642.     /**
  643.      *    The content of textarea is not part of the page.
  644.      *    @return boolean        True.
  645.      *    @access public
  646.      */
  647.     function isPrivateContent() {
  648.         return true;
  649.     }
  650. }
  651.  
  652. /**
  653.  *    File upload widget.
  654.  *    @package SimpleTest
  655.  *    @subpackage WebTester
  656.  */
  657. class SimpleUploadTag extends SimpleWidget {
  658.     
  659.     /**
  660.      *    Starts with attributes only.
  661.      *    @param hash $attributes    Attribute names and
  662.      *                                string values.
  663.      */
  664.     function SimpleUploadTag($attributes) {
  665.         $this->SimpleWidget('input', $attributes);
  666.     }
  667.     
  668.     /**
  669.      *    Tag contains no content.
  670.      *    @return boolean        False.
  671.      *    @access public
  672.      */
  673.     function expectEndTag() {
  674.         return false;
  675.     }
  676.     
  677.     /**
  678.      *    Dispatches the value into the form encoded packet.
  679.      *    @param SimpleEncoding $encoding    Form packet.
  680.      *    @access public
  681.      */
  682.     function write(&$encoding) {
  683.         if (! file_exists($this->getValue())) {
  684.             return;
  685.         }
  686.         $encoding->attach(
  687.                 $this->getName(),
  688.                 implode('', file($this->getValue())),
  689.                 basename($this->getValue()));
  690.     }
  691. }
  692.  
  693. /**
  694.  *    Drop down widget.
  695.  *    @package SimpleTest
  696.  *    @subpackage WebTester
  697.  */
  698. class SimpleSelectionTag extends SimpleWidget {
  699.     var $_options;
  700.     var $_choice;
  701.     
  702.     /**
  703.      *    Starts with attributes only.
  704.      *    @param hash $attributes    Attribute names and
  705.      *                                string values.
  706.      */
  707.     function SimpleSelectionTag($attributes) {
  708.         $this->SimpleWidget('select', $attributes);
  709.         $this->_options = array();
  710.         $this->_choice = false;
  711.     }
  712.     
  713.     /**
  714.      *    Adds an option tag to a selection field.
  715.      *    @param SimpleOptionTag $tag     New option.
  716.      *    @access public
  717.      */
  718.     function addTag(&$tag) {
  719.         if ($tag->getTagName() == 'option') {
  720.             $this->_options[] = &$tag;
  721.         }
  722.     }
  723.     
  724.     /**
  725.      *    Text within the selection element is ignored.
  726.      *    @param string $content        Ignored.
  727.      *    @access public
  728.      */
  729.     function addContent($content) {
  730.     }
  731.     
  732.     /**
  733.      *    Scans options for defaults. If none, then
  734.      *    the first option is selected.
  735.      *    @return string        Selected field.
  736.      *    @access public
  737.      */
  738.     function getDefault() {
  739.         for ($i = 0, $count = count($this->_options); $i < $count; $i++) {
  740.             if ($this->_options[$i]->getAttribute('selected') !== false) {
  741.                 return $this->_options[$i]->getDefault();
  742.             }
  743.         }
  744.         if ($count > 0) {
  745.             return $this->_options[0]->getDefault();
  746.         }
  747.         return '';
  748.     }
  749.     
  750.     /**
  751.      *    Can only set allowed values.
  752.      *    @param string $value       New choice.
  753.      *    @return boolean            True if allowed.
  754.      *    @access public
  755.      */
  756.     function setValue($value) {
  757.         for ($i = 0, $count = count($this->_options); $i < $count; $i++) {
  758.             if ($this->_options[$i]->isValue($value)) {
  759.                 $this->_choice = $i;
  760.                 return true;
  761.             }
  762.         }
  763.         return false;
  764.     }
  765.     
  766.     /**
  767.      *    Accessor for current selection value.
  768.      *    @return string      Value attribute or
  769.      *                         content of opton.
  770.      *    @access public
  771.      */
  772.     function getValue() {
  773.         if ($this->_choice === false) {
  774.             return $this->getDefault();
  775.         }
  776.         return $this->_options[$this->_choice]->getValue();
  777.     }
  778. }
  779.  
  780. /**
  781.  *    Drop down widget.
  782.  *    @package SimpleTest
  783.  *    @subpackage WebTester
  784.  */
  785. class MultipleSelectionTag extends SimpleWidget {
  786.     var $_options;
  787.     var $_values;
  788.     
  789.     /**
  790.      *    Starts with attributes only.
  791.      *    @param hash $attributes    Attribute names and
  792.      *                                string values.
  793.      */
  794.     function MultipleSelectionTag($attributes) {
  795.         $this->SimpleWidget('select', $attributes);
  796.         $this->_options = array();
  797.         $this->_values = false;
  798.     }
  799.     
  800.     /**
  801.      *    Adds an option tag to a selection field.
  802.      *    @param SimpleOptionTag $tag     New option.
  803.      *    @access public
  804.      */
  805.     function addTag(&$tag) {
  806.         if ($tag->getTagName() == 'option') {
  807.             $this->_options[] = &$tag;
  808.         }
  809.     }
  810.     
  811.     /**
  812.      *    Text within the selection element is ignored.
  813.      *    @param string $content        Ignored.
  814.      *    @access public
  815.      */
  816.     function addContent($content) {
  817.     }
  818.     
  819.     /**
  820.      *    Scans options for defaults to populate the
  821.      *    value array().
  822.      *    @return array        Selected fields.
  823.      *    @access public
  824.      */
  825.     function getDefault() {
  826.         $default = array();
  827.         for ($i = 0, $count = count($this->_options); $i < $count; $i++) {
  828.             if ($this->_options[$i]->getAttribute('selected') !== false) {
  829.                 $default[] = $this->_options[$i]->getDefault();
  830.             }
  831.         }
  832.         return $default;
  833.     }
  834.     
  835.     /**
  836.      *    Can only set allowed values. Any illegal value
  837.      *    will result in a failure, but all correct values
  838.      *    will be set.
  839.      *    @param array $desired      New choices.
  840.      *    @return boolean            True if all allowed.
  841.      *    @access public
  842.      */
  843.     function setValue($desired) {
  844.         $achieved = array();
  845.         foreach ($desired as $value) {
  846.             $success = false;
  847.             for ($i = 0, $count = count($this->_options); $i < $count; $i++) {
  848.                 if ($this->_options[$i]->isValue($value)) {
  849.                     $achieved[] = $this->_options[$i]->getValue();
  850.                     $success = true;
  851.                     break;
  852.                 }
  853.             }
  854.             if (! $success) {
  855.                 return false;
  856.             }
  857.         }
  858.         $this->_values = $achieved;
  859.         return true;
  860.     }
  861.     
  862.     /**
  863.      *    Accessor for current selection value.
  864.      *    @return array      List of currently set options.
  865.      *    @access public
  866.      */
  867.     function getValue() {
  868.         if ($this->_values === false) {
  869.             return $this->getDefault();
  870.         }
  871.         return $this->_values;
  872.     }
  873. }
  874.  
  875. /**
  876.  *    Option for selection field.
  877.  *    @package SimpleTest
  878.  *    @subpackage WebTester
  879.  */
  880. class SimpleOptionTag extends SimpleWidget {
  881.     
  882.     /**
  883.      *    Stashes the attributes.
  884.      */
  885.     function SimpleOptionTag($attributes) {
  886.         $this->SimpleWidget('option', $attributes);
  887.     }
  888.     
  889.     /**
  890.      *    Does nothing.
  891.      *    @param string $value      Ignored.
  892.      *    @return boolean           Not allowed.
  893.      *    @access public
  894.      */
  895.     function setValue($value) {
  896.         return false;
  897.     }
  898.     
  899.     /**
  900.      *    Test to see if a value matches the option.
  901.      *    @param string $compare    Value to compare with.
  902.      *    @return boolean           True if possible match.
  903.      *    @access public
  904.      */
  905.     function isValue($compare) {
  906.         $compare = trim($compare);
  907.         if (trim($this->getValue()) == $compare) {
  908.             return true;
  909.         }
  910.         return trim($this->getContent()) == $compare;
  911.     }
  912.     
  913.     /**
  914.      *    Accessor for starting value. Will be set to
  915.      *    the option label if no value exists.
  916.      *    @return string        Parsed value.
  917.      *    @access public
  918.      */
  919.     function getDefault() {
  920.         if ($this->getAttribute('value') === false) {
  921.             return $this->getContent();
  922.         }
  923.         return $this->getAttribute('value');
  924.     }
  925.     
  926.     /**
  927.      *    The content of options is not part of the page.
  928.      *    @return boolean        True.
  929.      *    @access public
  930.      */
  931.     function isPrivateContent() {
  932.         return true;
  933.     }
  934. }
  935.  
  936. /**
  937.  *    Radio button.
  938.  *    @package SimpleTest
  939.  *    @subpackage WebTester
  940.  */
  941. class SimpleRadioButtonTag extends SimpleWidget {
  942.     
  943.     /**
  944.      *    Stashes the attributes.
  945.      *    @param array $attributes        Hash of attributes.
  946.      */
  947.     function SimpleRadioButtonTag($attributes) {
  948.         $this->SimpleWidget('input', $attributes);
  949.         if ($this->getAttribute('value') === false) {
  950.             $this->_setAttribute('value', 'on');
  951.         }
  952.     }
  953.     
  954.     /**
  955.      *    Tag contains no content.
  956.      *    @return boolean        False.
  957.      *    @access public
  958.      */
  959.     function expectEndTag() {
  960.         return false;
  961.     }
  962.     
  963.     /**
  964.      *    The only allowed value sn the one in the
  965.      *    "value" attribute.
  966.      *    @param string $value      New value.
  967.      *    @return boolean           True if allowed.
  968.      *    @access public
  969.      */
  970.     function setValue($value) {
  971.         if ($value === false) {
  972.             return parent::setValue($value);
  973.         }
  974.         if ($value != $this->getAttribute('value')) {
  975.             return false;
  976.         }
  977.         return parent::setValue($value);
  978.     }
  979.     
  980.     /**
  981.      *    Accessor for starting value.
  982.      *    @return string        Parsed value.
  983.      *    @access public
  984.      */
  985.     function getDefault() {
  986.         if ($this->getAttribute('checked') !== false) {
  987.             return $this->getAttribute('value');
  988.         }
  989.         return false;
  990.     }
  991. }
  992.  
  993. /**
  994.  *    Checkbox widget.
  995.  *    @package SimpleTest
  996.  *    @subpackage WebTester
  997.  */
  998. class SimpleCheckboxTag extends SimpleWidget {
  999.     
  1000.     /**
  1001.      *    Starts with attributes only.
  1002.      *    @param hash $attributes    Attribute names and
  1003.      *                                string values.
  1004.      */
  1005.     function SimpleCheckboxTag($attributes) {
  1006.         $this->SimpleWidget('input', $attributes);
  1007.         if ($this->getAttribute('value') === false) {
  1008.             $this->_setAttribute('value', 'on');
  1009.         }
  1010.     }
  1011.     
  1012.     /**
  1013.      *    Tag contains no content.
  1014.      *    @return boolean        False.
  1015.      *    @access public
  1016.      */
  1017.     function expectEndTag() {
  1018.         return false;
  1019.     }
  1020.     
  1021.     /**
  1022.      *    The only allowed value in the one in the
  1023.      *    "value" attribute. The default for this
  1024.      *    attribute is "on". If this widget is set to
  1025.      *    true, then the usual value will be taken.
  1026.      *    @param string $value      New value.
  1027.      *    @return boolean           True if allowed.
  1028.      *    @access public
  1029.      */
  1030.     function setValue($value) {
  1031.         if ($value === false) {
  1032.             return parent::setValue($value);
  1033.         }
  1034.         if ($value === true) {
  1035.             return parent::setValue($this->getAttribute('value'));
  1036.         }
  1037.         if ($value != $this->getAttribute('value')) {
  1038.             return false;
  1039.         }
  1040.         return parent::setValue($value);
  1041.     }
  1042.     
  1043.     /**
  1044.      *    Accessor for starting value. The default
  1045.      *    value is "on".
  1046.      *    @return string        Parsed value.
  1047.      *    @access public
  1048.      */
  1049.     function getDefault() {
  1050.         if ($this->getAttribute('checked') !== false) {
  1051.             return $this->getAttribute('value');
  1052.         }
  1053.         return false;
  1054.     }
  1055. }
  1056.  
  1057. /**
  1058.  *    A group of multiple widgets with some shared behaviour.
  1059.  *    @package SimpleTest
  1060.  *    @subpackage WebTester
  1061.  */
  1062. class SimpleTagGroup {
  1063.     var $_widgets = array();
  1064.  
  1065.     /**
  1066.      *    Adds a tag to the group.
  1067.      *    @param SimpleWidget $widget 
  1068.      *    @access public
  1069.      */
  1070.     function addWidget(&$widget) {
  1071.         $this->_widgets[] = &$widget;
  1072.     }
  1073.     
  1074.     /**
  1075.      *    Accessor to widget set.
  1076.      *    @return array        All widgets.
  1077.      *    @access protected
  1078.      */
  1079.     function &_getWidgets() {
  1080.         return $this->_widgets;
  1081.     }
  1082.  
  1083.     /**
  1084.      *    Accessor for an attribute.
  1085.      *    @param string $label    Attribute name.
  1086.      *    @return boolean         Always false.
  1087.      *    @access public
  1088.      */
  1089.     function getAttribute($label) {
  1090.         return false;
  1091.     }
  1092.     
  1093.     /**
  1094.      *    Fetches the name for the widget from the first
  1095.      *    member.
  1096.      *    @return string        Name of widget.
  1097.      *    @access public
  1098.      */
  1099.     function getName() {
  1100.         if (count($this->_widgets) > 0) {
  1101.             return $this->_widgets[0]->getName();
  1102.         }
  1103.     }
  1104.     
  1105.     /**
  1106.      *    Scans the widgets for one with the appropriate
  1107.      *    ID field.
  1108.      *    @param string $id        ID value to try.
  1109.      *    @return boolean          True if matched.
  1110.      *    @access public
  1111.      */
  1112.     function isId($id) {
  1113.         for ($i = 0, $count = count($this->_widgets); $i < $count; $i++) {
  1114.             if ($this->_widgets[$i]->isId($id)) {
  1115.                 return true;
  1116.             }
  1117.         }
  1118.         return false;
  1119.     }
  1120.     
  1121.     /**
  1122.      *    Scans the widgets for one with the appropriate
  1123.      *    attached label.
  1124.      *    @param string $label     Attached label to try.
  1125.      *    @return boolean          True if matched.
  1126.      *    @access public
  1127.      */
  1128.     function isLabel($label) {
  1129.         for ($i = 0, $count = count($this->_widgets); $i < $count; $i++) {
  1130.             if ($this->_widgets[$i]->isLabel($label)) {
  1131.                 return true;
  1132.             }
  1133.         }
  1134.         return false;
  1135.     }
  1136.     
  1137.     /**
  1138.      *    Dispatches the value into the form encoded packet.
  1139.      *    @param SimpleEncoding $encoding    Form packet.
  1140.      *    @access public
  1141.      */
  1142.     function write(&$encoding) {
  1143.         $encoding->add($this->getName(), $this->getValue());
  1144.     }
  1145. }
  1146.  
  1147. /**
  1148.  *    A group of tags with the same name within a form.
  1149.  *    @package SimpleTest
  1150.  *    @subpackage WebTester
  1151.  */
  1152. class SimpleCheckboxGroup extends SimpleTagGroup {
  1153.     
  1154.     /**
  1155.      *    Accessor for current selected widget or false
  1156.      *    if none.
  1157.      *    @return string/array     Widget values or false if none.
  1158.      *    @access public
  1159.      */
  1160.     function getValue() {
  1161.         $values = array();
  1162.         $widgets = &$this->_getWidgets();
  1163.         for ($i = 0, $count = count($widgets); $i < $count; $i++) {
  1164.             if ($widgets[$i]->getValue() !== false) {
  1165.                 $values[] = $widgets[$i]->getValue();
  1166.             }
  1167.         }
  1168.         return $this->_coerceValues($values);
  1169.     }
  1170.     
  1171.     /**
  1172.      *    Accessor for starting value that is active.
  1173.      *    @return string/array      Widget values or false if none.
  1174.      *    @access public
  1175.      */
  1176.     function getDefault() {
  1177.         $values = array();
  1178.         $widgets = &$this->_getWidgets();
  1179.         for ($i = 0, $count = count($widgets); $i < $count; $i++) {
  1180.             if ($widgets[$i]->getDefault() !== false) {
  1181.                 $values[] = $widgets[$i]->getDefault();
  1182.             }
  1183.         }
  1184.         return $this->_coerceValues($values);
  1185.     }
  1186.     
  1187.     /**
  1188.      *    Accessor for current set values.
  1189.      *    @param string/array/boolean $values   Either a single string, a
  1190.      *                                           hash or false for nothing set.
  1191.      *    @return boolean                       True if all values can be set.
  1192.      *    @access public
  1193.      */
  1194.     function setValue($values) {
  1195.         $values = $this->_makeArray($values);
  1196.         if (! $this->_valuesArePossible($values)) {
  1197.             return false;
  1198.         }
  1199.         $widgets = &$this->_getWidgets();
  1200.         for ($i = 0, $count = count($widgets); $i < $count; $i++) {
  1201.             $possible = $widgets[$i]->getAttribute('value');
  1202.             if (in_array($widgets[$i]->getAttribute('value'), $values)) {
  1203.                 $widgets[$i]->setValue($possible);
  1204.             } else {
  1205.                 $widgets[$i]->setValue(false);
  1206.             }
  1207.         }
  1208.         return true;
  1209.     }
  1210.     
  1211.     /**
  1212.      *    Tests to see if a possible value set is legal.
  1213.      *    @param string/array/boolean $values   Either a single string, a
  1214.      *                                           hash or false for nothing set.
  1215.      *    @return boolean                       False if trying to set a
  1216.      *                                           missing value.
  1217.      *    @access private
  1218.      */
  1219.     function _valuesArePossible($values) {
  1220.         $matches = array();
  1221.         $widgets = &$this->_getWidgets();
  1222.         for ($i = 0, $count = count($widgets); $i < $count; $i++) {
  1223.             $possible = $widgets[$i]->getAttribute('value');
  1224.             if (in_array($possible, $values)) {
  1225.                 $matches[] = $possible;
  1226.             }
  1227.         }
  1228.         return ($values == $matches);
  1229.     }
  1230.     
  1231.     /**
  1232.      *    Converts the output to an appropriate format. This means
  1233.      *    that no values is false, a single value is just that
  1234.      *    value and only two or more are contained in an array.
  1235.      *    @param array $values           List of values of widgets.
  1236.      *    @return string/array/boolean   Expected format for a tag.
  1237.      *    @access private
  1238.      */
  1239.     function _coerceValues($values) {
  1240.         if (count($values) == 0) {
  1241.             return false;
  1242.         } elseif (count($values) == 1) {
  1243.             return $values[0];
  1244.         } else {
  1245.             return $values;
  1246.         }
  1247.     }
  1248.     
  1249.     /**
  1250.      *    Converts false or string into array. The opposite of
  1251.      *    the coercian method.
  1252.      *    @param string/array/boolean $value  A single item is converted
  1253.      *                                         to a one item list. False
  1254.      *                                         gives an empty list.
  1255.      *    @return array                       List of values, possibly empty.
  1256.      *    @access private
  1257.      */
  1258.     function _makeArray($value) {
  1259.         if ($value === false) {
  1260.             return array();
  1261.         }
  1262.         if (is_string($value)) {
  1263.             return array($value);
  1264.         }
  1265.         return $value;
  1266.     }
  1267. }
  1268.  
  1269. /**
  1270.  *    A group of tags with the same name within a form.
  1271.  *    Used for radio buttons.
  1272.  *    @package SimpleTest
  1273.  *    @subpackage WebTester
  1274.  */
  1275. class SimpleRadioGroup extends SimpleTagGroup {
  1276.     
  1277.     /**
  1278.      *    Each tag is tried in turn until one is
  1279.      *    successfully set. The others will be
  1280.      *    unchecked if successful.
  1281.      *    @param string $value      New value.
  1282.      *    @return boolean           True if any allowed.
  1283.      *    @access public
  1284.      */
  1285.     function setValue($value) {
  1286.         if (! $this->_valueIsPossible($value)) {
  1287.             return false;
  1288.         }
  1289.         $index = false;
  1290.         $widgets = &$this->_getWidgets();
  1291.         for ($i = 0, $count = count($widgets); $i < $count; $i++) {
  1292.             if (! $widgets[$i]->setValue($value)) {
  1293.                 $widgets[$i]->setValue(false);
  1294.             }
  1295.         }
  1296.         return true;
  1297.     }
  1298.     
  1299.     /**
  1300.      *    Tests to see if a value is allowed.
  1301.      *    @param string    Attempted value.
  1302.      *    @return boolean  True if a valid value.
  1303.      *    @access private
  1304.      */
  1305.     function _valueIsPossible($value) {
  1306.         $widgets = &$this->_getWidgets();
  1307.         for ($i = 0, $count = count($widgets); $i < $count; $i++) {
  1308.             if ($widgets[$i]->getAttribute('value') == $value) {
  1309.                 return true;
  1310.             }
  1311.         }
  1312.         return false;
  1313.     }
  1314.     
  1315.     /**
  1316.      *    Accessor for current selected widget or false
  1317.      *    if none.
  1318.      *    @return string/boolean   Value attribute or
  1319.      *                              content of opton.
  1320.      *    @access public
  1321.      */
  1322.     function getValue() {
  1323.         $widgets = &$this->_getWidgets();
  1324.         for ($i = 0, $count = count($widgets); $i < $count; $i++) {
  1325.             if ($widgets[$i]->getValue() !== false) {
  1326.                 return $widgets[$i]->getValue();
  1327.             }
  1328.         }
  1329.         return false;
  1330.     }
  1331.     
  1332.     /**
  1333.      *    Accessor for starting value that is active.
  1334.      *    @return string/boolean      Value of first checked
  1335.      *                                 widget or false if none.
  1336.      *    @access public
  1337.      */
  1338.     function getDefault() {
  1339.         $widgets = &$this->_getWidgets();
  1340.         for ($i = 0, $count = count($widgets); $i < $count; $i++) {
  1341.             if ($widgets[$i]->getDefault() !== false) {
  1342.                 return $widgets[$i]->getDefault();
  1343.             }
  1344.         }
  1345.         return false;
  1346.     }
  1347. }
  1348.  
  1349. /**
  1350.  *    Tag to keep track of labels.
  1351.  *    @package SimpleTest
  1352.  *    @subpackage WebTester
  1353.  */
  1354. class SimpleLabelTag extends SimpleTag {
  1355.     
  1356.     /**
  1357.      *    Starts with a named tag with attributes only.
  1358.      *    @param hash $attributes    Attribute names and
  1359.      *                                string values.
  1360.      */
  1361.     function SimpleLabelTag($attributes) {
  1362.         $this->SimpleTag('label', $attributes);
  1363.     }
  1364.     
  1365.     /**
  1366.      *    Access for the ID to attach the label to.
  1367.      *    @return string        For attribute.
  1368.      *    @access public
  1369.      */
  1370.     function getFor() {
  1371.         return $this->getAttribute('for');
  1372.     }
  1373. }
  1374.  
  1375. /**
  1376.  *    Tag to aid parsing the form.
  1377.  *    @package SimpleTest
  1378.  *    @subpackage WebTester
  1379.  */
  1380. class SimpleFormTag extends SimpleTag {
  1381.     
  1382.     /**
  1383.      *    Starts with a named tag with attributes only.
  1384.      *    @param hash $attributes    Attribute names and
  1385.      *                                string values.
  1386.      */
  1387.     function SimpleFormTag($attributes) {
  1388.         $this->SimpleTag('form', $attributes);
  1389.     }
  1390. }
  1391.  
  1392. /**
  1393.  *    Tag to aid parsing the frames in a page.
  1394.  *    @package SimpleTest
  1395.  *    @subpackage WebTester
  1396.  */
  1397. class SimpleFrameTag extends SimpleTag {
  1398.     
  1399.     /**
  1400.      *    Starts with a named tag with attributes only.
  1401.      *    @param hash $attributes    Attribute names and
  1402.      *                                string values.
  1403.      */
  1404.     function SimpleFrameTag($attributes) {
  1405.         $this->SimpleTag('frame', $attributes);
  1406.     }
  1407.     
  1408.     /**
  1409.      *    Tag contains no content.
  1410.      *    @return boolean        False.
  1411.      *    @access public
  1412.      */
  1413.     function expectEndTag() {
  1414.         return false;
  1415.     }
  1416. }
  1417. ?>

Documentation generated on Sun, 04 May 2008 09:22:14 -0500 by phpDocumentor 1.3.0