├── LICENSE
├── README.md
├── composer.json
└── src
    ├── Attributes.php
    ├── Sanitize.php
    ├── SanitizeException.php
    └── rules
        ├── Abs.php
        ├── BasicTags.php
        ├── BooleanRule.php
        ├── Call.php
        ├── Decode.php
        ├── DefaultRule.php
        ├── Email.php
        ├── Encode.php
        ├── FloatRule.php
        ├── IntRule.php
        ├── Ip.php
        ├── LowerFirst.php
        ├── Lowercase.php
        ├── LtrimWords.php
        ├── Negative.php
        ├── NoiseWords.php
        ├── Numbers.php
        ├── Positive.php
        ├── RemoveScript.php
        ├── RemoveTags.php
        ├── ReplaceRandChars.php
        ├── Round.php
        ├── RtrimWords.php
        ├── Rule.php
        ├── Slug.php
        ├── SpecialChars.php
        ├── StringRule.php
        ├── ToType.php
        ├── Trim.php
        ├── Truncate.php
        ├── TruncateWords.php
        ├── Unserialize.php
        ├── UpperFirst.php
        └── Uppercase.php


/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 RomeOz
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Sanitizator for PHP
 2 | =======================
 3 | 
 4 | [![Latest Stable Version](https://poser.pugx.org/romeOz/rock-sanitize/v/stable.svg)](https://packagist.org/packages/romeOz/rock-sanitize)
 5 | [![Total Downloads](https://poser.pugx.org/romeOz/rock-sanitize/downloads.svg)](https://packagist.org/packages/romeOz/rock-sanitize)
 6 | [![Build Status](https://travis-ci.org/romeOz/rock-sanitize.svg?branch=master)](https://travis-ci.org/romeOz/rock-sanitize)
 7 | [![HHVM Status](http://hhvm.h4cc.de/badge/romeoz/rock-sanitize.svg)](http://hhvm.h4cc.de/package/romeoz/rock-sanitize)
 8 | [![Coverage Status](https://coveralls.io/repos/romeOz/rock-sanitize/badge.svg?branch=master)](https://coveralls.io/r/romeOz/rock-sanitize?branch=master)
 9 | [![License](https://poser.pugx.org/romeOz/rock-sanitize/license.svg)](https://packagist.org/packages/romeOz/rock-sanitize)
10 | 
11 | Features
12 | -------------------
13 | 
14 |  * Sanitization of scalar variable, array and object
15 |  * Custom rules
16 |  * Standalone module/component for [Rock Framework](https://github.com/romeOz/rock)
17 |  
18 | Installation
19 | -------------------
20 | 
21 | From the Command Line:
22 | 
23 | ```
24 | composer require romeoz/rock-sanitize
25 | ```
26 | 
27 | In your composer.json:
28 | 
29 | ```json
30 | {
31 |     "require": {
32 |         "romeoz/rock-sanitize": "*"
33 |     }
34 | }
35 | ```
36 | 
37 | Quick Start
38 | -------------------
39 | 
40 | ```php
41 | use rock\sanitize\Sanitize;
42 | 
43 | Sanitize::removeTags()
44 |     ->lowercase()
45 |     ->sanitize('<b>Hello World!</b>');
46 | // output: hello world!    
47 | ```
48 | 
49 | ####As Array or Object
50 | 
51 | ```php
52 | use rock\sanitize\Sanitize;
53 | 
54 | $input = [
55 |     'name' => '<b>Tom</b>',
56 |     'age' => -22
57 | ];
58 | 
59 | $attributes = [
60 |     'name' => Sanitize::removeTags(),
61 |     'age' => Sanitize::abs()
62 | ];
63 |         
64 | Sanitize::attributes($attributes)->sanitize($input);
65 | /*
66 | output:
67 | 
68 | [
69 |   'name' => 'Tom',
70 |   'age' => 22
71 | ]
72 | */
73 | 
74 | // all attributes:
75 | Sanitize::attributes(Sanitize::removeTags())->sanitize($input);
76 | ```
77 | 
78 | Documentation
79 | -------------------
80 | 
81 |  * [Rules](https://github.com/romeOz/rock-sanitize/blob/master/docs/rules.md)
82 |  * [Custom rules](https://github.com/romeOz/rock-sanitize/blob/master/docs/custom-rules.md)
83 | 
84 | [Demo](https://github.com/romeOz/docker-rock-sanitize)
85 | -------------------
86 | 
87 |  * [Install Docker](https://docs.docker.com/installation/) or [askubuntu](http://askubuntu.com/a/473720)
88 |  * `docker run --name demo -d -p 8080:80 romeoz/docker-rock-sanitize`
89 |  * Open demo [http://localhost:8080/](http://localhost:8080/)
90 | 
91 | Requirements
92 | -------------------
93 | 
94 |  * PHP 5.4+
95 | 
96 | License
97 | -------------------
98 | 
99 | The Rock Sanitize is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT).


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "romeoz/rock-sanitize",
 3 |     "description": "Flexible sanitizator for PHP.",
 4 |     "keywords": ["sanitize", "sanitization", "sanitizator"],
 5 |     "type": "library",
 6 |     "license": "MIT",
 7 |     "support": {
 8 |         "email": "serggalka@gmail.com",
 9 |         "issues": "https://github.com/romeOz/rock-sanitize/issues",
10 |         "source": "https://github.com/romeOz/rock-sanitize"
11 |     },
12 |     "authors": [
13 |         {
14 |             "name": "Ruslan",
15 |             "email": "serggalka@gmail.com"
16 |         }
17 |     ],
18 |     "require": {
19 |         "php": ">=5.4.0",
20 |         "romeoz/rock-base" : "*@dev"
21 |     },
22 |     "require-dev": {
23 |         "phpunit/phpunit": "^4.7.0"
24 |     },
25 |     "autoload": {
26 |         "psr-4": {
27 |             "rock\\sanitize\\": "src/"
28 |         }
29 |     },
30 |     "extra": {
31 |         "branch-alias": {
32 |             "dev-master": "0.11-dev"
33 |         }
34 |     }
35 | }


--------------------------------------------------------------------------------
/src/Attributes.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace rock\sanitize;
  4 | 
  5 | 
  6 | use rock\base\ObjectInterface;
  7 | use rock\base\ObjectTrait;
  8 | use rock\helpers\ArrayHelper;
  9 | 
 10 | class Attributes implements ObjectInterface
 11 | {
 12 |     use ObjectTrait;
 13 | 
 14 |     public $remainder = '*';
 15 |     public $recursive = true;
 16 |     public $attributes = [];
 17 | 
 18 |     public function sanitize($input)
 19 |     {
 20 |         $object = null;
 21 |         $attributes = $this->attributes;
 22 |         if (is_object($input)) {
 23 |             $object = $input;
 24 |             $input = (array)$input;
 25 |         }
 26 |         if ($attributes instanceof Sanitize) {
 27 |             $attributes = $this->each($attributes, $input);
 28 |         }
 29 |         $result = [];
 30 |         foreach ($attributes as $attribute => $sanitize) {
 31 |             if (!$sanitize instanceof Sanitize) {
 32 |                 throw new SanitizeException("`{$attribute}` is not `" . Sanitize::className() . "`");
 33 |             }
 34 |             if ($attribute === $this->remainder) {
 35 |                 $result = array_merge($result, $this->remainder($sanitize, $attributes, $input));
 36 |                 continue;
 37 |             }
 38 | 
 39 |             if (strrpos($attribute, '.') !== false && ArrayHelper::getValue($input, explode('.', $attribute))) {
 40 |                 $input = $this->chain($sanitize, $input, $attribute);
 41 |                 continue;
 42 |             }
 43 | 
 44 |             if (!isset($input[$attribute])) {
 45 |                 continue;
 46 |             }
 47 | 
 48 |             if ((is_array($input[$attribute]) || is_object($input[$attribute]))) {
 49 |                 if (!$this->recursive) {
 50 |                     continue;
 51 |                 }
 52 |                 $this->attributes = is_array($this->attributes) && isset($this->attributes[$attribute])
 53 |                     ? $this->attributes[$attribute]
 54 |                     : $this->attributes;
 55 |                 $result[$attribute] = $this->sanitize($input[$attribute]);
 56 |                 continue;
 57 |             }
 58 |             $result[$attribute] = $sanitize->sanitize($input[$attribute]);
 59 |         }
 60 | 
 61 |         $result = is_int(key($result)) ? $result + $input : array_merge($input, $result);
 62 |         if (isset($object)) {
 63 |             foreach ($result as $property => $value) {
 64 |                 $object->$property = $value;
 65 |             }
 66 |             return $object;
 67 |         }
 68 |         return $result;
 69 |     }
 70 | 
 71 |     protected function each(Sanitize $sanitize, $input)
 72 |     {
 73 |         $attributes = [];
 74 |         foreach ($input as $key => $value) {
 75 |             $attributes[$key] = $sanitize;
 76 |         }
 77 |         return $attributes;
 78 |     }
 79 | 
 80 |     protected function remainder(Sanitize $sanitize, array $attributes, $input)
 81 |     {
 82 |         $input = ArrayHelper::diffByKeys($input, array_keys($attributes));
 83 |         $this->attributes = $sanitize;
 84 |         return $this->sanitize($input);
 85 |     }
 86 | 
 87 |     protected function chain(Sanitize $sanitize, $input, $attribute)
 88 |     {
 89 |         $callback = function ($value) use ($sanitize, $attribute) {
 90 |             if (is_array($value)) {
 91 |                 if (!$this->recursive) {
 92 |                     return $value;
 93 |                 }
 94 |                 $this->attributes = is_array($this->attributes) && isset($this->attributes[$attribute])
 95 |                     ? $this->attributes[$attribute]
 96 |                     : $this->attributes;
 97 |                 return $this->sanitize($value);
 98 |             }
 99 |             return $sanitize->sanitize($value);
100 |         };
101 |         return ArrayHelper::updateValue($input, explode('.', $attribute), $callback);
102 |     }
103 | }


--------------------------------------------------------------------------------
/src/Sanitize.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace rock\sanitize;
  4 | 
  5 | 
  6 | use rock\base\ObjectInterface;
  7 | use rock\base\ObjectTrait;
  8 | use rock\helpers\Instance;
  9 | use rock\sanitize\rules\Abs;
 10 | use rock\sanitize\rules\BasicTags;
 11 | use rock\sanitize\rules\BooleanRule;
 12 | use rock\sanitize\rules\Call;
 13 | use rock\sanitize\rules\Ip;
 14 | use rock\sanitize\rules\Decode;
 15 | use rock\sanitize\rules\DefaultRule;
 16 | use rock\sanitize\rules\Email;
 17 | use rock\sanitize\rules\Encode;
 18 | use rock\sanitize\rules\FloatRule;
 19 | use rock\sanitize\rules\IntRule;
 20 | use rock\sanitize\rules\Lowercase;
 21 | use rock\sanitize\rules\LowerFirst;
 22 | use rock\sanitize\rules\LtrimWords;
 23 | use rock\sanitize\rules\Negative;
 24 | use rock\sanitize\rules\NoiseWords;
 25 | use rock\sanitize\rules\Numbers;
 26 | use rock\sanitize\rules\Positive;
 27 | use rock\sanitize\rules\Round;
 28 | use rock\sanitize\rules\SpecialChars;
 29 | use rock\sanitize\rules\ReplaceRandChars;
 30 | use rock\sanitize\rules\RtrimWords;
 31 | use rock\sanitize\rules\Rule;
 32 | use rock\sanitize\rules\RemoveScript;
 33 | use rock\sanitize\rules\RemoveTags;
 34 | use rock\sanitize\rules\StringRule;
 35 | use rock\sanitize\rules\ToType;
 36 | use rock\sanitize\rules\Slug;
 37 | use rock\sanitize\rules\Trim;
 38 | use rock\sanitize\rules\Truncate;
 39 | use rock\sanitize\rules\TruncateWords;
 40 | use rock\sanitize\rules\Unserialize;
 41 | use rock\sanitize\rules\Uppercase;
 42 | use rock\sanitize\rules\UpperFirst;
 43 | 
 44 | /**
 45 |  * Sanitize
 46 |  *
 47 |  * @method static Sanitize attributes($attributes)
 48 |  * @method static Sanitize recursive(bool $recursive = true)
 49 |  * @method static Sanitize rules(array $rules)
 50 |  *
 51 |  * @method static Sanitize abs()
 52 |  * @method static Sanitize basicTags(StringRule $allowedTags = '')
 53 |  * @method static Sanitize bool()
 54 |  * @method static Sanitize call(callable $call, array $args = null)
 55 |  * @method static Sanitize ip(bool $normalize = true)
 56 |  * @method static Sanitize decode()
 57 |  * @method static Sanitize defaultValue(mixed $default = null)
 58 |  * @method static Sanitize email()
 59 |  * @method static Sanitize encode(bool $doubleEncode = true)
 60 |  * @method static Sanitize float()
 61 |  * @method static Sanitize int()
 62 |  * @method static Sanitize lowercase()
 63 |  * @method static Sanitize lowerFirst()
 64 |  * @method static Sanitize ltrimWords(array $words)
 65 |  * @method static Sanitize negative()
 66 |  * @method static Sanitize noiseWords(StringRule $enNoiseWords = '')
 67 |  * @method static Sanitize numbers()
 68 |  * @method static Sanitize positive()
 69 |  * @method static Sanitize specialChars()
 70 |  * @method static Sanitize removeScript()
 71 |  * @method static Sanitize removeTags()
 72 |  * @method static Sanitize replaceRandChars(StringRule $replaceTo = '*')
 73 |  * @method static Sanitize round(IntRule $precision = 0)
 74 |  * @method static Sanitize rtrimWords(array $words)
 75 |  * @method static Sanitize string()
 76 |  * @method static Sanitize toType()
 77 |  * @method static Sanitize slug(StringRule $replacement = '-', bool $lowercase = true)
 78 |  * @method static Sanitize trim()
 79 |  * @method static Sanitize truncate(IntRule $length = 4, StringRule $suffix = '...')
 80 |  * @method static Sanitize truncateWords(IntRule $length = 100, StringRule $suffix = '...')
 81 |  * @method static Sanitize unserialize()
 82 |  * @method static Sanitize uppercase()
 83 |  * @method static Sanitize upperFirst()
 84 |  *
 85 |  * @package rock\sanitize
 86 |  */
 87 | class Sanitize implements ObjectInterface
 88 | {
 89 |     use ObjectTrait {
 90 |         ObjectTrait::__call as parentCall;
 91 |     }
 92 | 
 93 |     /**
 94 |      * List rules.
 95 |      * @var array
 96 |      */
 97 |     protected $rules = [];
 98 |     /**
 99 |      * Enable recursive mode.
100 |      * @var bool
101 |      */
102 |     protected $recursive = true;
103 |     /**
104 |      * Label remainder.
105 |      * @var string
106 |      */
107 |     protected $remainder = '*';
108 |     /**
109 |      * List raw rules.
110 |      * @var Rule[]
111 |      */
112 |     protected $rawRules = [];
113 | 
114 |     public function init()
115 |     {
116 |         $this->rules = array_merge($this->defaultRules(), $this->rules);
117 |     }
118 | 
119 |     /**
120 |      * Sets a list rules.
121 |      * @param array $rules
122 |      * @return $this
123 |      */
124 |     public function setRules(array $rules)
125 |     {
126 |         $this->rules = array_merge($this->rules, $rules);
127 |         return $this;
128 |     }
129 | 
130 |     /**
131 |      * Enable recursive mode.
132 |      * @param bool $enable
133 |      * @return $this
134 |      */
135 |     public function setRecursive($enable)
136 |     {
137 |         $this->recursive = $enable;
138 |         return $this;
139 |     }
140 | 
141 |     /**
142 |      * Sets a label remainder.
143 |      * @param string $label
144 |      * @return $this
145 |      */
146 |     public function setRemainder($label)
147 |     {
148 |         $this->remainder = $label;
149 |         return $this;
150 |     }
151 | 
152 |     /**
153 |      * Sanitize value.
154 |      *
155 |      * @param mixed $input
156 |      * @return mixed
157 |      * @throws SanitizeException
158 |      */
159 |     public function sanitize($input)
160 |     {
161 |         foreach ($this->rawRules as $rule) {
162 |             if ($rule instanceof Attributes) {
163 |                 $config = [
164 |                     'remainder' => $this->remainder,
165 |                     'recursive' => $this->recursive
166 |                 ];
167 |                 Instance::configure($rule, $config);
168 |                 return $rule->sanitize($input);
169 |             }
170 |             $input = $rule->sanitize($input);
171 | 
172 |             if ($rule->recursive && (is_array($input) || is_object($input))) {
173 |                 $config['attributes'] = $this;
174 |                 return (new Attributes($config))->sanitize($input);
175 |             }
176 |         }
177 | 
178 |         return $input;
179 |     }
180 | 
181 |     /**
182 |      * Exists rule.
183 |      * @param string $name name of rule.
184 |      * @return bool
185 |      */
186 |     public function existsRule($name)
187 |     {
188 |         return isset($this->rules[$name]);
189 |     }
190 | 
191 |     /**
192 |      * @return rules\Rule[]
193 |      */
194 |     public function getRawRules()
195 |     {
196 |         return $this->rawRules;
197 |     }
198 | 
199 |     public function __call($name, $arguments)
200 |     {
201 |         if (method_exists($this, "{$name}Internal")) {
202 |             return call_user_func_array([$this, "{$name}Internal"], $arguments);
203 |         }
204 | 
205 |         if (!isset($this->rules[$name])) {
206 |             throw new SanitizeException("Unknown rule: {$name}");
207 |         }
208 |         if (!class_exists($this->rules[$name])) {
209 |             throw new SanitizeException(SanitizeException::UNKNOWN_CLASS, ['class' => $this->rules[$name]]);
210 |         }
211 |         $rule = $this->getInstanceRule($name, $arguments);
212 |         $this->rawRules[] = $rule;
213 |         return $this;
214 |     }
215 | 
216 |     public static function __callStatic($name, $arguments)
217 |     {
218 |         return call_user_func_array([static::getInstance(), $name], $arguments);
219 |     }
220 | 
221 |     protected function attributesInternal($attributes)
222 |     {
223 |         $this->rawRules = [];
224 |         $this->rawRules[] = new Attributes(['attributes' => $attributes, 'remainder' => $this->remainder]);
225 | 
226 |         return $this;
227 |     }
228 | 
229 |     protected function recursiveInternal($enable = true)
230 |     {
231 |         $this->recursive = $enable;
232 |         return $this;
233 |     }
234 | 
235 |     protected function rulesInternal(array $rules)
236 |     {
237 |         foreach ($rules as $rule => $args) {
238 |             if (is_int($rule)) {
239 |                 $rule = $args;
240 |                 $args = [];
241 |             }
242 |             if (is_array($rule)) {
243 |                 $args = (array)current($rule);
244 |                 $rule = key($rule);
245 |             }
246 |             call_user_func_array([$this, $rule], $args);
247 |         }
248 |         return $this;
249 |     }
250 | 
251 |     /**
252 |      * Returns instance rule.
253 |      * @param string $name name of rule
254 |      * @param array $arguments
255 |      * @return Rule
256 |      */
257 |     protected function getInstanceRule($name, array $arguments)
258 |     {
259 |         $reflect = new \ReflectionClass($this->rules[$name]);
260 |         return $reflect->newInstanceArgs($arguments);
261 |     }
262 | 
263 |     /**
264 |      * Returns instance.
265 |      *
266 |      * If exists {@see \rock\di\Container} that uses it.
267 |      * @return static
268 |      */
269 |     protected static function getInstance()
270 |     {
271 |         if (class_exists('\rock\di\Container')) {
272 |             return \rock\di\Container::load(static::className());
273 |         }
274 |         return new static();
275 |     }
276 | 
277 |     protected function defaultRules()
278 |     {
279 |         return [
280 |             'abs' => Abs::className(),
281 |             'basicTags' => BasicTags::className(),
282 |             'bool' => BooleanRule::className(),
283 |             'ip' => Ip::className(),
284 |             'call' => Call::className(),
285 |             'decode' => Decode::className(),
286 |             'defaultValue' => DefaultRule::className(),
287 |             'email' => Email::className(),
288 |             'encode' => Encode::className(),
289 |             'float' => FloatRule::className(),
290 |             'int' => IntRule::className(),
291 |             'lowercase' => Lowercase::className(),
292 |             'lowerFirst' => LowerFirst::className(),
293 |             'ltrimWords' => LtrimWords::className(),
294 |             'negative' => Negative::className(),
295 |             'noiseWords' => NoiseWords::className(),
296 |             'numbers' => Numbers::className(),
297 |             'positive' => Positive::className(),
298 |             'specialChars' => SpecialChars::className(),
299 |             'removeScript' => RemoveScript::className(),
300 |             'removeTags' => RemoveTags::className(),
301 |             'replaceRandChars' => ReplaceRandChars::className(),
302 |             'round' => Round::className(),
303 |             'rtrimWords' => RtrimWords::className(),
304 |             'string' => StringRule::className(),
305 |             'toType' => ToType::className(),
306 |             'slug' => Slug::className(),
307 |             'trim' => Trim::className(),
308 |             'truncate' => Truncate::className(),
309 |             'truncateWords' => TruncateWords::className(),
310 |             'unserialize' => Unserialize::className(),
311 |             'uppercase' => Uppercase::className(),
312 |             'upperFirst' => UpperFirst::className(),
313 |         ];
314 |     }
315 | }


--------------------------------------------------------------------------------
/src/SanitizeException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize;
 4 | 
 5 | 
 6 | use rock\base\BaseException;
 7 | 
 8 | class SanitizeException extends BaseException
 9 | {
10 | }


--------------------------------------------------------------------------------
/src/rules/Abs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class Abs extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return abs($input);
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/BasicTags.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | class BasicTags extends Rule
 6 | {
 7 |     protected $allowedTags = "<br><p><a><strong><b><i><em><img><blockquote><code><dd><dl><hr><h1><h2><h3><h4><h5><h6><label><ul><li><span><sub><sup>";
 8 | 
 9 |     public function __construct($allowedTags = null, $config = [])
10 |     {
11 |         $this->parentConstruct($config);
12 |         if (!empty($allowedTags)) {
13 |             $this->allowedTags = $allowedTags;
14 |         }
15 |     }
16 | 
17 |     /**
18 |      * @inheritdoc
19 |      */
20 |     public function sanitize($input)
21 |     {
22 |         return is_string($input) ? strip_tags($input, $this->allowedTags) : $input;
23 |     }
24 | } 


--------------------------------------------------------------------------------
/src/rules/BooleanRule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class BooleanRule extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return (bool)$input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/Call.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | class Call extends Rule
 6 | {
 7 |     protected $call;
 8 |     protected $args = [];
 9 | 
10 |     public function __construct(callable $call, array $args = null, $config = [])
11 |     {
12 |         $this->parentConstruct($config);
13 |         $this->call = $call;
14 |         if (!empty($args)) {
15 |             $this->args = $args;
16 |         }
17 |     }
18 | 
19 |     /**
20 |      * @inheritdoc
21 |      */
22 |     public function sanitize($input)
23 |     {
24 |         $args = $this->args;
25 |         array_unshift($args, $input);
26 |         return call_user_func_array($this->call, $args);
27 |     }
28 | }


--------------------------------------------------------------------------------
/src/rules/Decode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | class Decode extends Rule
 6 | {
 7 |     /**
 8 |      * @inheritdoc
 9 |      */
10 |     public function sanitize($input)
11 |     {
12 |         return is_string($input) ? \rock\helpers\StringHelper::decode($input) : $input;
13 |     }
14 | } 


--------------------------------------------------------------------------------
/src/rules/DefaultRule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class DefaultRule extends Rule
 7 | {
 8 |     protected $default;
 9 | 
10 |     public function __construct($default = null, $config = [])
11 |     {
12 |         $this->parentConstruct($config);
13 |         $this->default = $default;
14 |     }
15 | 
16 |     /**
17 |      * @inheritdoc
18 |      */
19 |     public function sanitize($input)
20 |     {
21 |         if (empty($input)) {
22 |             return $this->default;
23 |         }
24 |         return $input;
25 |     }
26 | } 


--------------------------------------------------------------------------------
/src/rules/Email.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class Email extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? filter_var($input, FILTER_SANITIZE_EMAIL) : $input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/Encode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class Encode extends Rule
 7 | {
 8 |     protected $doubleEncode = true;
 9 | 
10 |     public function __construct($doubleEncode = true, $config = [])
11 |     {
12 |         $this->parentConstruct($config);
13 |         $this->doubleEncode = $doubleEncode;
14 |     }
15 | 
16 |     /**
17 |      * @inheritdoc
18 |      */
19 |     public function sanitize($input)
20 |     {
21 |         return is_string($input) ? \rock\helpers\StringHelper::encode($input, $this->doubleEncode) : $input;
22 |     }
23 | } 


--------------------------------------------------------------------------------
/src/rules/FloatRule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class FloatRule extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return (float)$input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/IntRule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class IntRule extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return (int)$input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/Ip.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace rock\sanitize\rules;
  4 | 
  5 | 
  6 | class Ip extends Rule
  7 | {
  8 |     protected $normalize = true;
  9 | 
 10 |     public function __construct($normalize = true, $config = [])
 11 |     {
 12 |         $this->parentConstruct($config);
 13 |         $this->normalize = $normalize;
 14 |     }
 15 | 
 16 |     /**
 17 |      * @inheritdoc
 18 |      */
 19 |     public function sanitize($input)
 20 |     {
 21 |         if (strpos($input, '/') !== false) {
 22 |             return $this->rangeUsingCIDR($input);
 23 |         } elseif (strpos($input, '*') !== false) {
 24 |             return $this->rangeUsingWildcards($input);
 25 |         }
 26 |         return $this->normalize($input);
 27 |     }
 28 | 
 29 |     /**
 30 |      * @link http://stackoverflow.com/a/10086404
 31 |      * @param string $input
 32 |      * @return string
 33 |      */
 34 |     protected function rangeUsingCIDR($input)
 35 |     {
 36 |         list($ip, $prefix) = explode('/', $input);
 37 |         if ($this->isIPv6($ip)) {
 38 | 
 39 |             if (strpos($prefix, ':') !== false) {
 40 |                 $prefix =  strlen(str_replace('0', '', $this->IPv6toBit(inet_pton($prefix))));
 41 |             }
 42 |             $minBin = inet_pton($ip);
 43 |             $min = inet_ntop($minBin);
 44 |             $maxBin = $minBin = unpack('H*', $minBin)[1];
 45 |             $prefix = 128 - $prefix;
 46 |             $pos = 31;
 47 |             while ($prefix > 0) {
 48 |                 $orig = substr($maxBin, $pos, 1);
 49 |                 $origval = hexdec($orig);
 50 |                 $newval = $origval | (pow(2, min(4, $prefix)) - 1);
 51 |                 $new = dechex($newval);
 52 |                 $maxBin = substr_replace($maxBin, $new, $pos, 1);
 53 |                 $prefix -= 4;
 54 |                 $pos -= 1;
 55 |             }
 56 | 
 57 |             $max = inet_ntop(pack('H*', $maxBin));
 58 | 
 59 |             return $this->normalize($min) . '-' . $this->normalize($max);
 60 | 
 61 |         }
 62 |         if (strpos($prefix, '.') !== false) {
 63 |             $prefix =  strlen(str_replace('0', '', sprintf('%032b', ip2long($prefix))));
 64 |         }
 65 |         return  long2ip((ip2long($ip)) & ((-1 << (32 - (int)$prefix))))
 66 |         . '-'
 67 |         . long2ip((ip2long($ip)) + pow(2, (32 - (int)$prefix)) - 1);
 68 |     }
 69 | 
 70 |     protected function rangeUsingWildcards($input)
 71 |     {
 72 |         $input = $this->fillAddress($input);
 73 | 
 74 |         if (strpos($input, ':') !== false) {
 75 |             return  $this->normalize(strtr($input, '*', '0')) . '-' . $this->normalize(str_replace('*', 'ffff', $input));
 76 |         }
 77 |         return strtr($input, '*', '0') . '-' . str_replace('*', '255', $input);
 78 |     }
 79 | 
 80 |     protected function isIPv6($ip)
 81 |     {
 82 |         return (bool)filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6);
 83 |     }
 84 | 
 85 |     /**
 86 |      * @link http://stackoverflow.com/a/7951507
 87 |      * @param string $ip
 88 |      * @return string
 89 |      */
 90 |     protected function IPv6toBit($ip)
 91 |     {
 92 |         $result = '';
 93 |         $ip = str_split(unpack('A16', $ip)[1]);
 94 |         foreach ($ip as $char) {
 95 |             $result .= str_pad(decbin(ord($char)), 8, '0', STR_PAD_LEFT);
 96 |         }
 97 |         return $result;
 98 |     }
 99 |     protected function fillAddress($input, $char = '*')
100 |     {
101 |         if (strpos($input, ':') !== false) {
102 |             while (substr_count($input, ':') < 7) {
103 |                 $input .= ':' . $char;
104 |             }
105 |             return $input;
106 |         }
107 |         while (substr_count($input, '.') < 3) {
108 |             $input .= '.' . $char;
109 |         }
110 |         return $input;
111 |     }
112 | 
113 |     protected function normalize($ip)
114 |     {
115 |         if (!$this->normalize) {
116 |             return $ip;
117 |         }
118 |         return inet_ntop(inet_pton($ip));
119 |     }
120 | } 


--------------------------------------------------------------------------------
/src/rules/LowerFirst.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class LowerFirst extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? \rock\helpers\StringHelper::lowerFirst($input) : $input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/Lowercase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class Lowercase extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? \rock\helpers\StringHelper::lower($input) : $input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/LtrimWords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class LtrimWords extends Rule
 7 | {
 8 |     protected $words = [];
 9 | 
10 |     public function __construct(array $words, $config = [])
11 |     {
12 |         $this->parentConstruct($config);
13 |         $this->words = $words;
14 |     }
15 | 
16 |     /**
17 |      * @inheritdoc
18 |      */
19 |     public function sanitize($input)
20 |     {
21 |         return is_string($input) ? \rock\helpers\StringHelper::ltrimWords($input, $this->words) : $input;
22 |     }
23 | } 


--------------------------------------------------------------------------------
/src/rules/Negative.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | use rock\helpers\NumericHelper;
 7 | 
 8 | class Negative extends Rule
 9 | {
10 |     /**
11 |      * @inheritdoc
12 |      */
13 |     public function sanitize($input)
14 |     {
15 |         $input = NumericHelper::toNumeric($input);
16 |         return $input > 0 ? 0 : $input;
17 |     }
18 | } 


--------------------------------------------------------------------------------
/src/rules/NoiseWords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class NoiseWords extends Rule
 7 | {
 8 |     protected $enNoiseWords = 'about,after,all,also,an,and,another,any,are,as,at,be,because,been,before,
 9 | 				  				  	 being,between,both,but,by,came,can,come,could,did,do,each,for,from,get,
10 | 				  				  	 got,has,had,he,have,her,here,him,himself,his,how,if,in,into,is,it,its,it\'s,like,
11 | 			      				  	 make,many,me,might,more,most,much,must,my,never,now,of,on,only,or,other,
12 | 				  				  	 our,out,over,said,same,see,should,since,some,still,such,take,than,that,
13 | 				  				  	 the,their,them,then,there,these,they,this,those,through,to,too,under,up,
14 | 				  				  	 very,was,way,we,well,were,what,where,which,while,who,with,would,you,your,a,
15 | 				  				  	 b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,$,1,2,3,4,5,6,7,8,9,0,_';
16 | 
17 |     public function __construct($enNoiseWords = null, $config = [])
18 |     {
19 |         $this->parentConstruct($config);
20 |         if (!empty($enNoiseWords)) {
21 |             $this->enNoiseWords = $enNoiseWords;
22 |         }
23 |     }
24 | 
25 |     /**
26 |      * @inheritdoc
27 |      */
28 |     public function sanitize($input)
29 |     {
30 |         if (!is_string($input)) {
31 |             return $input;
32 |         }
33 |         $value = preg_replace('/\s\s+/u', chr(32), $input);
34 |         $value = " $value ";
35 |         $words = explode(',', $this->enNoiseWords);
36 |         foreach ($words as $word) {
37 |             $word = trim($word);
38 |             $word = " $word "; // Normalize
39 |             if (stripos($value, $word) !== FALSE) {
40 |                 $value = str_ireplace($word, chr(32), $value);
41 |             }
42 |         }
43 |         return trim($value);
44 |     }
45 | }


--------------------------------------------------------------------------------
/src/rules/Numbers.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class Numbers extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? filter_var($input, FILTER_SANITIZE_NUMBER_INT) : $input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/Positive.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | use rock\helpers\NumericHelper;
 7 | 
 8 | class Positive extends Rule
 9 | {
10 |     /**
11 |      * @inheritdoc
12 |      */
13 |     public function sanitize($input)
14 |     {
15 |         $input = NumericHelper::toNumeric($input);
16 |         return $input < 0 ? 0 : $input;
17 |     }
18 | } 


--------------------------------------------------------------------------------
/src/rules/RemoveScript.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class RemoveScript extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? preg_replace(
14 |             [
15 |                 '/\<[\\s\/]*
16 |                 (?:applet|b(?:ase|gsound|link)|
17 |                 embed|frame(?:set)?|
18 |                 i(?:frame|layer)|
19 |                 l(?:ayer|ink)|
20 |                 meta|s(?:cript|tyle)|title|xml)
21 |                 [^\>]*+\>/iusx',
22 |                 /* XSS injection IE */
23 |                 '/(\<[^\>]+?.*?)
24 |                 (?:expression|behaviour|javascript|s\\s*c\\s*r\\s*i\\s*p\\s*t\\s*)\\s*\(*(?:[^\(\)]++|\((?!\()|\)(?!\))|(?R))*\)*	# cut
25 |                 (.*?\>)/iux'
26 |             ],
27 |             ["", '$1$2'],
28 |             $input
29 |         ) : $input;
30 |     }
31 | } 


--------------------------------------------------------------------------------
/src/rules/RemoveTags.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class RemoveTags extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? filter_var($input, FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES) : $input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/ReplaceRandChars.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class ReplaceRandChars extends Rule
 7 | {
 8 |     protected $replaceTo = '*';
 9 | 
10 |     public function __construct($replaceTo = '*', $config = [])
11 |     {
12 |         $this->parentConstruct($config);
13 |         $this->replaceTo = $replaceTo;
14 |     }
15 | 
16 |     /**
17 |      * @inheritdoc
18 |      */
19 |     public function sanitize($input)
20 |     {
21 |         return is_string($input) ? \rock\helpers\StringHelper::replaceRandChars($input, $this->replaceTo) : $input;
22 |     }
23 | } 


--------------------------------------------------------------------------------
/src/rules/Round.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | class Round extends Rule
 6 | {
 7 |     protected $precision = 0;
 8 | 
 9 |     public function __construct($precision = 0, $config = [])
10 |     {
11 |         $this->parentConstruct($config);
12 |         $this->precision = $precision;
13 |     }
14 | 
15 |     /**
16 |      * @inheritdoc
17 |      */
18 |     public function sanitize($input)
19 |     {
20 |         return round($input, $this->precision);
21 |     }
22 | } 


--------------------------------------------------------------------------------
/src/rules/RtrimWords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class RtrimWords extends Rule
 7 | {
 8 |     protected $words = [];
 9 | 
10 |     public function __construct(array $words, $config = [])
11 |     {
12 |         $this->parentConstruct($config);
13 |         $this->words = $words;
14 |     }
15 | 
16 |     /**
17 |      * @inheritdoc
18 |      */
19 |     public function sanitize($input)
20 |     {
21 |         return is_string($input) ? \rock\helpers\StringHelper::rtrimWords($input, $this->words) : $input;
22 |     }
23 | } 


--------------------------------------------------------------------------------
/src/rules/Rule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | use rock\base\ObjectInterface;
 7 | use rock\base\ObjectTrait;
 8 | 
 9 | abstract class Rule implements ObjectInterface
10 | {
11 |     use ObjectTrait {
12 |         ObjectTrait::__construct as parentConstruct;
13 |     }
14 | 
15 |     public $recursive = true;
16 | 
17 |     /**
18 |      * @param mixed $input
19 |      * @return bool
20 |      */
21 |     abstract public function sanitize($input);
22 | } 


--------------------------------------------------------------------------------
/src/rules/Slug.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | use rock\helpers\Inflector;
 6 | 
 7 | class Slug extends Rule
 8 | {
 9 |     protected $replacement = '-';
10 |     protected $lowercase = true;
11 | 
12 |     public function __construct($replacement = '-', $lowercase = true, $config = [])
13 |     {
14 |         $this->parentConstruct($config);
15 |         $this->replacement = $replacement;
16 |         $this->lowercase = $lowercase;
17 |     }
18 | 
19 |     /**
20 |      * @inheritdoc
21 |      */
22 |     public function sanitize($input)
23 |     {
24 |         return is_string($input) ? Inflector::slug($input, $this->replacement, $this->lowercase) : $input;
25 |     }
26 | } 


--------------------------------------------------------------------------------
/src/rules/SpecialChars.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class SpecialChars extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? preg_replace('/[^\w\s]/i', '', $input) : $input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/StringRule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class StringRule extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return (string)$input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/ToType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | use rock\helpers\Helper;
 7 | 
 8 | class ToType extends Rule
 9 | {
10 |     /**
11 |      * @inheritdoc
12 |      */
13 |     public function sanitize($input)
14 |     {
15 |         return Helper::toType($input);
16 |     }
17 | } 


--------------------------------------------------------------------------------
/src/rules/Trim.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class Trim extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? trim($input) : $input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/Truncate.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class Truncate extends Rule
 7 | {
 8 |     protected $length = 4;
 9 |     protected $suffix = '...';
10 | 
11 |     public function __construct($length = 4, $suffix = '...', $config = [])
12 |     {
13 |         $this->parentConstruct($config);
14 |         $this->length = $length;
15 |         $this->suffix = $suffix;
16 |     }
17 | 
18 |     /**
19 |      * @inheritdoc
20 |      */
21 |     public function sanitize($input)
22 |     {
23 |         return \rock\helpers\StringHelper::truncate($input, $this->length, $this->suffix);
24 |     }
25 | } 


--------------------------------------------------------------------------------
/src/rules/TruncateWords.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class TruncateWords extends Rule
 7 | {
 8 |     protected $length = 100;
 9 |     protected $suffix = '...';
10 | 
11 |     public function __construct($length = 100, $suffix = '...', $config = [])
12 |     {
13 |         $this->parentConstruct($config);
14 |         $this->length = $length;
15 |         $this->suffix = $suffix;
16 |     }
17 | 
18 |     /**
19 |      * @inheritdoc
20 |      */
21 |     public function sanitize($input)
22 |     {
23 |         return \rock\helpers\StringHelper::truncateWords($input, $this->length, $this->suffix);
24 |     }
25 | } 


--------------------------------------------------------------------------------
/src/rules/Unserialize.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | use rock\helpers\Serialize;
 7 | 
 8 | class Unserialize extends Rule
 9 | {
10 |     /**
11 |      * @inheritdoc
12 |      */
13 |     public function sanitize($input)
14 |     {
15 |         if (!is_string($input)) {
16 |             return $input;
17 |         }
18 |         return Serialize::unserialize($input, false);
19 |     }
20 | } 


--------------------------------------------------------------------------------
/src/rules/UpperFirst.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class UpperFirst extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? \rock\helpers\StringHelper::upperFirst($input) : $input;
14 |     }
15 | } 


--------------------------------------------------------------------------------
/src/rules/Uppercase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace rock\sanitize\rules;
 4 | 
 5 | 
 6 | class Uppercase extends Rule
 7 | {
 8 |     /**
 9 |      * @inheritdoc
10 |      */
11 |     public function sanitize($input)
12 |     {
13 |         return is_string($input) ? \rock\helpers\StringHelper::upper($input) : $input;
14 |     }
15 | } 


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