Filter::ruleToField() - Code Metrics - Inspection of "initial commit" - linna/filter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6a6c7b...f57853 )

by Sebastian

created 2017-11-19 22:06 UTC

Filter::ruleToField() B

↳ Parent: Filter

Complexity

Conditions	6
Paths	17

Size

Total Lines	24
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	42

Importance

Changes

Metric	Value
cc	6
eloc	15
nc	17
nop	1
dl	0
loc	24
ccs	0
cts	19
cp	0
crap	42
rs	8.5125
c	0
b	0
f	0

<?php

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

namespace Linna\Filter;

use ReflectionClass;

/**
 * Filter.
 */
class Filter
{
    /**
     * @var array Rules for filtering.
     */
    private $rules = [];
    
    /**
     * @var array User data.
     */
    private $data = [];
    
    /**
     * @var array Error messages.
     */
    private $messages = [];
    
    /**
     * @var int Occurred errors.
     */
    private $errors = 0;

    /**
     * Class constructor.
     *
     * @param array $rules
     * @param array $data
     */
    public function __construct(array $rules, array $data)
    {
        $this->rules = $rules;
        $this->data = $data;

        $this->getRules();
    }

    /**
     * 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;
    }

    /**
     * Get parsed rules.
     */
    private function getRules()
    {
        $rules = $this->rules;
        
        foreach ($rules as $rule) {
            $this->ruleToField((new RuleInterpreter($rule))->get());
        }
    }

    /**
     * Apply rules to a field.
     *
     * @param array $rules
     */
    private function ruleToField(array $rules)
    {
        foreach ($rules as $rule) {
            $field = $rule[0];
            $filter = $rule[2][0];
            $expected = $rule[3];
            $args = [];
            
            $received = (isset($this->data[$field])) ? $this->data[$field] : '';

            if (is_array($expected)) {
                array_unshift($expected, $received);
                $args = $expected;
            }

            if (!is_array($expected)) {
                $args = [$received, $expected];
            }

            $instance = (new ReflectionClass('Linna\Filter\Rules\\' . $filter))->newInstanceArgs($args);

            if ($instance->test()) {
                $this->errors++;
                $this->messages[$field][$filter] = ['expected' => $expected, 'received' => $received];
            }
        }
    }
}


1			<?php
2
3			/**
4			* Linna Filter
5			*
6			* @author Sebastian Rapetti <[email protected]>
7			* @copyright (c) 2017, 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 ReflectionClass;
15
16			/**
17			* Filter.
18			*/
19			class Filter
20			{
21			/**
22			* @var array Rules for filtering.
23			*/
24			private $rules = [];
25
26			/**
27			* @var array User data.
28			*/
29			private $data = [];
30
31			/**
32			* @var array Error messages.
33			*/
34			private $messages = [];
35
36			/**
37			* @var int Occurred errors.
38			*/
39			private $errors = 0;
40
41			/**
42			* Class constructor.
43			*
44			* @param array $rules
45			* @param array $data
46			*/
47			public function __construct(array $rules, array $data)
48			{
49			$this->rules = $rules;
50			$this->data = $data;
51
52			$this->getRules();
53			}
54
55			/**
56			* Return occurred error number.
57			*
58			* @return int
59			*/
60			public function getErrors(): int
61			{
62			return $this->errors;
63			}
64
65			/**
66			* Return error messages.
67			*
68			* @return array
69			*/
70			public function getMessages(): array
71			{
72			return $this->messages;
73			}
74
75			/**
76			* Get parsed rules.
77			*/
78			private function getRules()
79			{
80			$rules = $this->rules;
81
82			foreach ($rules as $rule) {
83			$this->ruleToField((new RuleInterpreter($rule))->get());
84			}
85			}
86
87			/**
88			* Apply rules to a field.
89			*
90			* @param array $rules
91			*/
92			private function ruleToField(array $rules)
93			{
94			foreach ($rules as $rule) {
95			$field = $rule[0];
96			$filter = $rule[2][0];
97			$expected = $rule[3];
98			$args = [];
99
100			$received = (isset($this->data[$field])) ? $this->data[$field] : '';
101
102			if (is_array($expected)) {
103			array_unshift($expected, $received);
104			$args = $expected;
105			}
106
107			if (!is_array($expected)) {
108			$args = [$received, $expected];
109			}
110
111			$instance = (new ReflectionClass('Linna\Filter\Rules\\' . $filter))->newInstanceArgs($args);
112
113			if ($instance->test()) {
114			$this->errors++;
115			$this->messages[$field][$filter] = ['expected' => $expected, 'received' => $received];
116			}
117			}
118			}
119			}
120

linna / filter

Push — master ( 6a6c7b...f57853 )

Filter::ruleToField() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like