Filter::addCustomRules() - Code Metrics - Inspection of "CustomRule class added" - linna/filter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — b0.3.0 ( 326260...c79ea7 )

by Sebastian

created 2018-09-09 17:35 UTC

Filter::addCustomRules() A

↳ Parent: Filter

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

/**
 * Linna Filter
 *
 * @author Sebastian Rapetti <[email protected]>
 * @copyright (c) 2018, Sebastian Rapetti
 * @license http://opensource.org/licenses/MIT MIT License
 */
declare(strict_types=1);

namespace Linna\Filter;

use InvalidArgumentException;
use Linna\Filter\Rules\CustomRule;
use Linna\Filter\Rules\RuleSanitizeInterface;
use Linna\Filter\Rules\RuleValidateInterface;
use Linna\Filter\Result;

/**
 * Filter.
 */
class Filter
{
    /**
     * @var array User data.
     */
    private $data = [];

    /**
     * @var array Sanitized data.
     */
    private $sanitizedData = [];

    /**
     * @var array Error messages.
     */
    private $messages = [];

    /**
     * @var int Occurred errors.
     */
    private $errors = 0;

    /**
     * @var array Filters rules.
     */
    private $rules = [];

    /**
     * @var array Rule aliases.
     */
    private $alias = [];

    /**
     * Class Constructor.
     */
    public function __construct()
    {
        [$this->rules, $this->alias] = RuleBuilder::build();
    }

    /**
     * Add custom rules to filter.
     *
     * @param array $customRules
     */
    public function addCustomRules(array $customRules): void
    {
        [$rules, $alias] = RuleBuilder::buildCustom($customRules);

        $this->rules = array_merge($this->rules, $rules);
        $this->alias = array_merge($this->alias, $alias);
    }

    /**
     * Filter.
     *
     * @param mixed        $data
     * @param array|string $rule
     *
     * @throws InvalidArgumentException If rule isn't a string when used for only
     *                                  one value. If data and rule aren't array
     *                                  when used for multi values.
     *
     * @return Result
     */
    public function filter($data, $rule): Result
    {
        if (is_array($data) && is_array($rule)) {
            $this->sanitizedData = $this->data = $data;
            $this->interpreteRules($rule);

            return $this->buildResultObject();
        }

        if (is_string($rule)) {
            $this->sanitizedData = $this->data = ['data' => $data];
            $this->interpreteRules(['data '.$rule]);

            return $this->buildResultObject();
        }

        throw new InvalidArgumentException('Invalid types passed for data or rules.');
    }

    /**
     * Build anonymous class contain results of filtering.
     *
     * @return Result
     */
    private function buildResultObject(): Result
    {
        return new class($this->sanitizedData, $this->messages, $this->errors) extends Result {
        };
    }

    /**
     * Return occurred error number.
     *
     * @return int
     */
    public function getErrors(): int
    {
        return $this->errors;
    }

    /**
     * Return error messages.
     *
     * @return array
     */
    public function getMessages(): array
    {
        return $this->messages;
    }

    /**
     * Return passed data.
     *
     * @return array
     */
    public function getData(): array
    {
        return $this->sanitizedData;
    }

    /**
     * Get parsed rules.
     */
    private function interpreteRules($rules): void
    {
        $parser = new Parser();
        $lexer = new Lexer();

        foreach ($rules as $rule) {
            $this->ruleToField(
                $parser->parse(
                    $lexer->tokenize($rule),
                    $this->rules,
                    $this->alias
                )
            );
        }
    }

    /**
     * Apply rules to a field.
     *
     * @param array $rules
     */
    private function ruleToField(array $rules): void
    {
        foreach ($rules as $rule) {
            $field = $rule[0];
            $ruleProps = $this->rules[$rule[1]];
            $ruleParams = $rule[2];

            //initialize message array
            $this->messages[$field] = $this->messages[$field] ?? [];

            //check if value is isset in data
            if ($this->checkValue($field)) {
                continue;
            }

            $instance = $ruleProps['instance'] ?? new $ruleProps['full_class']();

            //invoke custom rule validate
            if ($instance instanceof CustomRule) {
                $this->invokeValidate($instance, $field, $ruleParams);
                continue;
            }

            //invoke validate section of the filter
            if ($instance instanceof RuleValidateInterface) {
                $this->invokeValidate($instance, $field, $ruleParams);
            }

            //invoke sanitize section of the filter
            if ($instance instanceof RuleSanitizeInterface) {
                $instance->sanitize($this->sanitizedData[$field]);
            }
        }
    }

    /**
     * Check if a field exist in data.
     *
     * @param string $field
     *
     * @return bool
     */
    private function checkValue(string &$field): bool
    {
        if (isset($this->data[$field])) {
            return false;
        }

        $this->errors++;
        $this->messages[$field][] = "Form field '{$field}' missing.";

        return true;
    }

    /**
     * Invoke validate.
     *
     * @param RuleValidateInterface $instance
     * @param string                $field
     * @param array                 $ruleParams
     */
    private function invokeValidate(RuleValidateInterface &$instance, string $field, array $ruleParams): void
    {
        array_unshift($ruleParams, $this->data[$field]);

        if (call_user_func_array(array($instance, 'validate'), $ruleParams)) {
            $this->errors++;

            $message = $instance->getMessage();

            if (strlen($message)) {
                $this->messages[$field][] = $message;
            }
        }
    }
}


1		<?php
2
3		/**
4		* Linna Filter
5		*
6		* @author Sebastian Rapetti <[email protected]>
7		* @copyright (c) 2018, Sebastian Rapetti
8		* @license http://opensource.org/licenses/MIT MIT License
9		*/
10		declare(strict_types=1);
11
12		namespace Linna\Filter;
13
14		use InvalidArgumentException;
15		use Linna\Filter\Rules\CustomRule;
16		use Linna\Filter\Rules\RuleSanitizeInterface;
17		use Linna\Filter\Rules\RuleValidateInterface;
18		use Linna\Filter\Result;
19
20		/**
21		* Filter.
22		*/
23		class Filter
24		{
25		/**
26		* @var array User data.
27		*/
28		private $data = [];
29
30		/**
31		* @var array Sanitized data.
32		*/
33		private $sanitizedData = [];
34
35		/**
36		* @var array Error messages.
37		*/
38		private $messages = [];
39
40		/**
41		* @var int Occurred errors.
42		*/
43		private $errors = 0;
44
45		/**
46		* @var array Filters rules.
47		*/
48		private $rules = [];
49
50		/**
51		* @var array Rule aliases.
52		*/
53		private $alias = [];
54
55		/**
56		* Class Constructor.
57		*/
58	81	public function __construct()
59		{
60	81	[$this->rules, $this->alias] = RuleBuilder::build();
61	81	}
62
63		/**
64		* Add custom rules to filter.
65		*
66		* @param array $customRules
67		*/
68		public function addCustomRules(array $customRules): void
69		{
70		[$rules, $alias] = RuleBuilder::buildCustom($customRules);
71
72		$this->rules = array_merge($this->rules, $rules);
73		$this->alias = array_merge($this->alias, $alias);
74		}
75
76		/**
77		* Filter.
78		*
79		* @param mixed $data
80		* @param array\|string $rule
81		*
82		* @throws InvalidArgumentException If rule isn't a string when used for only
83		* one value. If data and rule aren't array
84		* when used for multi values.
85		*
86		* @return Result
87		*/
88	81	public function filter($data, $rule): Result
89		{
90	81	if (is_array($data) && is_array($rule)) {
91	55	$this->sanitizedData = $this->data = $data;
92	55	$this->interpreteRules($rule);
93
94	55	return $this->buildResultObject();
95		}
96
97	26	if (is_string($rule)) {
98	25	$this->sanitizedData = $this->data = ['data' => $data];
99	25	$this->interpreteRules(['data '.$rule]);
100
101	25	return $this->buildResultObject();
102		}
103
104	1	throw new InvalidArgumentException('Invalid types passed for data or rules.');
105		}
106
107		/**
108		* Build anonymous class contain results of filtering.
109		*
110		* @return Result
111		*/
112		private function buildResultObject(): Result
113		{
114		return new class($this->sanitizedData, $this->messages, $this->errors) extends Result {
115		};
116		}
117
118		/**
119		* Return occurred error number.
120		*
121		* @return int
122		*/
123	53	public function getErrors(): int
124		{
125	53	return $this->errors;
126		}
127
128		/**
129		* Return error messages.
130		*
131		* @return array
132		*/
133	26	public function getMessages(): array
134		{
135	26	return $this->messages;
136		}
137
138		/**
139		* Return passed data.
140		*
141		* @return array
142		*/
143	2	public function getData(): array
144		{
145	2	return $this->sanitizedData;
146		}
147
148		/**
149		* Get parsed rules.
150		*/
151	80	private function interpreteRules($rules): void
152		{
153	80	$parser = new Parser();
154	80	$lexer = new Lexer();
155
156	80	foreach ($rules as $rule) {
157	80	$this->ruleToField(
158	80	$parser->parse(
159	80	$lexer->tokenize($rule),
160	80	$this->rules,
161	80	$this->alias
162		)
163		);
164		}
165	80	}
166
167		/**
168		* Apply rules to a field.
169		*
170		* @param array $rules
171		*/
172	80	private function ruleToField(array $rules): void
173		{
174	80	foreach ($rules as $rule) {
175	80	$field = $rule[0];
176	80	$ruleProps = $this->rules[$rule[1]];
177	80	$ruleParams = $rule[2];
178
179		//initialize message array
180	80	$this->messages[$field] = $this->messages[$field] ?? [];
181
182		//check if value is isset in data
183	80	if ($this->checkValue($field)) {
184	3	continue;
185		}
186
187	78	$instance = $ruleProps['instance'] ?? new $ruleProps['full_class']();
188
189		//invoke custom rule validate
190	78	if ($instance instanceof CustomRule) {
191		$this->invokeValidate($instance, $field, $ruleParams);
192		continue;
193		}
194
195		//invoke validate section of the filter
196	78	if ($instance instanceof RuleValidateInterface) {
197	78	$this->invokeValidate($instance, $field, $ruleParams);
198		}
199
200		//invoke sanitize section of the filter
201	78	if ($instance instanceof RuleSanitizeInterface) {
202	78	$instance->sanitize($this->sanitizedData[$field]);
203		}
204		}
205	80	}
206
207		/**
208		* Check if a field exist in data.
209		*
210		* @param string $field
211		*
212		* @return bool
213		*/
214	80	private function checkValue(string &$field): bool
215		{
216	80	if (isset($this->data[$field])) {
217	78	return false;
218		}
219
220	3	$this->errors++;
221	3	$this->messages[$field][] = "Form field '{$field}' missing.";
222
223	3	return true;
224		}
225
226		/**
227		* Invoke validate.
228		*
229		* @param RuleValidateInterface $instance
230		* @param string $field
231		* @param array $ruleParams
232		*/
233	78	private function invokeValidate(RuleValidateInterface &$instance, string $field, array $ruleParams): void
234		{
235	78	array_unshift($ruleParams, $this->data[$field]);
236
237	78	if (call_user_func_array(array($instance, 'validate'), $ruleParams)) {
238	46	$this->errors++;
239
240	46	$message = $instance->getMessage();
241
242	46	if (strlen($message)) {
243	46	$this->messages[$field][] = $message;
244		}
245		}
246	78	}
247		}
248

linna / filter

Push — b0.3.0 ( 326260...c79ea7 )

Filter::addCustomRules() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like