FilterResource::regexReplace() - Code Metrics - Inspection of "Adds a rule to slug a field with its own value or..." - particle-php/Filter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#47)

unknown

created 2016-06-30 10:01 UTC

FilterResource::regexReplace() A

↳ Parent: FilterResource

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	2
crap	1

<?php
/**
 * Particle.
 *
 * @link      http://github.com/particle-php for the canonical source repository
 * @copyright Copyright (c) 2005-2015 Particle (http://particle-php.com)
 * @license   https://github.com/particle-php/Filter/blob/master/LICENSE New BSD License
 */
namespace Particle\Filter;

/**
 * Class FilterResource
 * @package Particle\Filter
 */
class FilterResource
{
    /**
     * @var Filter
     */
    protected $filter;

    /**
     * @var null|string|string[]
     */
    protected $keys;

    /**
     * @param Filter $filter
     * @param null|string|string[] $keys
     */
    public function __construct(Filter $filter, $keys = null)
    {
        $this->filter = $filter;
        $this->keys = $keys;
    }

    /**
     * Results rule that returns alphabetic numeric characters from the value
     *
     * @return $this
     */
    public function alnum()
    {
        return $this->addRule(new FilterRule\AlNum);
    }

    /**
     * Results rule that returns the value appended with a given value
     *
     * @param string $append
     * @return Chain
     */
    public function append($append)
    {
        return $this->addRule(new FilterRule\Append($append));
    }

    /**
     * Results rule that returns a casted boolean
     *
     * @return $this
     */
    public function bool()
    {
        return $this->addRule(new FilterRule\CastBool);
    }

    /**
     * Returns rule that returns a value modified by a callable closure
     *
     * @param callable $callable
     * @param bool $allowNotSet
     * @return $this
     */
    public function callback(callable $callable, $allowNotSet = false)
    {
        return $this->addRule(new FilterRule\Callback($callable, $allowNotSet));
    }

    /**
     * Returns rule that defaults a given value if the data key was not provided
     *
     * @param mixed $defaultValue
     * @return $this
     */
    public function defaults($defaultValue)
    {
        return $this->addRule(new FilterRule\Defaults($defaultValue));
    }

    /**
     * Returns rule that can filter repeated nested arrays
     *
     * @param callable $callable
     * @return $this
     */
    public function each(callable $callable)
    {
        return $this->addRule(new FilterRule\Each($callable));
    }

    /**
     * Returns rule that returns an value in a specific encoding format
     *
     * @param string|null $toEncodingFormat
     * @param string|null $fromEncodingFormat
     * @return $this
     */
    public function encode($toEncodingFormat = null, $fromEncodingFormat = null)
    {
        return $this->addRule(new FilterRule\Encode($toEncodingFormat, $fromEncodingFormat));
    }

    /**
     * Returns rule that results a casted float
     *
     * @return $this
     */
    public function float()
    {
        return $this->addRule(new FilterRule\CastFloat);
    }

    /**
     * Returns rule that results a casted int
     *
     * @return $this
     */
    public function int()
    {
        return $this->addRule(new FilterRule\CastInt);
    }

    /**
     * Returns rule that results all letters of a value
     *
     * @return $this
     */
    public function letters()
    {
        return $this->addRule(new FilterRule\Letters);
    }

    /**
     * Returns rule that results a lower-cased value
     *
     * @return $this
     */
    public function lower()
    {
        return $this->addRule(new FilterRule\Lower);
    }

    /**
     * Returns rule that formats numbers
     *
     * @param int $decimals
     * @param string $decimalPoint
     * @param string $thousandSeparator
     * @return $this
     */
    public function numberFormat($decimals, $decimalPoint, $thousandSeparator)
    {
        return $this->addRule(new FilterRule\NumberFormat($decimals, $decimalPoint, $thousandSeparator));
    }

    /**
     * Returns rule that results all numbers of a value
     *
     * @return $this
     */
    public function numbers()
    {
        return $this->addRule(new FilterRule\Numbers);
    }

    /**
     * Results rule that returns the value prepended with a given value
     *
     * @param string $prepend
     * @return Chain
     */
    public function prepend($prepend)
    {
        return $this->addRule(new FilterRule\Prepend($prepend));
    }

    /**
     * Results rule that returns a value with replacements by a regex
     *
     * @param string $searchRegex
     * @param string $replace
     * @return $this
     */
    public function regexReplace($searchRegex, $replace)
    {
        return $this->addRule(new FilterRule\RegexReplace($searchRegex, $replace));
    }

    /**
     * Results rule that returns an empty result so it can be removed
     *
     * @return $this
     */
    public function remove()
    {
        return $this->addRule(new FilterRule\Remove);
    }

    /**
     * Results rule that returns an empty result when the value is null so it can be removed
     *
     * @return $this
     */
    public function removeNull()
    {
        return $this->addRule(new FilterRule\RemoveNull);
    }

    /**
     * Results rule that returns a value with replacements
     *
     * @param mixed $search
     * @param mixed $replace
     * @return $this
     */
    public function replace($search, $replace)
    {
        return $this->addRule(new FilterRule\Replace($search, $replace));
    }

    /**
     * @param type $fieldToSlugFrom
     */
    public function slug($fieldToSlugFrom = null)
    {
        return $this->addRule(new FilterRule\Slug($fieldToSlugFrom));

    }

    /**
     * Returns rule that results a casted string
     *
     * @return $this
     */
    public function string()
    {
        return $this->addRule(new FilterRule\CastString);
    }

    /**
     * Results rule that results a html-stripped value
     *
     * @param null|string $excludeTags
     * @return $this
     */
    public function stripHtml($excludeTags = null)
    {
        return $this->addRule(new FilterRule\StripHtml($excludeTags));
    }

    /**
     * Returns rule that results a trimmed value
     *
     * @param string|null $characters
     * @return $this
     */
    public function trim($characters = null)
    {
        return $this->addRule(new FilterRule\Trim($characters));
    }

    /**
     * Results rule that returns an upper-cased value
     *
     * @return $this
     */
    public function upper()
    {
        return $this->addRule(new FilterRule\Upper);
    }

    /**
     * Returns rule that results a value starting with a upper-cased character
     *
     * @return $this
     */
    public function upperFirst()
    {
        return $this->addRule(new FilterRule\UpperFirst);
    }

    /**
     * Add a new rule to the chain
     *
     * @param FilterRule $rule
     * @return $this
     */
    protected function addRule(FilterRule $rule)
    {
        if ($this->keys === null) {
            $this->filter->addFilterRule($rule);
        }

        if (is_array($this->keys)) {
            foreach ($this->keys as $key) {
                $this->filter->addFilterRule($rule, $key);
            }
        } else {
            $this->filter->addFilterRule($rule, $this->keys);
        }

        return $this;
    }
}


1		<?php
2		/**
3		* Particle.
4		*
5		* @link http://github.com/particle-php for the canonical source repository
6		* @copyright Copyright (c) 2005-2015 Particle (http://particle-php.com)
7		* @license https://github.com/particle-php/Filter/blob/master/LICENSE New BSD License
8		*/
9		namespace Particle\Filter;
10
11		/**
12		* Class FilterResource
13		* @package Particle\Filter
14		*/
15		class FilterResource
16		{
17		/**
18		* @var Filter
19		*/
20		protected $filter;
21
22		/**
23		* @var null\|string\|string[]
24		*/
25		protected $keys;
26
27		/**
28		* @param Filter $filter
29		* @param null\|string\|string[] $keys
30		*/
31	171	public function __construct(Filter $filter, $keys = null)
32		{
33	171	$this->filter = $filter;
34	171	$this->keys = $keys;
35	171	}
36
37		/**
38		* Results rule that returns alphabetic numeric characters from the value
39		*
40		* @return $this
41		*/
42	4	public function alnum()
43		{
44	4	return $this->addRule(new FilterRule\AlNum);
45		}
46
47		/**
48		* Results rule that returns the value appended with a given value
49		*
50		* @param string $append
51		* @return Chain
52		*/
53	4	public function append($append)
54		{
55	4	return $this->addRule(new FilterRule\Append($append));
56		}
57
58		/**
59		* Results rule that returns a casted boolean
60		*
61		* @return $this
62		*/
63	16	public function bool()
64		{
65	16	return $this->addRule(new FilterRule\CastBool);
66		}
67
68		/**
69		* Returns rule that returns a value modified by a callable closure
70		*
71		* @param callable $callable
72		* @param bool $allowNotSet
73		* @return $this
74		*/
75	6	public function callback(callable $callable, $allowNotSet = false)
76		{
77	6	return $this->addRule(new FilterRule\Callback($callable, $allowNotSet));
78		}
79
80		/**
81		* Returns rule that defaults a given value if the data key was not provided
82		*
83		* @param mixed $defaultValue
84		* @return $this
85		*/
86	13	public function defaults($defaultValue)
87		{
88	13	return $this->addRule(new FilterRule\Defaults($defaultValue));
89		}
90
91		/**
92		* Returns rule that can filter repeated nested arrays
93		*
94		* @param callable $callable
95		* @return $this
96		*/
97	2	public function each(callable $callable)
98		{
99	2	return $this->addRule(new FilterRule\Each($callable));
100		}
101
102		/**
103		* Returns rule that returns an value in a specific encoding format
104		*
105		* @param string\|null $toEncodingFormat
106		* @param string\|null $fromEncodingFormat
107		* @return $this
108		*/
109	5	public function encode($toEncodingFormat = null, $fromEncodingFormat = null)
110		{
111	5	return $this->addRule(new FilterRule\Encode($toEncodingFormat, $fromEncodingFormat));
112		}
113
114		/**
115		* Returns rule that results a casted float
116		*
117		* @return $this
118		*/
119	12	public function float()
120		{
121	12	return $this->addRule(new FilterRule\CastFloat);
122		}
123
124		/**
125		* Returns rule that results a casted int
126		*
127		* @return $this
128		*/
129	11	public function int()
130		{
131	11	return $this->addRule(new FilterRule\CastInt);
132		}
133
134		/**
135		* Returns rule that results all letters of a value
136		*
137		* @return $this
138		*/
139	3	public function letters()
140		{
141	3	return $this->addRule(new FilterRule\Letters);
142		}
143
144		/**
145		* Returns rule that results a lower-cased value
146		*
147		* @return $this
148		*/
149	17	public function lower()
150		{
151	17	return $this->addRule(new FilterRule\Lower);
152		}
153
154		/**
155		* Returns rule that formats numbers
156		*
157		* @param int $decimals
158		* @param string $decimalPoint
159		* @param string $thousandSeparator
160		* @return $this
161		*/
162	12	public function numberFormat($decimals, $decimalPoint, $thousandSeparator)
163		{
164	12	return $this->addRule(new FilterRule\NumberFormat($decimals, $decimalPoint, $thousandSeparator));
165		}
166
167		/**
168		* Returns rule that results all numbers of a value
169		*
170		* @return $this
171		*/
172	3	public function numbers()
173		{
174	3	return $this->addRule(new FilterRule\Numbers);
175		}
176
177		/**
178		* Results rule that returns the value prepended with a given value
179		*
180		* @param string $prepend
181		* @return Chain
182		*/
183	4	public function prepend($prepend)
184		{
185	4	return $this->addRule(new FilterRule\Prepend($prepend));
186		}
187
188		/**
189		* Results rule that returns a value with replacements by a regex
190		*
191		* @param string $searchRegex
192		* @param string $replace
193		* @return $this
194		*/
195	2	public function regexReplace($searchRegex, $replace)
196		{
197	2	return $this->addRule(new FilterRule\RegexReplace($searchRegex, $replace));
198		}
199
200		/**
201		* Results rule that returns an empty result so it can be removed
202		*
203		* @return $this
204		*/
205	5	public function remove()
206		{
207	5	return $this->addRule(new FilterRule\Remove);
208		}
209
210		/**
211		* Results rule that returns an empty result when the value is null so it can be removed
212		*
213		* @return $this
214		*/
215	7	public function removeNull()
216		{
217	7	return $this->addRule(new FilterRule\RemoveNull);
218		}
219
220		/**
221		* Results rule that returns a value with replacements
222		*
223		* @param mixed $search
224		* @param mixed $replace
225		* @return $this
226		*/
227	5	public function replace($search, $replace)
228		{
229	5	return $this->addRule(new FilterRule\Replace($search, $replace));
230		}
231
232		/**
233		* @param type $fieldToSlugFrom
234		*/
235	7	public function slug($fieldToSlugFrom = null)
236		{
237	7	return $this->addRule(new FilterRule\Slug($fieldToSlugFrom));
		0 ignored issues – show Bug introduced 2016-06-30 10:10 UTC by Report Bug Copy Issue Report It seems like `$fieldToSlugFrom` defined by parameter `$fieldToSlugFrom` on line 235 can also be of type `null`; however, `Particle\Filter\FilterRule\Slug::__construct()` does only seem to accept `string`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
238		}
239
240		/**
241		* Returns rule that results a casted string
242		*
243		* @return $this
244		*/
245	7	public function string()
246		{
247	7	return $this->addRule(new FilterRule\CastString);
248		}
249
250		/**
251		* Results rule that results a html-stripped value
252		*
253		* @param null\|string $excludeTags
254		* @return $this
255		*/
256	4	public function stripHtml($excludeTags = null)
257		{
258	4	return $this->addRule(new FilterRule\StripHtml($excludeTags));
259		}
260
261		/**
262		* Returns rule that results a trimmed value
263		*
264		* @param string\|null $characters
265		* @return $this
266		*/
267	21	public function trim($characters = null)
268		{
269	21	return $this->addRule(new FilterRule\Trim($characters));
270		}
271
272		/**
273		* Results rule that returns an upper-cased value
274		*
275		* @return $this
276		*/
277	7	public function upper()
278		{
279	7	return $this->addRule(new FilterRule\Upper);
280		}
281
282		/**
283		* Returns rule that results a value starting with a upper-cased character
284		*
285		* @return $this
286		*/
287	14	public function upperFirst()
288		{
289	14	return $this->addRule(new FilterRule\UpperFirst);
290		}
291
292		/**
293		* Add a new rule to the chain
294		*
295		* @param FilterRule $rule
296		* @return $this
297		*/
298	170	protected function addRule(FilterRule $rule)
299		{
300	170	if ($this->keys === null) {
301	4	$this->filter->addFilterRule($rule);
302	4	}
303
304	170	if (is_array($this->keys)) {
305	6	foreach ($this->keys as $key) {
306	6	$this->filter->addFilterRule($rule, $key);
307	6	}
308	6	} else {
309	165	$this->filter->addFilterRule($rule, $this->keys);
310		}
311
312	170	return $this;
313		}
314		}
315

particle-php / Filter

Pull Request — master (#47)

FilterResource::regexReplace() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like