Validator::canBeCached() - Code Metrics - Inspection of "Merge pull request #9406 from chrispenny/feature/s..." - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — 4 ( 34eb17...84b405 )

by Robbie

created 2020-07-16 22:58 UTC

Validator::canBeCached() A

↳ Parent: Validator

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace SilverStripe\Forms;

use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Extensible;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\ORM\ValidationResult;

/**
 * This validation class handles all form and custom form validation through the use of Required
 * fields. It relies on javascript for client-side validation, and marking fields after server-side
 * validation. It acts as a visitor to individual form fields.
 */
abstract class Validator
{
    use Injectable;
    use Configurable;
    use Extensible;

    public function __construct()
    {
        $this->resetResult();
    }

    /**
     * @var Form $form
     */
    protected $form;

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

    /**
     * @var bool
     */
    private $enabled = true;

    /**
     * @param Form $form
     * @return $this
     */
    public function setForm($form)
    {
        $this->form = $form;
        return $this;
    }

    /**
     * Returns any errors there may be.
     *
     * @return ValidationResult
     */
    public function validate()
    {
        $this->resetResult();
        if ($this->getEnabled()) {
            $this->php($this->form->getData());
        }
        return $this->result;
    }

    /**
     * Callback to register an error on a field (Called from implementations of
     * {@link FormField::validate}). The optional error message type parameter is loaded into the
     * HTML class attribute.
     *
     * See {@link getErrors()} for details.
     *
     * @param string $fieldName Field name for this error
     * @param string $message The message string
     * @param string $messageType The type of message: e.g. "bad", "warning", "good", or "required". Passed as a CSS
     *                            class to the form, so other values can be used if desired.
     * @param string|bool $cast Cast type; One of the CAST_ constant definitions.
     * Bool values will be treated as plain text flag.
     * @return $this
     */
    public function validationError(
        $fieldName,
        $message,
        $messageType = ValidationResult::TYPE_ERROR,
        $cast = ValidationResult::CAST_TEXT
    ) {
        $this->result->addFieldError($fieldName, $message, $messageType, null, $cast);
        return $this;
    }

    /**
     * Returns all errors found by a previous call to {@link validate()}. The returned array has a
     * structure resembling:
     *
     * <code>
     *     array(
     *         'fieldName' => '[form field name]',
     *         'message' => '[validation error message]',
     *         'messageType' => '[bad|message|validation|required]',
     *         'messageCast' => '[text|html]'
     *     )
     * </code>
     *
     * @return null|array
     */
    public function getErrors()
    {
        if ($this->result) {
            return $this->result->getMessages();
        }
        return null;
    }

    /**
     * Get last validation result
     *
     * @return ValidationResult
     */
    public function getResult()
    {
        return $this->result;
    }

    /**
     * Returns whether the field in question is required. This will usually display '*' next to the
     * field. The base implementation always returns false.
     *
     * @param string $fieldName
     *
     * @return bool
     */
    public function fieldIsRequired($fieldName)
    {
        return false;
    }

    /**
     * @param array $data
     *
     * @return mixed
     */
    abstract public function php($data);

    /**
     * @param bool $enabled
     * @return $this
     */
    public function setEnabled($enabled)
    {
        $this->enabled = (bool)$enabled;
        return $this;
    }

    /**
     * @return bool
     */
    public function getEnabled()
    {
        return $this->enabled;
    }

    /**
     * @return $this
     */
    public function removeValidation()
    {
        $this->setEnabled(false);
        $this->resetResult();
        return $this;
    }

    /**
     * When Validators are set on the form, it can affect whether or not the form cannot be cached.
     *
     * @see RequiredFields for an example of when you might be able to cache your form.
     *
     * @return bool
     */
    public function canBeCached(): bool
    {
        return false;
    }

    /**
     * Clear current result
     *
     * @return $this
     */
    protected function resetResult()
    {
        $this->result = ValidationResult::create();
        return $this;
    }
}


1			<?php
2
3			namespace SilverStripe\Forms;
4
5			use SilverStripe\Core\Config\Configurable;
6			use SilverStripe\Core\Extensible;
7			use SilverStripe\Core\Injector\Injectable;
8			use SilverStripe\ORM\ValidationResult;
9
10			/**
11			* This validation class handles all form and custom form validation through the use of Required
12			* fields. It relies on javascript for client-side validation, and marking fields after server-side
13			* validation. It acts as a visitor to individual form fields.
14			*/
15			abstract class Validator
16			{
17			use Injectable;
18			use Configurable;
19			use Extensible;
20
21			public function __construct()
22			{
23			$this->resetResult();
24			}
25
26			/**
27			* @var Form $form
28			*/
29			protected $form;
30
31			/**
32			* @var ValidationResult $result
33			*/
34			protected $result;
35
36			/**
37			* @var bool
38			*/
39			private $enabled = true;
40
41			/**
42			* @param Form $form
43			* @return $this
44			*/
45			public function setForm($form)
46			{
47			$this->form = $form;
48			return $this;
49			}
50
51			/**
52			* Returns any errors there may be.
53			*
54			* @return ValidationResult
55			*/
56			public function validate()
57			{
58			$this->resetResult();
59			if ($this->getEnabled()) {
60			$this->php($this->form->getData());
61			}
62			return $this->result;
63			}
64
65			/**
66			* Callback to register an error on a field (Called from implementations of
67			* {@link FormField::validate}). The optional error message type parameter is loaded into the
68			* HTML class attribute.
69			*
70			* See {@link getErrors()} for details.
71			*
72			* @param string $fieldName Field name for this error
73			* @param string $message The message string
74			* @param string $messageType The type of message: e.g. "bad", "warning", "good", or "required". Passed as a CSS
75			* class to the form, so other values can be used if desired.
76			* @param string\|bool $cast Cast type; One of the CAST_ constant definitions.
77			* Bool values will be treated as plain text flag.
78			* @return $this
79			*/
80			public function validationError(
81			$fieldName,
82			$message,
83			$messageType = ValidationResult::TYPE_ERROR,
84			$cast = ValidationResult::CAST_TEXT
85			) {
86			$this->result->addFieldError($fieldName, $message, $messageType, null, $cast);
87			return $this;
88			}
89
90			/**
91			* Returns all errors found by a previous call to {@link validate()}. The returned array has a
92			* structure resembling:
93			*
94			* <code>
95			* array(
96			* 'fieldName' => '[form field name]',
97			* 'message' => '[validation error message]',
98			* 'messageType' => '[bad\|message\|validation\|required]',
99			* 'messageCast' => '[text\|html]'
100			* )
101			* </code>
102			*
103			* @return null\|array
104			*/
105			public function getErrors()
106			{
107			if ($this->result) {
108			return $this->result->getMessages();
109			}
110			return null;
111			}
112
113			/**
114			* Get last validation result
115			*
116			* @return ValidationResult
117			*/
118			public function getResult()
119			{
120			return $this->result;
121			}
122
123			/**
124			* Returns whether the field in question is required. This will usually display '*' next to the
125			* field. The base implementation always returns false.
126			*
127			* @param string $fieldName
128			*
129			* @return bool
130			*/
131			public function fieldIsRequired($fieldName)
132			{
133			return false;
134			}
135
136			/**
137			* @param array $data
138			*
139			* @return mixed
140			*/
141			abstract public function php($data);
142
143			/**
144			* @param bool $enabled
145			* @return $this
146			*/
147			public function setEnabled($enabled)
148			{
149			$this->enabled = (bool)$enabled;
150			return $this;
151			}
152
153			/**
154			* @return bool
155			*/
156			public function getEnabled()
157			{
158			return $this->enabled;
159			}
160
161			/**
162			* @return $this
163			*/
164			public function removeValidation()
165			{
166			$this->setEnabled(false);
167			$this->resetResult();
168			return $this;
169			}
170
171			/**
172			* When Validators are set on the form, it can affect whether or not the form cannot be cached.
173			*
174			* @see RequiredFields for an example of when you might be able to cache your form.
175			*
176			* @return bool
177			*/
178			public function canBeCached(): bool
179			{
180			return false;
181			}
182
183			/**
184			* Clear current result
185			*
186			* @return $this
187			*/
188			protected function resetResult()
189			{
190			$this->result = ValidationResult::create();
191			return $this;
192			}
193			}
194

silverstripe / silverstripe-framework

Push — 4 ( 34eb17...84b405 )

Validator::canBeCached() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like