├── README.md
├── RequestObject.php
├── test1.php
├── test2.php
├── test3.php
├── test4.php
├── test5.php
└── test6.php


/README.md:
--------------------------------------------------------------------------------
  1 | # Example 1: simple example</h2>
  2 |     class Request1 extends RequestObject
  3 |     {
  4 |         public $param1;
  5 |     }
  6 | 
  7 |     $request = new Request1();
  8 |     echo "param1: " . $request->param1 . '<p/>';
  9 | 
 10 | output:
 11 | 
 12 |     test1.php?param1=11212
 13 |     param1: 11212
 14 | 
 15 |     test1.php?param1=hi
 16 |     param1: hi
 17 | 
 18 | 
 19 | # Example 2: data types and default values
 20 | 
 21 | ```php
 22 | <?php
 23 | class Request2 extends RequestObject
 24 | {
 25 |     /**
 26 |      * @cast string
 27 |      */
 28 |     public $param1;
 29 |     /**
 30 |      * @cast string
 31 |      * @default default value
 32 |      */
 33 |     public $param2;
 34 | }
 35 | 
 36 | $request = new Request2();
 37 | 
 38 | echo "param1: <br/>";
 39 | var_dump($request->param1);
 40 | echo "<br/>";
 41 | 
 42 | echo "param2: <br/>";
 43 | var_dump($request->param2);
 44 | echo "<br/>";
 45 | ```
 46 | 
 47 | output:
 48 | 
 49 |     test2.php?param1=hi&amp;param2=1
 50 | 
 51 |     param1: string(2) "hi"
 52 |     param2: string(1) "1"
 53 | 
 54 |     test2.php?param1=1&amp;param2=hi
 55 | 
 56 |     param1: string(1) "1"
 57 |     param2: string(2) "hi"
 58 | 
 59 |     test2.php?param1=1
 60 |     param1: string(1) "1"
 61 |     param2: string(13) "default value"
 62 | 
 63 | # Example 3: validadors
 64 | ```php
 65 | <?php
 66 | class Request3 extends RequestObject
 67 | {
 68 |     /** @cast string */
 69 |     public $param1;
 70 |     /** @cast integer */
 71 |     public $param2;
 72 | 
 73 |     protected function validate_param1(&$value)
 74 |     {
 75 |         $value = strrev($value);
 76 |     }
 77 |     
 78 |     protected function validate_param2($value)
 79 |     {
 80 |         if ($value == 1) {
 81 |             return false;
 82 |         }
 83 |     }
 84 | }
 85 | try {
 86 |     $request = new Request3();
 87 | 
 88 |     echo "param1: <br/>";
 89 |     var_dump($request->param1);
 90 |     echo "<br/>";
 91 | 
 92 |     echo "param2: <br/>";
 93 |     var_dump($request->param2);
 94 |     echo "<br/>";
 95 | } catch (RequestObjectException $e) {
 96 |     echo $e->getMessage();
 97 |     echo "<br/>";
 98 |     var_dump($e->getValidationErrors());
 99 | }
100 | ```
101 | 
102 | output:
103 | 
104 |     test3.php?param2=2&amp;param1=hi
105 |     param1: string(2) "ih"
106 |     param2: int(2)
107 | 
108 |     test3.php?param1=hola&amp;param2=1
109 |     Validation error
110 |     array(1) { ["param2"]=&gt; array(1) { ["value"]=&gt; int(1) } }
111 | 
112 | # Example 4: Dynamic validations
113 | 
114 | ```php
115 | <?php
116 | class Request4 extends RequestObject
117 | {
118 |     /** @cast string */
119 |     public $param1;
120 |     /** @cast integer */
121 |     public $param2;
122 | }
123 | 
124 | $request = new Request4(false); // disables perform validation on contructor
125 |                                // it means it will not raise any validation exception
126 | $request->appendValidateTo('param2', function($value) {
127 |         if ($value == 1) {
128 |             return false;
129 |         }
130 |     });
131 | 
132 | try {
133 |     $request->validateAll(); // now we perform the validation
134 | 
135 |     echo "param1: <br/>";
136 |     var_dump($request->param1);
137 |     echo "<br/>";
138 | 
139 |     echo "param2: <br/>";
140 |     var_dump($request->param2);
141 |     echo "<br/>";
142 | } catch (RequestObjectException $e) {
143 |     echo $e->getMessage();
144 |     echo "<br/>";
145 |     var_dump($e->getValidationErrors());
146 | }
147 | ```
148 | 
149 | output:
150 | 
151 |     test4.php?param1=hi&amp;param2=2
152 |     param1: string(4) "hi"
153 |     param2: int(2)
154 | 
155 |     test4.php?param1=hola&amp;param2=1
156 |     Validation error
157 |     array(1) { ["param2"]=&gt; array(1) { ["value"]=&gt; int(1) } }
158 | 
159 | 
160 | 
161 | # Example 5: Arrays and default params
162 | 
163 | ```php
164 | <?php
165 | class Request5 extends RequestObject
166 | {
167 |     /** @cast arrayString */
168 |     public $param1;
169 | 
170 |     /** @cast integer */
171 |     public $param2;
172 | 
173 |     /**
174 |      * @cast arrayString
175 |      * @defaultArray "hello", "world"
176 |      */
177 |     public $param3;
178 | 
179 |     protected function validate_param2(&$value)
180 |     {
181 |         $value++;
182 |     }
183 | }
184 | 
185 | $request = new Request5();
186 | 
187 | echo "<p>param1: </p>";
188 | var_dump($request->param1);
189 | 
190 | echo "<p>param2: </p>";
191 | var_dump($request->param2);
192 | 
193 | echo "<p>param3: </p>";
194 | var_dump($request->param3);
195 | ```
196 | 
197 | output:
198 | 
199 |     test5.php?param1[]=1&amp;param1[]=2&amp;param2[]=hi
200 |     param1: array(2) { [0]=&gt; int(1) [1]=&gt; int(2) }
201 |     param2: int(1)
202 |     param3: array(2) { [0]=&gt; string(5) "hello" [1]=&gt; string(5) "world" }
203 | 
204 |     test5.php?param1[]=1&amp;param1[]=2&amp;param2=2
205 |     param1: array(2) { [0]=&gt; string(1) "1" [1]=&gt; string(1) "2" }
206 |     param2: int(3)
207 |     param3: array(2) { [0]=&gt; string(5) "hello" [1]=&gt; string(5) "world" }
208 | 


--------------------------------------------------------------------------------
/RequestObject.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * THIS PROGRAM COMES WITH ABSOLUTELY NO WARANTIES !
  4 |  * USE IT AT YOUR OWN RISKS !
  5 |  *
  6 |  * @author Gonzalo Ayuso <gonzalo123@gmail.com>
  7 |  *
  8 |  * @copyright under GPL 2 licence
  9 |  */
 10 | class RequestObjectException extends Exception
 11 | {
 12 |     private $validationErrors = array();
 13 |     function __construct($message, $validationErrors)
 14 |     {
 15 |         $this->validationErrors = $validationErrors;
 16 |         parent::__construct($message);
 17 |     }
 18 | 
 19 |     public function getValidationErrors()
 20 |     {
 21 |         return $this->validationErrors;
 22 |     }
 23 | }
 24 | 
 25 | abstract class RequestObject
 26 | {
 27 |     private $parameters = array();
 28 |     private $reflection;
 29 | 
 30 |     private function processPHPDoc(ReflectionProperty $reflect)
 31 |     {
 32 |         $out = array('default' => null, 'cast' => 'raw');
 33 |         $docComment = $reflect->getDocComment();
 34 |         if (trim($docComment) == '') return $out;
 35 |         
 36 |         $docComment = preg_replace('#[ \t]*(?:\/\*\*|\*\/|\*)?[ ]{0,1}(.*)?#', '$1', $docComment);
 37 |         $docComment = trim(str_replace('*/', null, $docComment));
 38 | 
 39 |         foreach (explode("\n", $docComment) as $item) {
 40 |             $item = strtolower($item);
 41 |             if (strpos($item, '@cast') !== false) {
 42 |                 $cast = trim(str_replace('@cast', null, $item));
 43 |                 $out['cast'] = $cast;
 44 |             }
 45 | 
 46 |             if (strpos($item, '@default') !== false) {
 47 |                 $default = trim(str_replace('@default', null, $item));
 48 |                 $out['default'] = $default;
 49 |             }
 50 |         }
 51 |         return $out;
 52 |     }
 53 | 
 54 |     /**
 55 |      * @static
 56 |      * @param bool $validateInConstructor
 57 |      * @return RequestObject
 58 |      */
 59 |     public static function factory($validateInConstructor = true)
 60 |     {
 61 |         return new self($validateInConstructor);
 62 |     }
 63 | 
 64 |     /**
 65 |      * @var RequestObject
 66 |      */
 67 |     private static $instance = null;
 68 | 
 69 |     /**
 70 |      * @static
 71 |      * @return RequestObject
 72 |      */
 73 |     public static function singleton()
 74 |     {
 75 |         if (is_null(self::$instance)) {
 76 |             self::$instance = self::factory();
 77 |         }
 78 |         return self::$instance;
 79 |     }
 80 | 
 81 |     public function __construct($validateInConstructor = true)
 82 |     {
 83 |         $this->reflection = new ReflectionClass($this);
 84 | 
 85 |         $args = array();
 86 |         $availablefilters = $this->getAvailableFilters();
 87 | 
 88 |         foreach ($this->reflection->getProperties(ReflectionProperty::IS_PUBLIC) as $reflectionProperty) {
 89 |             $propertyName = $reflectionProperty->getName();
 90 |             $doc = $this->processPHPDoc($this->reflection->getProperty($propertyName));
 91 | 
 92 |             $values = array('default' => $doc['default']);
 93 |             if (strpos($doc['cast'], 'array') !== false) {
 94 |                 $values['flags'] = FILTER_REQUIRE_ARRAY;
 95 |                 $cast = str_replace('array', null, $doc['cast']);
 96 |             } else {
 97 |                 $cast = $doc['cast'];
 98 |             }
 99 | 
100 |             if (!array_key_exists($cast, $availablefilters)) {
101 |                 throw new Exception("cast '{$cast}' not available");
102 |             }
103 |             $values['filter'] = $availablefilters[$cast];
104 |             $args[$propertyName] = $values;
105 |         }
106 | 
107 |         $inputMethods = array('GET' => INPUT_GET, 'POST' => INPUT_POST);
108 |         $inputMethod = $inputMethods[$_SERVER['REQUEST_METHOD']];
109 | 
110 |         $myinputs = filter_input_array($inputMethod, $args);
111 | 
112 |         foreach ($myinputs as $propertyName => $filteredInput) {
113 |             if (is_null($filteredInput) && ! is_null($args[$propertyName])) {
114 |                 $this->$propertyName = filter_var($args[$propertyName]['default'], $args[$propertyName]['filter']);
115 |             } else {
116 |                 $this->$propertyName = $filteredInput;
117 |             }
118 |             $this->filteredParameters[$propertyName] = $this->$propertyName;
119 | 
120 |         }
121 |         
122 |         if ($validateInConstructor === true) {
123 |             $this->validateAll();
124 |         }
125 |     }
126 | 
127 |     private $filteredParameters = array();
128 | 
129 |     public function getFilteredParameters()
130 |     {
131 |         return $this->filteredParameters;
132 |     }
133 | 
134 |     private function filterInput($cast, $key, $default)
135 |     {
136 |         $inputMethods = array('GET' => INPUT_GET, 'POST' => INPUT_POST);
137 | 
138 |         if (!array_key_exists($_SERVER['REQUEST_METHOD'], $inputMethods)) {
139 |             throw new Exception("Input method not supported");
140 |         }
141 |         
142 |         $inputMethod = $inputMethods[$_SERVER['REQUEST_METHOD']];
143 | 
144 |         $filters = $this->getAvailableFilters();
145 |         $filter = $filters[$cast];
146 |         $out = filter_input($inputMethod, $key, $filter);
147 | 
148 |         if (is_null($out) && $default != '') {
149 |             $out = filter_var($default, $filter);
150 |         }
151 |         return $out;
152 |     }
153 | 
154 |     private function getAvailableFilters()
155 |     {
156 |         $filters = array(
157 |             'string'  => FILTER_SANITIZE_STRING,
158 |             'int'     => FILTER_VALIDATE_INT,
159 |             'integer' => FILTER_VALIDATE_INT,
160 |             'bool'    => FILTER_VALIDATE_BOOLEAN,
161 |             'float'   => FILTER_VALIDATE_FLOAT,
162 |             'url'     => FILTER_VALIDATE_EMAIL,
163 |             'email'   => FILTER_SANITIZE_STRING,
164 |             'raw'     => FILTER_UNSAFE_RAW
165 |         );
166 |         return $filters;
167 |     }
168 | 
169 |     public function validateAll()
170 |     {
171 |         $validationErrors = array();
172 |         foreach (array_keys($this->parameters) as $parameter) {
173 |             $validateMethod = "validate_{$parameter}";
174 |             if ($this->reflection->hasMethod($validateMethod) || isset($this->dinamicCallbacks[$validateMethod])) {
175 |                 $parameter = $this->$parameter;
176 |                 if ($this->$validateMethod($parameter) === false) {
177 |                     $validationErrors[$parameter] = array(
178 |                         'value' => $this->$parameter
179 |                     );
180 |                 }
181 |             }
182 |         }
183 | 
184 |         if (count($validationErrors) > 0) {
185 |             throw new RequestObjectException('Validation error', $validationErrors);
186 |         }
187 |     }
188 | 
189 |     private $dinamicCallbacks = array();
190 | 
191 |     public function appendValidateTo($property, Closure $callback)
192 |     {
193 |         $this->dinamicCallbacks["validate_{$property}"] = $callback;
194 |     }
195 | 
196 |     public function __call($name, $arguments)
197 |     {
198 |         if (isset($this->dinamicCallbacks[$name])) {
199 |             return call_user_func_array($this->dinamicCallbacks[$name], $arguments);
200 |         } else {
201 |             return null;
202 |         }
203 |     }
204 | }
205 | 


--------------------------------------------------------------------------------
/test1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | include "RequestObject.php";
 3 | 
 4 | class Request extends RequestObject
 5 | {
 6 |     public $param1;
 7 | }
 8 | 
 9 | $request = new Request();
10 | 
11 | echo "param1: " . $request->param1 . '<p/>';
12 | /*
13 | test1.php?param1=11212
14 | param1: 11212
15 | 
16 | test1.php?param1=hola
17 | param1: hola
18 |  */
19 | 


--------------------------------------------------------------------------------
/test2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | include "RequestObject.php";
 3 | 
 4 | class Request extends RequestObject
 5 | {
 6 |     /** @cast string */
 7 |     public $param1;
 8 |     /**
 9 |      * @cast string
10 |      * @default default value
11 |      */
12 |     public $param2;
13 | }
14 | 
15 | $request = new Request();
16 | 
17 | echo "param1: <br/>";
18 | var_dump($request->param1);
19 | echo "<br/>";
20 | 
21 | echo "param2: <br/>";
22 | var_dump($request->param2);
23 | echo "<br/>";
24 | 
25 | /*
26 | test2.php?param1=hi&param2=1
27 | 
28 | param1: string(2) "hi"
29 | param2: string(1) "1"
30 | 
31 | test2.php?param1=1&param2=hi
32 | 
33 | param1: string(1) "1"
34 | param2: string(2) "hi"
35 | 
36 | test2.php?param1=1
37 | param1: string(1) "1"
38 | param2: string(13) "default value"
39 |  */
40 | 


--------------------------------------------------------------------------------
/test3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | include "RequestObject.php";
 3 | 
 4 | class Request extends RequestObject
 5 | {
 6 |     /** @cast string */
 7 |     public $param1;
 8 |     /** @cast integer */
 9 |     public $param2;
10 | 
11 |     protected function validate_param1(&$value)
12 |     {
13 |         $value = strrev($value);
14 |     }
15 |     
16 |     protected function validate_param2($value)
17 |     {
18 |         if ($value == 1) {
19 |             return false;
20 |         }
21 |     }
22 | }
23 | try {
24 |     $request = new Request();
25 | 
26 |     echo "param1: <br/>";
27 |     var_dump($request->param1);
28 |     echo "<br/>";
29 | 
30 |     echo "param2: <br/>";
31 |     var_dump($request->param2);
32 |     echo "<br/>";
33 | } catch (RequestObjectException $e) {
34 |     echo $e->getMessage();
35 |     echo "<br/>";
36 |     var_dump($e->getValidationErrors());
37 | }
38 | 
39 | /*
40 | test3.php?param2=2&param1=hi
41 | param1: string(2) "ih"
42 | param2: int(2)
43 | 
44 | test3.php?param1=hola&param2=1
45 | Validation error
46 | array(1) { [1]=> array(1) { ["value"]=> NULL } }
47 | */
48 | 


--------------------------------------------------------------------------------
/test4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | include "RequestObject.php";
 3 | 
 4 | class Request extends RequestObject
 5 | {
 6 |     /** @cast string */
 7 |     public $param1;
 8 |     /** @cast integer */
 9 |     public $param2;
10 | }
11 | 
12 | $request = new Request(false); // disables perform validation on contructor
13 |                                // it means it will not raise any validation exception
14 | $request->appendValidateTo('param2', function($value) {
15 |         if ($value == 1) {
16 |             return false;
17 |         }
18 | 
19 |         $value = '1';
20 |     });
21 | 
22 | try {
23 |     $request->validateAll();
24 | 
25 |     echo "param1: <br/>";
26 |     var_dump($request->param1);
27 |     echo "<br/>";
28 | 
29 |     echo "param2: <br/>";
30 |     var_dump($request->param2);
31 |     echo "<br/>";
32 | } catch (RequestObjectException $e) {
33 |     echo $e->getMessage();
34 |     echo "<br/>";
35 |     var_dump($e->getValidationErrors());
36 | }
37 | 
38 | 
39 | /*
40 | test4.php?param1=hola&param2=2
41 | param1: string(4) "hola"
42 | param2: int(2)
43 | 
44 | test4.php?param1=hola&param2=1
45 | Validation error
46 | array(1) { [1]=> array(1) { ["value"]=> NULL } }
47 |  */
48 | 


--------------------------------------------------------------------------------
/test5.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | include "RequestObject.php";
 3 | 
 4 | class Request extends RequestObject
 5 | {
 6 |     /** @cast arrayInteger */
 7 |     public $param1;
 8 | }
 9 | 
10 | $request = new Request();
11 | 
12 | echo "param1: <p/>";
13 | var_dump($request->param1);
14 | /*
15 | test5.php?param1[]=1&param1[]=2
16 | param1: 11212
17 | 
18 | test1.php?param1=hola
19 | param1: hola
20 |  */
21 | 


--------------------------------------------------------------------------------
/test6.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | include "RequestObject.php";
 3 | 
 4 | class Request extends RequestObject
 5 | {
 6 |     /** @cast string */
 7 |     public $param1;
 8 | 
 9 |     /**
10 |      * @cast string
11 |      * @default default value
12 |      */
13 |     public $param2;
14 | }
15 | 
16 | $request = new Request();
17 | extract($request->getFilteredParameters());
18 | 
19 | echo "param1: <br/>";
20 | var_dump($param1);
21 | echo "<br/>";
22 | 
23 | echo "param2: <br/>";
24 | var_dump($param2);
25 | echo "<br/>";
26 | 


--------------------------------------------------------------------------------