AbstractFormValidator::validateWithoutSavingResults() - Code Metrics - Inspection of "Merge branch 'development' into unit-tests-conditi..." - romm/formz - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — unit-tests-conditions ( a23049...dc9eee )

by Romain

created 2017-03-02 18:23 UTC

AbstractFormValidator::validateWithoutSavingResults() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	16
rs	9.4285
cc	2
eloc	9
nc	2
nop	1

<?php
/*
 * 2017 Romain CANON <[email protected]>
 *
 * This file is part of the TYPO3 Formz project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace Romm\Formz\Validation\Validator\Form;

use Romm\Formz\Configuration\Form\Field\Field;
use Romm\Formz\Core\Core;
use Romm\Formz\Error\FormResult;
use Romm\Formz\Exceptions\InvalidArgumentTypeException;
use Romm\Formz\Form\FormInterface;
use Romm\Formz\Service\FormService;
use TYPO3\CMS\Extbase\Validation\Validator\AbstractValidator as ExtbaseAbstractValidator;

/**
 * This is the abstract form validator, which must be inherited by any custom
 * form validator in order to work properly.
 *
 * Please note that a default form validator already exists if you need a form
 * which does not require any particular action: `DefaultFormValidator`.
 *
 * A form validator should be called to validate any form instance (which is a
 * child of `AbstractForm`). Usually, this is used in controller actions to
 * validate a form sent by the user. Example:
 *
 * /**
 *  * Action called when the Example form is submitted.
 *  *
 *  * @param $exForm
 *  * @validate $exForm Romm.Formz:Form\DefaultFormValidator
 *  * /
 *  public function submitFormAction(ExampleForm $exForm) { ... }
 *
 *******************************************************************************
 *
 * You may use you own custom form validator in order to be able to use the
 * following features:
 *
 * - Pre-validation custom process:
 *   By extending the method `beforeValidationProcess()`, you are able to handle
 *   anything you want just before the form validation begins to loop on every
 *   field. This can be used for instance to (de)activate the validation of
 *   certain fields under very specific circumstances.
 *
 * - In real time custom process:
 *   After each field went trough a validation process, a magic method is called
 *   to allow very low level custom process. The magic method name looks like:
 *   "{lowerCamelCaseFieldName}Validated". For instance, when the "email" field
 *   just went trough the validation process, the method `emailValidated()` is
 *   called.
 *
 * - Post-validation custom process:
 *   After the validation was done on every field of the form, this method is
 *   called to allow you high level process. For instance, let's assume your
 *   form is used to calculate a price estimation depending on information
 *   submitted in the form; when the form went trough the validation process and
 *   got no error, you can run the price estimation, and if any error occurs you
 *   are still able to add an error to `$this->result` (in a controller you do
 *   not have access to it anymore).
 */
abstract class AbstractFormValidator extends ExtbaseAbstractValidator implements FormValidatorInterface
{
    /**
     * @inheritdoc
     */
    protected $supportedOptions = [
        'name' => ['', 'Name of the form.', 'string', true]
    ];

    /**
     * @var FormResult
     */
    protected $result;

    /**
     * @var FormValidatorExecutor
     */
    protected $formValidatorExecutor;

    /**
     * Checks the given form instance, and launches the validation if it is a
     * correct form.
     *
     * @param FormInterface $form The form instance to be validated.
     * @return FormResult
     */
    final public function validate($form)
    {
        $this->validateWithoutSavingResults($form);
        $this->formValidatorExecutor->saveValidationResult();

        return $this->result;
    }

    /**
     * @param FormInterface $form
     * @return FormResult
     * @throws InvalidArgumentTypeException
     */
    public function validateWithoutSavingResults($form)
    {
        if (false === $form instanceof FormInterface) {
            throw new InvalidArgumentTypeException(
                'Trying to validate a form that does not implement the interface "' . FormInterface::class . '". Given class: "' . get_class($form) . '"',
                1487865158
            );
        }

        $this->result = new FormResult;
        $this->formValidatorExecutor = $this->getFormValidatorExecutor($form);

        $this->isValid($form);

        return $this->result;
    }

    /**
     * Runs the whole validation workflow.
     *
     * @param FormInterface $form
     */
    final public function isValid($form)
    {
        $this->formValidatorExecutor->applyBehaviours();
        $this->formValidatorExecutor->checkFieldsActivation();

        $this->beforeValidationProcess();

        $this->formValidatorExecutor->validateFields(function (Field $field) {
            $this->callAfterFieldValidationMethod($field);
        });

        $this->afterValidationProcess();

        if ($this->result->hasErrors()) {
            // Storing the form for possible third party further usage.
            FormService::addFormWithErrors($form);
        }
    }

    /**
     * Use this function to (de)activate the validation for some given fields.
     */
    protected function beforeValidationProcess()
    {
    }

    /**
     * Use this function to run your own processes after the validation ran.
     */
    protected function afterValidationProcess()
    {
    }

    /**
     * After each field has been validated, a matching method can be called if
     * it exists in the child class.
     *
     * The syntax is `{lowerCamelCaseFieldName}Validated()`.
     *
     * Example: for field `firstName` - `firstNameValidated()`.
     *
     * @param Field $field
     */
    private function callAfterFieldValidationMethod(Field $field)
    {
        $functionName = lcfirst($field->getFieldName() . 'Validated');

        if (method_exists($this, $functionName)) {
            call_user_func([$this, $functionName]);
        }
    }

    /**
     * @param FormInterface $form
     * @return FormValidatorExecutor
     */
    protected function getFormValidatorExecutor(FormInterface $form)
    {
        /** @var FormValidatorExecutor $formValidatorExecutor */
        $formValidatorExecutor = Core::instantiate(FormValidatorExecutor::class, $form, $this->options['name'], $this->result);

        return $formValidatorExecutor;
    }
}


1			<?php
2			/*
3			* 2017 Romain CANON <[email protected]>
4			*
5			* This file is part of the TYPO3 Formz project.
6			* It is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU General Public License, either
8			* version 3 of the License, or any later version.
9			*
10			* For the full copyright and license information, see:
11			* http://www.gnu.org/licenses/gpl-3.0.html
12			*/
13
14			namespace Romm\Formz\Validation\Validator\Form;
15
16			use Romm\Formz\Configuration\Form\Field\Field;
17			use Romm\Formz\Core\Core;
18			use Romm\Formz\Error\FormResult;
19			use Romm\Formz\Exceptions\InvalidArgumentTypeException;
20			use Romm\Formz\Form\FormInterface;
21			use Romm\Formz\Service\FormService;
22			use TYPO3\CMS\Extbase\Validation\Validator\AbstractValidator as ExtbaseAbstractValidator;
23
24			/**
25			* This is the abstract form validator, which must be inherited by any custom
26			* form validator in order to work properly.
27			*
28			* Please note that a default form validator already exists if you need a form
29			* which does not require any particular action: `DefaultFormValidator`.
30			*
31			* A form validator should be called to validate any form instance (which is a
32			* child of `AbstractForm`). Usually, this is used in controller actions to
33			* validate a form sent by the user. Example:
34			*
35			* /**
36			* * Action called when the Example form is submitted.
37			* *
38			* * @param $exForm
39			* * @validate $exForm Romm.Formz:Form\DefaultFormValidator
40			* * /
41			* public function submitFormAction(ExampleForm $exForm) { ... }
42			*
43			*******************************************************************************
44			*
45			* You may use you own custom form validator in order to be able to use the
46			* following features:
47			*
48			* - Pre-validation custom process:
49			* By extending the method `beforeValidationProcess()`, you are able to handle
50			* anything you want just before the form validation begins to loop on every
51			* field. This can be used for instance to (de)activate the validation of
52			* certain fields under very specific circumstances.
53			*
54			* - In real time custom process:
55			* After each field went trough a validation process, a magic method is called
56			* to allow very low level custom process. The magic method name looks like:
57			* "{lowerCamelCaseFieldName}Validated". For instance, when the "email" field
58			* just went trough the validation process, the method `emailValidated()` is
59			* called.
60			*
61			* - Post-validation custom process:
62			* After the validation was done on every field of the form, this method is
63			* called to allow you high level process. For instance, let's assume your
64			* form is used to calculate a price estimation depending on information
65			* submitted in the form; when the form went trough the validation process and
66			* got no error, you can run the price estimation, and if any error occurs you
67			* are still able to add an error to `$this->result` (in a controller you do
68			* not have access to it anymore).
69			*/
70			abstract class AbstractFormValidator extends ExtbaseAbstractValidator implements FormValidatorInterface
71			{
72			/**
73			* @inheritdoc
74			*/
75			protected $supportedOptions = [
76			'name' => ['', 'Name of the form.', 'string', true]
77			];
78
79			/**
80			* @var FormResult
81			*/
82			protected $result;
83
84			/**
85			* @var FormValidatorExecutor
86			*/
87			protected $formValidatorExecutor;
88
89			/**
90			* Checks the given form instance, and launches the validation if it is a
91			* correct form.
92			*
93			* @param FormInterface $form The form instance to be validated.
94			* @return FormResult
95			*/
96			final public function validate($form)
97			{
98			$this->validateWithoutSavingResults($form);
99			$this->formValidatorExecutor->saveValidationResult();
100
101			return $this->result;
102			}
103
104			/**
105			* @param FormInterface $form
106			* @return FormResult
107			* @throws InvalidArgumentTypeException
108			*/
109			public function validateWithoutSavingResults($form)
110			{
111			if (false === $form instanceof FormInterface) {
112			throw new InvalidArgumentTypeException(
113			'Trying to validate a form that does not implement the interface "' . FormInterface::class . '". Given class: "' . get_class($form) . '"',
114			1487865158
115			);
116			}
117
118			$this->result = new FormResult;
119			$this->formValidatorExecutor = $this->getFormValidatorExecutor($form);
120
121			$this->isValid($form);
122
123			return $this->result;
124			}
125
126			/**
127			* Runs the whole validation workflow.
128			*
129			* @param FormInterface $form
130			*/
131			final public function isValid($form)
132			{
133			$this->formValidatorExecutor->applyBehaviours();
134			$this->formValidatorExecutor->checkFieldsActivation();
135
136			$this->beforeValidationProcess();
137
138			$this->formValidatorExecutor->validateFields(function (Field $field) {
139			$this->callAfterFieldValidationMethod($field);
140			});
141
142			$this->afterValidationProcess();
143
144			if ($this->result->hasErrors()) {
145			// Storing the form for possible third party further usage.
146			FormService::addFormWithErrors($form);
147			}
148			}
149
150			/**
151			* Use this function to (de)activate the validation for some given fields.
152			*/
153			protected function beforeValidationProcess()
154			{
155			}
156
157			/**
158			* Use this function to run your own processes after the validation ran.
159			*/
160			protected function afterValidationProcess()
161			{
162			}
163
164			/**
165			* After each field has been validated, a matching method can be called if
166			* it exists in the child class.
167			*
168			* The syntax is `{lowerCamelCaseFieldName}Validated()`.
169			*
170			* Example: for field `firstName` - `firstNameValidated()`.
171			*
172			* @param Field $field
173			*/
174			private function callAfterFieldValidationMethod(Field $field)
175			{
176			$functionName = lcfirst($field->getFieldName() . 'Validated');
177
178			if (method_exists($this, $functionName)) {
179			call_user_func([$this, $functionName]);
180			}
181			}
182
183			/**
184			* @param FormInterface $form
185			* @return FormValidatorExecutor
186			*/
187			protected function getFormValidatorExecutor(FormInterface $form)
188			{
189			/** @var FormValidatorExecutor $formValidatorExecutor */
190			$formValidatorExecutor = Core::instantiate(FormValidatorExecutor::class, $form, $this->options['name'], $this->result);
191
192			return $formValidatorExecutor;
193			}
194			}
195

romm / formz

Push — unit-tests-conditions ( a23049...dc9eee )

AbstractFormValidator::validateWithoutSavingResults() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like