Validator::executeCustomRule() - Code Metrics - Inspection of "305 refactor demo module to make it fully standalo..." - softberg/quantum-php-core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#312)

by Arman

created 2025-08-05 16:14 UTC

Validator::executeCustomRule() A

↳ Parent: Validator

Complexity

Conditions	4
Paths	3

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	5
nc	3
nop	4
dl	0
loc	10
rs	10
c	0
b	0
f	0

<?php

/**
 * Quantum PHP Framework
 *
 * An open source software development framework for PHP
 *
 * @package Quantum
 * @author Arman Ag. <[email protected]>
 * @copyright Copyright (c) 2018 Softberg LLC (https://softberg.org)
 * @link http://quantum.softberg.org/
 * @since 2.9.8
 */

namespace Quantum\Libraries\Validation;

use Quantum\Libraries\Validation\Rules\Resource;
use Quantum\Libraries\Validation\Rules\General;
use Quantum\Libraries\Validation\Rules\Length;
use Quantum\Libraries\Validation\Rules\Lists;
use Quantum\Libraries\Validation\Rules\Type;
use Quantum\Libraries\Validation\Rules\File;
use Closure;

/**
 * Class Validator
 * @package Quantum\Libraries\Validation
 */
class Validator
{

    use General;
    use Type;
    use File;
    use Lists;
    use Length;
    use Resource;

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

    /**
     * Validation Errors
     * @var array
     */
    private $errors = [];

    /**
     * Request data
     * @var array
     */
    private $data = [];

    /**
     * Custom validation callbacks
     * @var Closure[]
     */
    private $customValidations = [];

    /**
     * Add rules for a single field
     * @param string $field
     * @param array $rules Format: [['ruleName' => param], ...]
     */
    public function addRule(string $field, array $rules)
    {
        if (empty($field)) {
            return;
        }

        if (!isset($this->rules[$field])) {
            $this->rules[$field] = [];
        }

        foreach ($rules as $rule) {
            $ruleName = key($rule);
            $ruleParam = current($rule);
            $this->rules[$field][$ruleName] = $ruleParam;
        }
    }

    /**
     * Add multiple rules for multiple fields
     * @param array $rules Format: ['field' => [ ['rule' => param], ... ], ...]
     */
    public function addRules(array $rules): void
    {
        foreach ($rules as $field => $fieldRules) {
            $this->addRule($field, $fieldRules);
        }
    }

    /**
     * Update a single rule for a field if exists
     * @param string $field
     * @param array $rule Format: ['ruleName' => param]
     */
    public function updateRule(string $field, array $rule)
    {
        if (empty($field)) {
            return;
        }

        $ruleName = key($rule);
        $ruleParam = current($rule);

        if (isset($this->rules[$field][$ruleName])) {
            $this->rules[$field][$ruleName] = $ruleParam;
        }
    }

    /**
     * Delete a rule or all rules for a given field
     * @param string $field
     * @param string|null $rule Specific rule to delete; if null deletes all rules for field
     * @return void
     */
    public function deleteRule(string $field, string $rule = null): void
    {
        if (empty($field) || !isset($this->rules[$field])) {
            return;
        }

        if ($rule !== null) {
            unset($this->rules[$field][$rule]);
            if (empty($this->rules[$field])) {
                unset($this->rules[$field]);
            }
        } else {
            unset($this->rules[$field]);
        }
    }

    /**
     * Flush all rules and errors
     * @return void
     */
    public function flushRules(): void
    {
        $this->rules = [];
        $this->flushErrors();
    }

    /**
     * Validate given data against defined rules
     * @param array $data
     * @return bool True if valid, false otherwise
     */
    public function isValid(array $data): bool
    {
        $this->data = $data;
        $this->flushErrors();

        if (empty($this->rules)) {
            return true;
        }

        foreach ($this->rules as $field => $_) {
            if (!array_key_exists($field, $data)) {
                $data[$field] = '';
            }
        }

        foreach ($data as $field => $value) {
            if (!isset($this->rules[$field])) {
                continue;
            }

            foreach ($this->rules[$field] as $rule => $param) {
                if (method_exists($this, $rule) && is_callable([$this, $rule])) {
                    $this->$rule($field, $value, $param);
                } elseif (isset($this->customValidations[$rule])) {
                    $this->executeCustomRule($rule, $field, $value, $param);
                }
            }
        }

        return empty($this->errors);
    }

    /**
     * Add a custom validation rule
     * @param string $rule Rule name
     * @param Closure $function Callback function with signature function($value, $param): bool
     * @return void
     */
    public function addValidation(string $rule, Closure $function): void
    {
        if (empty($rule) || !is_callable($function)) {
            return;
        }

        $this->customValidations[$rule] = $function;
    }

    /**
     * Gets validation errors with translations
     * @return array
     */
    public function getErrors(): array
    {
        if (empty($this->errors)) {
            return [];
        }

        $messages = [];

        foreach ($this->errors as $field => $fieldErrors) {
            foreach ($fieldErrors as $rule => $param) {
                $translationParams = [t('common.' . $field)];
                if ($param !== null && $param !== '') {
                    $translationParams[] = $param;
                }

                $messages[$field][] = t("validation.$rule", $translationParams);
            }
        }

        return $messages;
    }

    /**
     * Adds an error for a field and rule
     * @param string $field
     * @param string $rule
     * @param mixed|null $param
     * @return void
     */
    protected function addError(string $field, string $rule, $param = null): void
    {
        if (!isset($this->errors[$field])) {
            $this->errors[$field] = [];
        }

        $this->errors[$field][$rule] = $param;
    }

    /**
     * Flush all errors
     * @return void
     */
    public function flushErrors(): void
    {
        $this->errors = [];
    }

    /**
     * Executes user defined rule
     * @param string $rule
     * @param string $field
     * @param $value
     * @param $param
     */
    protected function executeCustomRule(string $rule, string $field, $value, $param)
    {
        if ($value === '' || $value === null) {
            return;
        }

        $function = $this->customValidations[$rule];

        if (!$function($value, $param)) {
            $this->addError($field, $rule, $param);
        }
    }
}


1			<?php
2
3			/**
4			* Quantum PHP Framework
5			*
6			* An open source software development framework for PHP
7			*
8			* @package Quantum
9			* @author Arman Ag. <[email protected]>
10			* @copyright Copyright (c) 2018 Softberg LLC (https://softberg.org)
11			* @link http://quantum.softberg.org/
12			* @since 2.9.8
13			*/
14
15			namespace Quantum\Libraries\Validation;
16
17			use Quantum\Libraries\Validation\Rules\Resource;
18			use Quantum\Libraries\Validation\Rules\General;
19			use Quantum\Libraries\Validation\Rules\Length;
20			use Quantum\Libraries\Validation\Rules\Lists;
21			use Quantum\Libraries\Validation\Rules\Type;
22			use Quantum\Libraries\Validation\Rules\File;
23			use Closure;
24
25			/**
26			* Class Validator
27			* @package Quantum\Libraries\Validation
28			*/
29			class Validator
30			{
31
32			use General;
33			use Type;
34			use File;
35			use Lists;
36			use Length;
37			use Resource;
38
39			/**
40			* Rules
41			* @var array
42			*/
43			private $rules = [];
44
45			/**
46			* Validation Errors
47			* @var array
48			*/
49			private $errors = [];
50
51			/**
52			* Request data
53			* @var array
54			*/
55			private $data = [];
56
57			/**
58			* Custom validation callbacks
59			* @var Closure[]
60			*/
61			private $customValidations = [];
62
63			/**
64			* Add rules for a single field
65			* @param string $field
66			* @param array $rules Format: [['ruleName' => param], ...]
67			*/
68			public function addRule(string $field, array $rules)
69			{
70			if (empty($field)) {
71			return;
72			}
73
74			if (!isset($this->rules[$field])) {
75			$this->rules[$field] = [];
76			}
77
78			foreach ($rules as $rule) {
79			$ruleName = key($rule);
80			$ruleParam = current($rule);
81			$this->rules[$field][$ruleName] = $ruleParam;
82			}
83			}
84
85			/**
86			* Add multiple rules for multiple fields
87			* @param array $rules Format: ['field' => [ ['rule' => param], ... ], ...]
88			*/
89			public function addRules(array $rules): void
90			{
91			foreach ($rules as $field => $fieldRules) {
92			$this->addRule($field, $fieldRules);
93			}
94			}
95
96			/**
97			* Update a single rule for a field if exists
98			* @param string $field
99			* @param array $rule Format: ['ruleName' => param]
100			*/
101			public function updateRule(string $field, array $rule)
102			{
103			if (empty($field)) {
104			return;
105			}
106
107			$ruleName = key($rule);
108			$ruleParam = current($rule);
109
110			if (isset($this->rules[$field][$ruleName])) {
111			$this->rules[$field][$ruleName] = $ruleParam;
112			}
113			}
114
115			/**
116			* Delete a rule or all rules for a given field
117			* @param string $field
118			* @param string\|null $rule Specific rule to delete; if null deletes all rules for field
119			* @return void
120			*/
121			public function deleteRule(string $field, string $rule = null): void
122			{
123			if (empty($field) \|\| !isset($this->rules[$field])) {
124			return;
125			}
126
127			if ($rule !== null) {
128			unset($this->rules[$field][$rule]);
129			if (empty($this->rules[$field])) {
130			unset($this->rules[$field]);
131			}
132			} else {
133			unset($this->rules[$field]);
134			}
135			}
136
137			/**
138			* Flush all rules and errors
139			* @return void
140			*/
141			public function flushRules(): void
142			{
143			$this->rules = [];
144			$this->flushErrors();
145			}
146
147			/**
148			* Validate given data against defined rules
149			* @param array $data
150			* @return bool True if valid, false otherwise
151			*/
152			public function isValid(array $data): bool
153			{
154			$this->data = $data;
155			$this->flushErrors();
156
157			if (empty($this->rules)) {
158			return true;
159			}
160
161			foreach ($this->rules as $field => $_) {
162			if (!array_key_exists($field, $data)) {
163			$data[$field] = '';
164			}
165			}
166
167			foreach ($data as $field => $value) {
168			if (!isset($this->rules[$field])) {
169			continue;
170			}
171
172			foreach ($this->rules[$field] as $rule => $param) {
173			if (method_exists($this, $rule) && is_callable([$this, $rule])) {
174			$this->$rule($field, $value, $param);
175			} elseif (isset($this->customValidations[$rule])) {
176			$this->executeCustomRule($rule, $field, $value, $param);
177			}
178			}
179			}
180
181			return empty($this->errors);
182			}
183
184			/**
185			* Add a custom validation rule
186			* @param string $rule Rule name
187			* @param Closure $function Callback function with signature function($value, $param): bool
188			* @return void
189			*/
190			public function addValidation(string $rule, Closure $function): void
191			{
192			if (empty($rule) \|\| !is_callable($function)) {
193			return;
194			}
195
196			$this->customValidations[$rule] = $function;
197			}
198
199			/**
200			* Gets validation errors with translations
201			* @return array
202			*/
203			public function getErrors(): array
204			{
205			if (empty($this->errors)) {
206			return [];
207			}
208
209			$messages = [];
210
211			foreach ($this->errors as $field => $fieldErrors) {
212			foreach ($fieldErrors as $rule => $param) {
213			$translationParams = [t('common.' . $field)];
214			if ($param !== null && $param !== '') {
215			$translationParams[] = $param;
216			}
217
218			$messages[$field][] = t("validation.$rule", $translationParams);
219			}
220			}
221
222			return $messages;
223			}
224
225			/**
226			* Adds an error for a field and rule
227			* @param string $field
228			* @param string $rule
229			* @param mixed\|null $param
230			* @return void
231			*/
232			protected function addError(string $field, string $rule, $param = null): void
233			{
234			if (!isset($this->errors[$field])) {
235			$this->errors[$field] = [];
236			}
237
238			$this->errors[$field][$rule] = $param;
239			}
240
241			/**
242			* Flush all errors
243			* @return void
244			*/
245			public function flushErrors(): void
246			{
247			$this->errors = [];
248			}
249
250			/**
251			* Executes user defined rule
252			* @param string $rule
253			* @param string $field
254			* @param $value
255			* @param $param
256			*/
257			protected function executeCustomRule(string $rule, string $field, $value, $param)
258			{
259			if ($value === '' \|\| $value === null) {
260			return;
261			}
262
263			$function = $this->customValidations[$rule];
264
265			if (!$function($value, $param)) {
266			$this->addError($field, $rule, $param);
267			}
268			}
269			}
270

softberg / quantum-php-core

Pull Request — master (#312)

Validator::executeCustomRule() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like