Source for file encoding.php

Documentation is available at encoding.php

  1. <?php
  2. /**
  3.  *  base include file for SimpleTest
  4.  *  @package    SimpleTest
  5.  *  @subpackage WebTester
  6.  *  @version    $Id: encoding.php 1964 2009-10-13 15:27:31Z maetl_ $
  7.  */
  8.     
  9. /**#@+
  10.  *  include other SimpleTest class files
  11.  */
  12. require_once(dirname(__FILE__) . '/socket.php');
  13. /**#@-*/
  14.  
  15. /**
  16.  *    Single post parameter.
  17.  *    @package SimpleTest
  18.  *    @subpackage WebTester
  19.  */
  20. class SimpleEncodedPair {
  21.     private $key;
  22.     private $value;
  23.     
  24.     /**
  25.      *    Stashes the data for rendering later.
  26.      *    @param string $key       Form element name.
  27.      *    @param string $value     Data to send.
  28.      */
  29.     function __construct($key, $value) {
  30.         $this->key = $key;
  31.         $this->value = $value;
  32.     }
  33.     
  34.     /**
  35.      *    The pair as a single string.
  36.      *    @return string        Encoded pair.
  37.      *    @access public
  38.      */
  39.     function asRequest() {
  40.         return urlencode($this->key) . '=' . urlencode($this->value);
  41.     }
  42.     
  43.     /**
  44.      *    The MIME part as a string.
  45.      *    @return string        MIME part encoding.
  46.      *    @access public
  47.      */
  48.     function asMime() {
  49.         $part = 'Content-Disposition: form-data; ';
  50.         $part .= "name=\"" . $this->key . "\"\r\n";
  51.         $part .= "\r\n" . $this->value;
  52.         return $part;
  53.     }
  54.     
  55.     /**
  56.      *    Is this the value we are looking for?
  57.      *    @param string $key    Identifier.
  58.      *    @return boolean       True if matched.
  59.      *    @access public
  60.      */
  61.     function isKey($key) {
  62.         return $key == $this->key;
  63.     }
  64.     
  65.     /**
  66.      *    Is this the value we are looking for?
  67.      *    @return string       Identifier.
  68.      *    @access public
  69.      */
  70.     function getKey() {
  71.         return $this->key;
  72.     }
  73.     
  74.     /**
  75.      *    Is this the value we are looking for?
  76.      *    @return string       Content.
  77.      *    @access public
  78.      */
  79.     function getValue() {
  80.         return $this->value;
  81.     }
  82. }
  83.  
  84. /**
  85.  *    Single post parameter.
  86.  *    @package SimpleTest
  87.  *    @subpackage WebTester
  88.  */
  89. class SimpleAttachment {
  90.     private $key;
  91.     private $content;
  92.     private $filename;
  93.     
  94.     /**
  95.      *    Stashes the data for rendering later.
  96.      *    @param string $key          Key to add value to.
  97.      *    @param string $content      Raw data.
  98.      *    @param hash $filename       Original filename.
  99.      */
  100.     function __construct($key, $content, $filename) {
  101.         $this->key = $key;
  102.         $this->content = $content;
  103.         $this->filename = $filename;
  104.     }
  105.     
  106.     /**
  107.      *    The pair as a single string.
  108.      *    @return string        Encoded pair.
  109.      *    @access public
  110.      */
  111.     function asRequest() {
  112.         return '';
  113.     }
  114.     
  115.     /**
  116.      *    The MIME part as a string.
  117.      *    @return string        MIME part encoding.
  118.      *    @access public
  119.      */
  120.     function asMime() {
  121.         $part = 'Content-Disposition: form-data; ';
  122.         $part .= 'name="' . $this->key . '"; ';
  123.         $part .= 'filename="' . $this->filename . '"';
  124.         $part .= "\r\nContent-Type: " . $this->deduceMimeType();
  125.         $part .= "\r\n\r\n" . $this->content;
  126.         return $part;
  127.     }
  128.     
  129.     /**
  130.      *    Attempts to figure out the MIME type from the
  131.      *    file extension and the content.
  132.      *    @return string        MIME type.
  133.      *    @access private
  134.      */
  135.     protected function deduceMimeType() {
  136.         if ($this->isOnlyAscii($this->content)) {
  137.             return 'text/plain';
  138.         }
  139.         return 'application/octet-stream';
  140.     }
  141.     
  142.     /**
  143.      *    Tests each character is in the range 0-127.
  144.      *    @param string $ascii    String to test.
  145.      *    @access private
  146.      */
  147.     protected function isOnlyAscii($ascii) {
  148.         for ($i = 0, $length = strlen($ascii); $i < $length; $i++) {
  149.             if (ord($ascii[$i]) > 127) {
  150.                 return false;
  151.             }
  152.         }
  153.         return true;
  154.     }
  155.     
  156.     /**
  157.      *    Is this the value we are looking for?
  158.      *    @param string $key    Identifier.
  159.      *    @return boolean       True if matched.
  160.      *    @access public
  161.      */
  162.     function isKey($key) {
  163.         return $key == $this->key;
  164.     }
  165.     
  166.     /**
  167.      *    Is this the value we are looking for?
  168.      *    @return string       Identifier.
  169.      *    @access public
  170.      */
  171.     function getKey() {
  172.         return $this->key;
  173.     }
  174.     
  175.     /**
  176.      *    Is this the value we are looking for?
  177.      *    @return string       Content.
  178.      *    @access public
  179.      */
  180.     function getValue() {
  181.         return $this->filename;
  182.     }
  183. }
  184.  
  185. /**
  186.  *    Bundle of GET/POST parameters. Can include
  187.  *    repeated parameters.
  188.  *    @package SimpleTest
  189.  *    @subpackage WebTester
  190.  */
  191. class SimpleEncoding {
  192.     private $request;
  193.     
  194.     /**
  195.      *    Starts empty.
  196.      *    @param array $query       Hash of parameters.
  197.      *                               Multiple values are
  198.      *                               as lists on a single key.
  199.      *    @access public
  200.      */
  201.     function __construct($query = false) {
  202.         if (! $query) {
  203.             $query = array();
  204.         }
  205.         $this->clear();
  206.         $this->merge($query);
  207.     }
  208.     
  209.     /**
  210.      *    Empties the request of parameters.
  211.      *    @access public
  212.      */
  213.     function clear() {
  214.         $this->request = array();
  215.     }
  216.     
  217.     /**
  218.      *    Adds a parameter to the query.
  219.      *    @param string $key            Key to add value to.
  220.      *    @param string/array $value    New data.
  221.      *    @access public
  222.      */
  223.     function add($key, $value) {
  224.         if ($value === false) {
  225.             return;
  226.         }
  227.         if (is_array($value)) {
  228.             foreach ($value as $item) {
  229.                 $this->addPair($key, $item);
  230.             }
  231.         } else {
  232.             $this->addPair($key, $value);
  233.         }
  234.     }
  235.     
  236.     /**
  237.      *    Adds a new value into the request.
  238.      *    @param string $key            Key to add value to.
  239.      *    @param string/array $value    New data.
  240.      *    @access private
  241.      */
  242.     protected function addPair($key, $value) {
  243.         $this->request[] = new SimpleEncodedPair($key, $value);
  244.     }
  245.     
  246.     /**
  247.      *    Adds a MIME part to the query. Does nothing for a
  248.      *    form encoded packet.
  249.      *    @param string $key          Key to add value to.
  250.      *    @param string $content      Raw data.
  251.      *    @param hash $filename       Original filename.
  252.      *    @access public
  253.      */
  254.     function attach($key, $content, $filename) {
  255.         $this->request[] = new SimpleAttachment($key, $content, $filename);
  256.     }
  257.     
  258.     /**
  259.      *    Adds a set of parameters to this query.
  260.      *    @param array/SimpleQueryString $query  Multiple values are
  261.      *                                            as lists on a single key.
  262.      *    @access public
  263.      */
  264.     function merge($query) {
  265.         if (is_object($query)) {
  266.             $this->request = array_merge($this->request, $query->getAll());
  267.         } elseif (is_array($query)) {
  268.             foreach ($query as $key => $value) {
  269.                 $this->add($key, $value);
  270.             }
  271.         }
  272.     }
  273.     
  274.     /**
  275.      *    Accessor for single value.
  276.      *    @return string/array    False if missing, string
  277.      *                             if present and array if
  278.      *                             multiple entries.
  279.      *    @access public
  280.      */
  281.     function getValue($key) {
  282.         $values = array();
  283.         foreach ($this->request as $pair) {
  284.             if ($pair->isKey($key)) {
  285.                 $values[] = $pair->getValue();
  286.             }
  287.         }
  288.         if (count($values) == 0) {
  289.             return false;
  290.         } elseif (count($values) == 1) {
  291.             return $values[0];
  292.         } else {
  293.             return $values;
  294.         }
  295.     }
  296.     
  297.     /**
  298.      *    Accessor for listing of pairs.
  299.      *    @return array        All pair objects.
  300.      *    @access public
  301.      */
  302.     function getAll() {
  303.         return $this->request;
  304.     }
  305.     
  306.     /**
  307.      *    Renders the query string as a URL encoded
  308.      *    request part.
  309.      *    @return string        Part of URL.
  310.      *    @access protected
  311.      */
  312.     protected function encode() {
  313.         $statements = array();
  314.         foreach ($this->request as $pair) {
  315.             if ($statement = $pair->asRequest()) {
  316.                 $statements[] = $statement;
  317.             }
  318.         }
  319.         return implode('&', $statements);
  320.     }
  321. }
  322.  
  323. /**
  324.  *    Bundle of GET parameters. Can include
  325.  *    repeated parameters.
  326.  *    @package SimpleTest
  327.  *    @subpackage WebTester
  328.  */
  329. class SimpleGetEncoding extends SimpleEncoding {
  330.     
  331.     /**
  332.      *    Starts empty.
  333.      *    @param array $query       Hash of parameters.
  334.      *                               Multiple values are
  335.      *                               as lists on a single key.
  336.      *    @access public
  337.      */
  338.     function __construct($query = false) {
  339.         parent::__construct($query);
  340.     }
  341.     
  342.     /**
  343.      *    HTTP request method.
  344.      *    @return string        Always GET.
  345.      *    @access public
  346.      */
  347.     function getMethod() {
  348.         return 'GET';
  349.     }
  350.     
  351.     /**
  352.      *    Writes no extra headers.
  353.      *    @param SimpleSocket $socket        Socket to write to.
  354.      *    @access public
  355.      */
  356.     function writeHeadersTo(&$socket) {
  357.     }
  358.     
  359.     /**
  360.      *    No data is sent to the socket as the data is encoded into
  361.      *    the URL.
  362.      *    @param SimpleSocket $socket        Socket to write to.
  363.      *    @access public
  364.      */
  365.     function writeTo(&$socket) {
  366.     }
  367.     
  368.     /**
  369.      *    Renders the query string as a URL encoded
  370.      *    request part for attaching to a URL.
  371.      *    @return string        Part of URL.
  372.      *    @access public
  373.      */
  374.     function asUrlRequest() {
  375.         return $this->encode();
  376.     }
  377. }
  378.  
  379. /**
  380.  *    Bundle of URL parameters for a HEAD request.
  381.  *    @package SimpleTest
  382.  *    @subpackage WebTester
  383.  */
  384. class SimpleHeadEncoding extends SimpleGetEncoding {
  385.     
  386.     /**
  387.      *    Starts empty.
  388.      *    @param array $query       Hash of parameters.
  389.      *                               Multiple values are
  390.      *                               as lists on a single key.
  391.      *    @access public
  392.      */
  393.     function __construct($query = false) {
  394.         parent::__construct($query);
  395.     }
  396.     
  397.     /**
  398.      *    HTTP request method.
  399.      *    @return string        Always HEAD.
  400.      *    @access public
  401.      */
  402.     function getMethod() {
  403.         return 'HEAD';
  404.     }
  405. }
  406.  
  407. /**
  408.  *    Bundle of URL parameters for a DELETE request.
  409.  *    @package SimpleTest
  410.  *    @subpackage WebTester
  411.  */
  412. class SimpleDeleteEncoding extends SimpleGetEncoding {
  413.     
  414.     /**
  415.      *    Starts empty.
  416.      *    @param array $query       Hash of parameters.
  417.      *                               Multiple values are
  418.      *                               as lists on a single key.
  419.      *    @access public
  420.      */
  421.     function __construct($query = false) {
  422.         parent::__construct($query);
  423.     }
  424.     
  425.     /**
  426.      *    HTTP request method.
  427.      *    @return string        Always DELETE.
  428.      *    @access public
  429.      */
  430.     function getMethod() {
  431.         return 'DELETE';
  432.     }
  433. }
  434.  
  435. /**
  436.  *    Bundles an entity-body for transporting
  437.  *    a raw content payload with the request.
  438.  *    @package SimpleTest
  439.  *    @subpackage WebTester
  440.  */
  441. class SimpleEntityEncoding extends SimpleEncoding {
  442.     private $content_type;
  443.     private $body;
  444.     
  445.     function __construct($query = false, $content_type = false) {
  446.         $this->content_type = $content_type;
  447.         if (is_string($query)) {
  448.             $this->body = $query;
  449.             parent::__construct();
  450.         } else {
  451.             parent::__construct($query);
  452.         }
  453.     }
  454.     
  455.     /**
  456.      *    Returns the media type of the entity body
  457.      *    @return string 
  458.      *    @access public
  459.      */
  460.     function getContentType() {
  461.         if (!$this->content_type) {
  462.             return ($this->body) ? 'text/plain' : 'application/x-www-form-urlencoded';
  463.         }
  464.         return $this->content_type;
  465.     }
  466.        
  467.     /**
  468.      *    Dispatches the form headers down the socket.
  469.      *    @param SimpleSocket $socket        Socket to write to.
  470.      *    @access public
  471.      */
  472.     function writeHeadersTo(&$socket) {
  473.         $socket->write("Content-Length: " . (integer)strlen($this->encode()) . "\r\n");
  474.         $socket->write("Content-Type: " .  $this->getContentType() . "\r\n");
  475.     }
  476.     
  477.     /**
  478.      *    Dispatches the form data down the socket.
  479.      *    @param SimpleSocket $socket        Socket to write to.
  480.      *    @access public
  481.      */
  482.     function writeTo(&$socket) {
  483.         $socket->write($this->encode());
  484.     }
  485.     
  486.     /**
  487.      *    Renders the request body
  488.      *    @return Encoded entity body
  489.      *    @access protected
  490.      */
  491.     protected function encode() {
  492.         return ($this->body) ? $this->body : parent::encode();
  493.     }
  494. }
  495.  
  496. /**
  497.  *    Bundle of POST parameters. Can include
  498.  *    repeated parameters.
  499.  *    @package SimpleTest
  500.  *    @subpackage WebTester
  501.  */
  502. class SimplePostEncoding extends SimpleEntityEncoding {
  503.     
  504.     /**
  505.      *    Starts empty.
  506.      *    @param array $query       Hash of parameters.
  507.      *                               Multiple values are
  508.      *                               as lists on a single key.
  509.      *    @access public
  510.      */
  511.     function __construct($query = false, $content_type = false) {
  512.         if (is_array($query) and $this->hasMoreThanOneLevel($query)) {
  513.             $query = $this->rewriteArrayWithMultipleLevels($query);
  514.         }
  515.         parent::__construct($query, $content_type);
  516.     }
  517.     
  518.     function hasMoreThanOneLevel($query) {
  519.         foreach ($query as $key => $value) {
  520.             if (is_array($value)) {
  521.                 return true;
  522.             }
  523.         }
  524.         return false;
  525.     }
  526.  
  527.     function rewriteArrayWithMultipleLevels($query) {
  528.         $query_ = array();
  529.         foreach ($query as $key => $value) {
  530.             if (is_array($value)) {
  531.                 foreach ($value as $sub_key => $sub_value) {
  532.                     $query_[$key."[".$sub_key."]"] = $sub_value;
  533.                 }
  534.             } else {
  535.                 $query_[$key] = $value;
  536.             }
  537.         }
  538.         if ($this->hasMoreThanOneLevel($query_)) {
  539.             $query_ = $this->rewriteArrayWithMultipleLevels($query_);
  540.         }
  541.         
  542.         return $query_;
  543.     }
  544.     
  545.     /**
  546.      *    HTTP request method.
  547.      *    @return string        Always POST.
  548.      *    @access public
  549.      */
  550.     function getMethod() {
  551.         return 'POST';
  552.     }
  553.     
  554.     /**
  555.      *    Renders the query string as a URL encoded
  556.      *    request part for attaching to a URL.
  557.      *    @return string        Part of URL.
  558.      *    @access public
  559.      */
  560.     function asUrlRequest() {
  561.         return '';
  562.     }
  563. }
  564.  
  565. /**
  566.  *    Encoded entity body for a PUT request.
  567.  *    @package SimpleTest
  568.  *    @subpackage WebTester
  569.  */
  570. class SimplePutEncoding extends SimpleEntityEncoding {
  571.     
  572.     /**
  573.      *    Starts empty.
  574.      *    @param array $query       Hash of parameters.
  575.      *                               Multiple values are
  576.      *                               as lists on a single key.
  577.      *    @access public
  578.      */
  579.     function __construct($query = false, $content_type = false) {
  580.         parent::__construct($query, $content_type);
  581.     }
  582.     
  583.     /**
  584.      *    HTTP request method.
  585.      *    @return string        Always PUT.
  586.      *    @access public
  587.      */
  588.     function getMethod() {
  589.         return 'PUT';
  590.     }
  591. }
  592.  
  593. /**
  594.  *    Bundle of POST parameters in the multipart
  595.  *    format. Can include file uploads.
  596.  *    @package SimpleTest
  597.  *    @subpackage WebTester
  598.  */
  599. class SimpleMultipartEncoding extends SimplePostEncoding {
  600.     private $boundary;
  601.     
  602.     /**
  603.      *    Starts empty.
  604.      *    @param array $query       Hash of parameters.
  605.      *                               Multiple values are
  606.      *                               as lists on a single key.
  607.      *    @access public
  608.      */
  609.     function __construct($query = false, $boundary = false) {
  610.         parent::__construct($query);
  611.         $this->boundary = ($boundary === false ? uniqid('st') : $boundary);
  612.     }
  613.     
  614.     /**
  615.      *    Dispatches the form headers down the socket.
  616.      *    @param SimpleSocket $socket        Socket to write to.
  617.      *    @access public
  618.      */
  619.     function writeHeadersTo(&$socket) {
  620.         $socket->write("Content-Length: " . (integer)strlen($this->encode()) . "\r\n");
  621.         $socket->write("Content-Type: multipart/form-data; boundary=" . $this->boundary . "\r\n");
  622.     }
  623.     
  624.     /**
  625.      *    Dispatches the form data down the socket.
  626.      *    @param SimpleSocket $socket        Socket to write to.
  627.      *    @access public
  628.      */
  629.     function writeTo(&$socket) {
  630.         $socket->write($this->encode());
  631.     }
  632.     
  633.     /**
  634.      *    Renders the query string as a URL encoded
  635.      *    request part.
  636.      *    @return string        Part of URL.
  637.      *    @access public
  638.      */
  639.     function encode() {
  640.         $stream = '';
  641.         foreach ($this->getAll() as $pair) {
  642.             $stream .= "--" . $this->boundary . "\r\n";
  643.             $stream .= $pair->asMime() . "\r\n";
  644.         }
  645.         $stream .= "--" . $this->boundary . "--\r\n";
  646.         return $stream;
  647.     }
  648. }
  649. ?>

Documentation generated on Sun, 31 Oct 2010 16:31:19 -0500 by phpDocumentor 1.4.3