Validator::getAllRules() - Code Metrics - Inspection of "[+]: optimize "auto"-values (small revert)" - voku/HtmlFormValidator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b062f4...fb9144 )

by Lars

created 2017-12-17 23:04 UTC

Validator::getAllRules() A

↳ Parent: Validator

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

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

<?php

declare(strict_types=1);

namespace voku\HtmlFormValidator;

use Respect\Validation\Exceptions\ComponentException;
use Respect\Validation\Exceptions\NestedValidationException;
use Respect\Validation\Exceptions\ValidationException;
use Respect\Validation\Factory;
use Respect\Validation\Rules\AbstractRule;
use Respect\Validation\Rules\Email;
use Respect\Validation\Rules\HexRgbColor;
use Respect\Validation\Rules\Url;
use voku\helper\HtmlDomParser;
use voku\helper\SimpleHtmlDom;
use voku\helper\UTF8;
use voku\HtmlFormValidator\Exceptions\NoValidationRule;
use voku\HtmlFormValidator\Exceptions\UnknownFilter;
use voku\HtmlFormValidator\Exceptions\UnknownValidationRule;

class Validator
{
  /**
   * @var HtmlDomParser
   */
  private $formDocument;

  /**
   * @var string[][]
   */
  private $rules = [];

  /**
   * @var string[][]
   */
  private $required_rules = [];

  /**
   * @var string[][]
   */
  private $filters = [];

  /**
   * @var callable[]
   */
  private $filters_custom = [];

  /**
   * @var callable|null
   */
  private $translator;

  /**
   * @var ValidatorRulesManager
   */
  private $validatorRulesManager;

  /**
   * @var string
   */
  private $selector;

  /**
   * @param string $formHTML
   * @param string $selector
   */
  public function __construct($formHTML, $selector = '')
  {
    $this->validatorRulesManager = new ValidatorRulesManager();

    $this->formDocument = HtmlDomParser::str_get_html($formHTML);

    $this->selector = $selector;

    $this->parseHtmlDomForRules();
  }

  /**
   * @param string   $name   <p>A name for the "data-filter"-attribute in the dom.</p>
   * @param callable $filter <p>A custom filter.</p>
   */
  public function addCustomFilter(string $name, callable $filter)
  {
    $this->filters_custom[$name] = $filter;
  }

  /**
   * @param string              $name      <p>A name for the "data-validator"-attribute in the dom.</p>
   * @param string|AbstractRule $validator <p>A custom validation class.</p>
   */
  public function addCustomRule(string $name, $validator)
  {
    $this->validatorRulesManager->addCustomRule($name, $validator);
  }

  /**
   * @param mixed  $currentFieldData
   * @param string $fieldFilter
   *
   * @throws UnknownFilter
   *
   * @return mixed|string|null
   */
  private function applyFilter($currentFieldData, string $fieldFilter)
  {
    if ($currentFieldData === null) {
      return null;
    }

    if (isset($this->filters_custom[$fieldFilter])) {
      return \call_user_func($this->filters_custom[$fieldFilter], $currentFieldData);
    }

    switch ($fieldFilter) {
      case 'trim':
        return \trim($currentFieldData);
      case 'escape':
        return \htmlentities($currentFieldData, ENT_QUOTES | ENT_HTML5, 'UTF-8');
    }

    if (method_exists(UTF8::class, $fieldFilter)) {
      $currentFieldData = \call_user_func([UTF8::class, $fieldFilter], $currentFieldData);
    } else {
      throw new UnknownFilter(
          'No filter available for "' . $fieldFilter . '"'
      );
    }

    return $currentFieldData;
  }

  /**
   * @param string $type
   *
   * @return string|null
   */
  public function autoSelectRuleByInputType(string $type)
  {
    $matchingArray = [
        'email' => Email::class,
        'url'   => Url::class,
        'color' => HexRgbColor::class,

        //
        // TODO@me -> take a look here
        // -> https://github.com/xtreamwayz/html-form-validator/blob/master/src/FormElement/Number.php
        //
    ];

    return $matchingArray[$type] ?? null;
  }

  /**
   * Get the filters that will be applied.
   *
   * @return string[][]
   */
  public function getAllFilters(): array
  {
    return $this->filters;
  }

  /**
   * Get the rules that will be applied.
   *
   * @return string[][]
   */
  public function getAllRules(): array
  {
    return $this->rules;
  }

  /**
   * @param array  $formValues
   * @param string $field
   *
   * @return mixed|null
   */
  private function getCurrentFieldValue(array $formValues, string $field)
  {
    $fieldArrayPos = UTF8::strpos($field, '[');
    if ($fieldArrayPos !== false) {
      $fieldStart = UTF8::substr($field, 0, $fieldArrayPos);
      $fieldArray = UTF8::substr($field, $fieldArrayPos);
      $fieldHelperChar = '';
      $fieldArrayTmp = preg_replace_callback(
          '/\[([^\]]+)\]/',
          function ($match) use ($fieldHelperChar) {
            return $match[1] . $fieldHelperChar;
          },
          $fieldArray
      );
      $fieldArrayTmp = explode($fieldHelperChar, trim($fieldArrayTmp, $fieldHelperChar));

      $i = 0;
      $fieldHelper = [];
      foreach ($fieldArrayTmp as $fieldArrayTmpInner) {
        $fieldHelper[$i] = $fieldArrayTmpInner;

        $i++;
      }

      $currentFieldValue = null;

      switch ($i) {
        case 4:
          if (isset($formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]][$fieldHelper[2]][$fieldHelper[3]])) {
            $currentFieldValue = $formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]][$fieldHelper[2]][$fieldHelper[3]];
          }
          break;
        case 3:
          if (isset($formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]][$fieldHelper[2]])) {
            $currentFieldValue = $formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]][$fieldHelper[2]];
          }
          break;
        case 2:
          if (isset($formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]])) {
            $currentFieldValue = $formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]];
          }
          break;
        case 1:
          if (isset($formValues[$fieldStart][$fieldHelper[0]])) {
            $currentFieldValue = $formValues[$fieldStart][$fieldHelper[0]];
          }
          break;
      }
    } else {
      $currentFieldValue = $formValues[$field] ?? null;
    }

    return $currentFieldValue;
  }

  /**
   * @return string
   */
  public function getHtml(): string
  {
    return $this->formDocument->html();
  }

  /**
   * Get the required rules that will be applied.
   *
   * @return string[][]
   */
  public function getRequiredRules(): array
  {
    return $this->required_rules;
  }

  /**
   * @return callable|null
   */
  public function getTranslator()
  {
    return $this->translator;
  }

  /**
   * Find the first form on page or via css-selector, and parse <input>-elements.
   *
   * @return bool
   */
  public function parseHtmlDomForRules(): bool
  {
    // init
    $this->rules = [];
    $inputForm = [];

    if ($this->selector) {
      $forms = $this->formDocument->find($this->selector);
    } else {
      $forms = $this->formDocument->find('form');
    }

    if (\count($forms) === 0) {
      return false;
    }

    // get the first form
    $form = $forms[0];

    // get the from-id
    if ($form->id) {
      $formHelperId = $form->id;
    } else {
      $formHelperId = \uniqid('html-form-validator-tmp', true);
    }

    // get the <input>-elements from the form
    $inputFromFields = $form->getElementsByTagName('input');
    foreach ($inputFromFields as $inputFormField) {
      $this->parseInputForRules($inputFormField, $formHelperId);
      $this->parseInputForFilter($inputFormField, $formHelperId);
    }

    // get the <input>-elements with a matching form="id"
    if (\strpos($formHelperId, 'html-form-validator-tmp') !== 0) {
      $inputFromFieldsTmpAll = $this->formDocument->find('input');
      foreach ($inputFromFieldsTmpAll as $inputFromFieldTmp) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
        if ($inputFromFieldTmp->form == $formHelperId) {
          $this->parseInputForRules($inputFromFieldTmp, $formHelperId);
          $this->parseInputForFilter($inputFromFieldTmp, $formHelperId);
        }
      }
    }

    return (\count($inputForm) >= 0);
  }

  /**
   * Determine if element has filter attributes, and save the given filter.
   *
   * @param SimpleHtmlDom $inputField
   * @param string        $formHelperId
   */
  private function parseInputForFilter(SimpleHtmlDom $inputField, string $formHelperId)
  {
    if (!$inputField->hasAttribute('data-filter')) {
      return;
    }

    $inputName = $inputField->getAttribute('name');
    $inputFilter = $inputField->getAttribute('data-filter');

    if (!$inputFilter) {
      $inputFilter = 'htmlentities';
    }

    $this->filters[$formHelperId][$inputName] = $inputFilter;
  }


  /**
   * Determine if element has validator attributes, and save the given rule.
   *
   * @param SimpleHtmlDom $inputField
   * @param string        $formHelperId
   */
  private function parseInputForRules(SimpleHtmlDom $inputField, string $formHelperId)
  {
    if (!$inputField->hasAttribute('data-validator')) {
      return;
    }

    $inputName = $inputField->getAttribute('name');
    $inputRule = $inputField->getAttribute('data-validator');

    if (strpos($inputRule, 'auto') !== false) {
      $inputType = $inputField->getAttribute('type');

      $inputRule = str_replace(
          'auto',
          $this->autoSelectRuleByInputType($inputType),
          $inputRule
      );
    }

    if ($inputField->hasAttribute('required')) {
      $this->required_rules[$formHelperId][$inputName] = $inputRule;
    }

    $this->rules[$formHelperId][$inputName] = $inputRule;
  }

  /**
   * @param callable $translator
   *
   * @return Validator
   */
  public function setTranslator(callable $translator): Validator
  {
    $this->translator = $translator;

    return $this;
  }

  /**
   * Loop the form data through form rules.
   *
   * @param array $formValues
   * @param bool  $useNoValidationRuleException
   *
   * @throws UnknownValidationRule
   *
   * @return ValidatorResult
   */
  public function validate(array $formValues, $useNoValidationRuleException = false): ValidatorResult
  {
    if (
        $useNoValidationRuleException === true
        &&
        \count($this->rules) === 0
    ) {
      throw new NoValidationRule(
          'No rules defined in the html.'
      );
    }

    // init
    $validatorResult = new ValidatorResult($this->formDocument);

    foreach ($this->rules as $formHelperId => $formFields) {
      foreach ($formFields as $field => $fieldRuleOuter) {

        $currentFieldValue = $this->getCurrentFieldValue($formValues, $field);

        //
        // use the filter
        //

        if (isset($this->filters[$formHelperId][$field])) {
          $filtersOuter = $this->filters[$formHelperId][$field];
          if (\strpos($filtersOuter, '|') !== false) {
            $fieldFilters = \explode('|', $filtersOuter);
          } else {
            $fieldFilters = (array)$filtersOuter;
          }

          foreach ($fieldFilters as $fieldFilter) {

            if (!$fieldFilter) {
              continue;
            }

            $currentFieldValue = $this->applyFilter($currentFieldValue, $fieldFilter);
          }
        }

        //
        // save the new values into the result-object
        //

        $validatorResult->setValues($field, $currentFieldValue);

        //
        // skip validation, if there was no value and validation is not required
        //

        if (
            $currentFieldValue === null
            &&
            !isset($this->required_rules[$formHelperId][$field])
        ) {
          continue;
        }

        //
        // use the validation rules from the dom
        //

        if (\strpos($fieldRuleOuter, '|') !== false) {
          $fieldRules = \explode('|', $fieldRuleOuter);
        } else {
          $fieldRules = (array)$fieldRuleOuter;
        }

        foreach ($fieldRules as $fieldRule) {

          if (!$fieldRule) {
            continue;
          }

          $validationClassArray = $this->validatorRulesManager->getClassViaAlias($fieldRule);

          if ($validationClassArray['object']) {
            $validationClass = $validationClassArray['object'];
          } else if ($validationClassArray['class']) {
            $validationClass = $validationClassArray['class'];
          } else {
            $validationClass = null;
          }

          $validationClassArgs = $validationClassArray['classArgs'] ?? null;

          if ($validationClass instanceof AbstractRule) {

            $respectValidator = $validationClass;

          } else {

            try {
              $respectValidatorFactory = new Factory();
              $respectValidatorFactory->prependRulePrefix('voku\\HtmlFormValidator\\Rules');

              if ($validationClassArgs !== null) {
                $respectValidator = $respectValidatorFactory->rule($validationClass, $validationClassArgs);
              } else {
                $respectValidator = $respectValidatorFactory->rule($validationClass);
              }

            } catch (ComponentException $componentException) {
              throw new UnknownValidationRule(
                  'No rule defined for: ' . $field . ' (rule: ' . $fieldRule . ' | class: ' . $validationClass . ')',
                  500,
                  $componentException
              );
            }

          }

          $hasPassed = false;
          $translator = $this->getTranslator();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();

          try {
            $hasPassed = $respectValidator->assert($currentFieldValue);
          } catch (NestedValidationException $nestedValidationException) {

            if ($translator) {
              $nestedValidationException->setParam('translator', $translator);
            }

            $validatorResult->setError($field, $nestedValidationException->getFullMessage());
          } catch (ValidationException $validationException) {

            if ($translator) {
              $validationException->setParam('translator', $translator);
            }

            $validatorResult->setError($field, $validationException->getMainMessage());
          }

          if ($hasPassed === true) {
            continue;
          }

        }
      }
    }

    return $validatorResult;
  }

}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace voku\HtmlFormValidator;
6
7		use Respect\Validation\Exceptions\ComponentException;
8		use Respect\Validation\Exceptions\NestedValidationException;
9		use Respect\Validation\Exceptions\ValidationException;
10		use Respect\Validation\Factory;
11		use Respect\Validation\Rules\AbstractRule;
12		use Respect\Validation\Rules\Email;
13		use Respect\Validation\Rules\HexRgbColor;
14		use Respect\Validation\Rules\Url;
15		use voku\helper\HtmlDomParser;
16		use voku\helper\SimpleHtmlDom;
17		use voku\helper\UTF8;
18		use voku\HtmlFormValidator\Exceptions\NoValidationRule;
19		use voku\HtmlFormValidator\Exceptions\UnknownFilter;
20		use voku\HtmlFormValidator\Exceptions\UnknownValidationRule;
21
22		class Validator
23		{
24		/**
25		* @var HtmlDomParser
26		*/
27		private $formDocument;
28
29		/**
30		* @var string[][]
31		*/
32		private $rules = [];
33
34		/**
35		* @var string[][]
36		*/
37		private $required_rules = [];
38
39		/**
40		* @var string[][]
41		*/
42		private $filters = [];
43
44		/**
45		* @var callable[]
46		*/
47		private $filters_custom = [];
48
49		/**
50		* @var callable\|null
51		*/
52		private $translator;
53
54		/**
55		* @var ValidatorRulesManager
56		*/
57		private $validatorRulesManager;
58
59		/**
60		* @var string
61		*/
62		private $selector;
63
64		/**
65		* @param string $formHTML
66		* @param string $selector
67		*/
68	18	public function __construct($formHTML, $selector = '')
69		{
70	18	$this->validatorRulesManager = new ValidatorRulesManager();
71
72	18	$this->formDocument = HtmlDomParser::str_get_html($formHTML);
		0 ignored issues – show Unused Code introduced 2017-12-17 06:05 UTC by Report Bug Copy Issue Report The call to `HtmlDomParser::str_get_html()` has too many arguments starting with `$formHTML`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
73	18	$this->selector = $selector;
74
75	18	$this->parseHtmlDomForRules();
76	18	}
77
78		/**
79		* @param string $name <p>A name for the "data-filter"-attribute in the dom.</p>
80		* @param callable $filter <p>A custom filter.</p>
81		*/
82	1	public function addCustomFilter(string $name, callable $filter)
83		{
84	1	$this->filters_custom[$name] = $filter;
85	1	}
86
87		/**
88		* @param string $name <p>A name for the "data-validator"-attribute in the dom.</p>
89		* @param string\|AbstractRule $validator <p>A custom validation class.</p>
90		*/
91	2	public function addCustomRule(string $name, $validator)
92		{
93	2	$this->validatorRulesManager->addCustomRule($name, $validator);
94	2	}
95
96		/**
97		* @param mixed $currentFieldData
98		* @param string $fieldFilter
99		*
100		* @throws UnknownFilter
101		*
102		* @return mixed\|string\|null
103		*/
104	5	private function applyFilter($currentFieldData, string $fieldFilter)
105		{
106	5	if ($currentFieldData === null) {
107	1	return null;
108		}
109
110	5	if (isset($this->filters_custom[$fieldFilter])) {
111	1	return \call_user_func($this->filters_custom[$fieldFilter], $currentFieldData);
112		}
113
114		switch ($fieldFilter) {
115	4	case 'trim':
116	4	return \trim($currentFieldData);
117	4	case 'escape':
118	4	return \htmlentities($currentFieldData, ENT_QUOTES \| ENT_HTML5, 'UTF-8');
119		}
120
121	4	if (method_exists(UTF8::class, $fieldFilter)) {
122	4	$currentFieldData = \call_user_func([UTF8::class, $fieldFilter], $currentFieldData);
123		} else {
124		throw new UnknownFilter(
125		'No filter available for "' . $fieldFilter . '"'
126		);
127		}
128
129	4	return $currentFieldData;
130		}
131
132		/**
133		* @param string $type
134		*
135		* @return string\|null
136		*/
137	3	public function autoSelectRuleByInputType(string $type)
138		{
139		$matchingArray = [
140	3	'email' => Email::class,
141		'url' => Url::class,
142		'color' => HexRgbColor::class,
143
144		//
145		// TODO@me -> take a look here
146		// -> https://github.com/xtreamwayz/html-form-validator/blob/master/src/FormElement/Number.php
147		//
148		];
149
150	3	return $matchingArray[$type] ?? null;
151		}
152
153		/**
154		* Get the filters that will be applied.
155		*
156		* @return string[][]
157		*/
158	1	public function getAllFilters(): array
159		{
160	1	return $this->filters;
161		}
162
163		/**
164		* Get the rules that will be applied.
165		*
166		* @return string[][]
167		*/
168	11	public function getAllRules(): array
169		{
170	11	return $this->rules;
171		}
172
173		/**
174		* @param array $formValues
175		* @param string $field
176		*
177		* @return mixed\|null
178		*/
179	14	private function getCurrentFieldValue(array $formValues, string $field)
180		{
181	14	$fieldArrayPos = UTF8::strpos($field, '[');
182	14	if ($fieldArrayPos !== false) {
183	3	$fieldStart = UTF8::substr($field, 0, $fieldArrayPos);
184	3	$fieldArray = UTF8::substr($field, $fieldArrayPos);
185	3	$fieldHelperChar = '';
186	3	$fieldArrayTmp = preg_replace_callback(
187	3	'/\[([^\]]+)\]/',
188	3	function ($match) use ($fieldHelperChar) {
189	3	return $match[1] . $fieldHelperChar;
190	3	},
191	3	$fieldArray
192		);
193	3	$fieldArrayTmp = explode($fieldHelperChar, trim($fieldArrayTmp, $fieldHelperChar));
194
195	3	$i = 0;
196	3	$fieldHelper = [];
197	3	foreach ($fieldArrayTmp as $fieldArrayTmpInner) {
198	3	$fieldHelper[$i] = $fieldArrayTmpInner;
199
200	3	$i++;
201		}
202
203	3	$currentFieldValue = null;
204
205		switch ($i) {
206	3	case 4:
207		if (isset($formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]][$fieldHelper[2]][$fieldHelper[3]])) {
208		$currentFieldValue = $formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]][$fieldHelper[2]][$fieldHelper[3]];
209		}
210		break;
211	3	case 3:
212		if (isset($formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]][$fieldHelper[2]])) {
213		$currentFieldValue = $formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]][$fieldHelper[2]];
214		}
215		break;
216	3	case 2:
217	1	if (isset($formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]])) {
218	1	$currentFieldValue = $formValues[$fieldStart][$fieldHelper[0]][$fieldHelper[1]];
219		}
220	1	break;
221	2	case 1:
222	2	if (isset($formValues[$fieldStart][$fieldHelper[0]])) {
223	2	$currentFieldValue = $formValues[$fieldStart][$fieldHelper[0]];
224		}
225	3	break;
226		}
227		} else {
228	11	$currentFieldValue = $formValues[$field] ?? null;
229		}
230
231	14	return $currentFieldValue;
232		}
233
234		/**
235		* @return string
236		*/
237	3	public function getHtml(): string
238		{
239	3	return $this->formDocument->html();
240		}
241
242		/**
243		* Get the required rules that will be applied.
244		*
245		* @return string[][]
246		*/
247		public function getRequiredRules(): array
248		{
249		return $this->required_rules;
250		}
251
252		/**
253		* @return callable\|null
254		*/
255	13	public function getTranslator()
256		{
257	13	return $this->translator;
258		}
259
260		/**
261		* Find the first form on page or via css-selector, and parse <input>-elements.
262		*
263		* @return bool
264		*/
265	18	public function parseHtmlDomForRules(): bool
266		{
267		// init
268	18	$this->rules = [];
269	18	$inputForm = [];
270
271	18	if ($this->selector) {
272	2	$forms = $this->formDocument->find($this->selector);
273		} else {
274	16	$forms = $this->formDocument->find('form');
275		}
276
277	18	if (\count($forms) === 0) {
278	1	return false;
279		}
280
281		// get the first form
282	17	$form = $forms[0];
283
284		// get the from-id
285	17	if ($form->id) {
286	10	$formHelperId = $form->id;
287		} else {
288	7	$formHelperId = \uniqid('html-form-validator-tmp', true);
289		}
290
291		// get the <input>-elements from the form
292	17	$inputFromFields = $form->getElementsByTagName('input');
293	17	foreach ($inputFromFields as $inputFormField) {
294	17	$this->parseInputForRules($inputFormField, $formHelperId);
295	17	$this->parseInputForFilter($inputFormField, $formHelperId);
296		}
297
298		// get the <input>-elements with a matching form="id"
299	17	if (\strpos($formHelperId, 'html-form-validator-tmp') !== 0) {
300	10	$inputFromFieldsTmpAll = $this->formDocument->find('input');
301	10	foreach ($inputFromFieldsTmpAll as $inputFromFieldTmp) {
		0 ignored issues – show Bug introduced 2017-12-17 06:05 UTC by Report Bug Copy Issue Report The expression `$inputFromFieldsTmpAll` of type `array<integer,object<vok...leHtmlDomNodeInterface>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
302	10	if ($inputFromFieldTmp->form == $formHelperId) {
303	1	$this->parseInputForRules($inputFromFieldTmp, $formHelperId);
304	10	$this->parseInputForFilter($inputFromFieldTmp, $formHelperId);
305		}
306		}
307		}
308
309	17	return (\count($inputForm) >= 0);
310		}
311
312		/**
313		* Determine if element has filter attributes, and save the given filter.
314		*
315		* @param SimpleHtmlDom $inputField
316		* @param string $formHelperId
317		*/
318	17	private function parseInputForFilter(SimpleHtmlDom $inputField, string $formHelperId)
319		{
320	17	if (!$inputField->hasAttribute('data-filter')) {
321	17	return;
322		}
323
324	6	$inputName = $inputField->getAttribute('name');
325	6	$inputFilter = $inputField->getAttribute('data-filter');
326
327	6	if (!$inputFilter) {
328	1	$inputFilter = 'htmlentities';
329		}
330
331	6	$this->filters[$formHelperId][$inputName] = $inputFilter;
332	6	}
333
334
335		/**
336		* Determine if element has validator attributes, and save the given rule.
337		*
338		* @param SimpleHtmlDom $inputField
339		* @param string $formHelperId
340		*/
341	17	private function parseInputForRules(SimpleHtmlDom $inputField, string $formHelperId)
342		{
343	17	if (!$inputField->hasAttribute('data-validator')) {
344	14	return;
345		}
346
347	16	$inputName = $inputField->getAttribute('name');
348	16	$inputRule = $inputField->getAttribute('data-validator');
349
350	16	if (strpos($inputRule, 'auto') !== false) {
351	3	$inputType = $inputField->getAttribute('type');
352
353	3	$inputRule = str_replace(
354	3	'auto',
355	3	$this->autoSelectRuleByInputType($inputType),
356	3	$inputRule
357		);
358		}
359
360	16	if ($inputField->hasAttribute('required')) {
361	16	$this->required_rules[$formHelperId][$inputName] = $inputRule;
362		}
363
364	16	$this->rules[$formHelperId][$inputName] = $inputRule;
365	16	}
366
367		/**
368		* @param callable $translator
369		*
370		* @return Validator
371		*/
372	1	public function setTranslator(callable $translator): Validator
373		{
374	1	$this->translator = $translator;
375
376	1	return $this;
377		}
378
379		/**
380		* Loop the form data through form rules.
381		*
382		* @param array $formValues
383		* @param bool $useNoValidationRuleException
384		*
385		* @throws UnknownValidationRule
386		*
387		* @return ValidatorResult
388		*/
389	16	public function validate(array $formValues, $useNoValidationRuleException = false): ValidatorResult
390		{
391		if (
392	16	$useNoValidationRuleException === true
393		&&
394	16	\count($this->rules) === 0
395		) {
396	1	throw new NoValidationRule(
397	1	'No rules defined in the html.'
398		);
399		}
400
401		// init
402	15	$validatorResult = new ValidatorResult($this->formDocument);
403
404	15	foreach ($this->rules as $formHelperId => $formFields) {
405	14	foreach ($formFields as $field => $fieldRuleOuter) {
406
407	14	$currentFieldValue = $this->getCurrentFieldValue($formValues, $field);
408
409		//
410		// use the filter
411		//
412
413	14	if (isset($this->filters[$formHelperId][$field])) {
414	5	$filtersOuter = $this->filters[$formHelperId][$field];
415	5	if (\strpos($filtersOuter, '\|') !== false) {
416	4	$fieldFilters = \explode('\|', $filtersOuter);
417		} else {
418	4	$fieldFilters = (array)$filtersOuter;
419		}
420
421	5	foreach ($fieldFilters as $fieldFilter) {
422
423	5	if (!$fieldFilter) {
424		continue;
425		}
426
427	5	$currentFieldValue = $this->applyFilter($currentFieldValue, $fieldFilter);
428		}
429		}
430
431		//
432		// save the new values into the result-object
433		//
434
435	14	$validatorResult->setValues($field, $currentFieldValue);
436
437		//
438		// skip validation, if there was no value and validation is not required
439		//
440
441		if (
442	14	$currentFieldValue === null
443		&&
444	14	!isset($this->required_rules[$formHelperId][$field])
445		) {
446	3	continue;
447		}
448
449		//
450		// use the validation rules from the dom
451		//
452
453	14	if (\strpos($fieldRuleOuter, '\|') !== false) {
454	8	$fieldRules = \explode('\|', $fieldRuleOuter);
455		} else {
456	10	$fieldRules = (array)$fieldRuleOuter;
457		}
458
459	14	foreach ($fieldRules as $fieldRule) {
460
461	14	if (!$fieldRule) {
462		continue;
463		}
464
465	14	$validationClassArray = $this->validatorRulesManager->getClassViaAlias($fieldRule);
466
467	14	if ($validationClassArray['object']) {
468	1	$validationClass = $validationClassArray['object'];
469	14	} else if ($validationClassArray['class']) {
470	14	$validationClass = $validationClassArray['class'];
471		} else {
472		$validationClass = null;
473		}
474
475	14	$validationClassArgs = $validationClassArray['classArgs'] ?? null;
476
477	14	if ($validationClass instanceof AbstractRule) {
478
479	1	$respectValidator = $validationClass;
480
481		} else {
482
483		try {
484	14	$respectValidatorFactory = new Factory();
485	14	$respectValidatorFactory->prependRulePrefix('voku\\HtmlFormValidator\\Rules');
486
487	14	if ($validationClassArgs !== null) {
488	5	$respectValidator = $respectValidatorFactory->rule($validationClass, $validationClassArgs);
489		} else {
490	14	$respectValidator = $respectValidatorFactory->rule($validationClass);
491		}
492
493	1	} catch (ComponentException $componentException) {
494	1	throw new UnknownValidationRule(
495	1	'No rule defined for: ' . $field . ' (rule: ' . $fieldRule . ' \| class: ' . $validationClass . ')',
496	1	500,
497	1	$componentException
498		);
499		}
500
501		}
502
503	13	$hasPassed = false;
504	13	$translator = $this->getTranslator();
		0 ignored issues – show Bug introduced 2017-12-17 22:50 UTC by Report Bug Copy Issue Report Are you sure the assignment to `$translator` is correct as `$this->getTranslator()` (which targets `voku\HtmlFormValidator\Validator::getTranslator()`) seems to always return null. This check looks for function or method calls that always return null and whose return value is assigned to a variable. class A { function getObject() { return null; } } $a = new A(); $object = $a->getObject(); The method `getObject()` can return nothing but null, so it makes no sense to assign that value to a variable. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
505
506		try {
507	13	$hasPassed = $respectValidator->assert($currentFieldValue);
508	8	} catch (NestedValidationException $nestedValidationException) {
509
510	1	if ($translator) {
511		$nestedValidationException->setParam('translator', $translator);
512		}
513
514	1	$validatorResult->setError($field, $nestedValidationException->getFullMessage());
515	7	} catch (ValidationException $validationException) {
516
517	7	if ($translator) {
518	1	$validationException->setParam('translator', $translator);
519		}
520
521	7	$validatorResult->setError($field, $validationException->getMainMessage());
522		}
523
524	13	if ($hasPassed === true) {
525	13	continue;
526		}
527
528		}
529		}
530		}
531
532	14	return $validatorResult;
533		}
534
535		}
536

voku / HtmlFormValidator

Push — master ( b062f4...fb9144 )

Validator::getAllRules() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like