AbstractRule::__construct() - Code Metrics - Inspection of "Upgrade code to PHP 7.1+" - siriusphp/validation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 458234...a0327e )

by Adrian

created 2020-02-26 16:54 UTC

AbstractRule::__construct() A

↳ Parent: AbstractRule

Complexity

Conditions	4
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	7
cts	7
cp	1
rs	9.9666
c	0
b	0
f	0
cc	4
nc	3
nop	1
crap	4

<?php
declare(strict_types=1);
namespace Sirius\Validation\Rule;

use Sirius\Validation\DataWrapper\ArrayWrapper;
use Sirius\Validation\DataWrapper\WrapperInterface;
use Sirius\Validation\ErrorMessage;
use Sirius\Validation\Util\RuleHelper;

abstract class AbstractRule
{
    // default error message when there is no LABEL attached
    const MESSAGE = 'Value is not valid';

    // default error message when there is a LABEL attached
    const LABELED_MESSAGE = '{label} is not valid';

    /**
     * The validation context
     * This is the data set that the data being validated belongs to
     * @var WrapperInterface
     */
    protected $context;

    /**
     * Options for the validator.
     * Also passed to the error message for customization.
     *
     * @var array
     */
    protected $options = [];

    /**
     * Custom error message template for the validator instance
     * If you don't agree with the default messages that were provided
     *
     * @var string
     */
    protected $messageTemplate;

    /**
     * Result of the last validation
     *
     * @var boolean
     */
    protected $success = false;

    /**
     * Last value validated with the validator.
     * Stored in order to be passed to the errorMessage so that you get error
     * messages like '"abc" is not a valid email'
     *
     * @var mixed
     */
    protected $value;

    /**
     * The error message prototype that will be used to generate the error message
     *
     * @var ErrorMessage
     */
    protected $errorMessagePrototype;

    /**
     * Options map in case the options are passed as list instead of associative array
     *
     * @var array
     */
    protected $optionsIndexMap = [];

    public function __construct($options = [])
    {
        $options = RuleHelper::normalizeOptions($options, $this->optionsIndexMap);
        if (is_array($options) && ! empty($options)) {
            foreach ($options as $k => $v) {
                $this->setOption($k, $v);
            }
        }
    }

    /**
     * Generates a unique string to identify the validator.
     * It is used to compare 2 validators so you don't add the same rule twice in a validator object
     *
     * @return string
     */
    public function getUniqueId(): string
    {
        return get_called_class() . '|' . json_encode(ksort($this->options));
    }

    /**
     * Set an option for the validator.
     *
     * The options are also be passed to the error message.
     *
     * @param string $name
     * @param mixed $value
     *
     * @return AbstractRule
     */
    public function setOption($name, $value)
    {
        $this->options[$name] = $value;

        return $this;
    }

    /**
     * Get an option for the validator.
     *
     * @param string $name
     *
     * @return mixed
     */
    public function getOption($name)
    {
        if (isset($this->options[$name])) {
            return $this->options[$name];
        } else {
            return null;
        }
    }

    /**
     * The context of the validator can be used when the validator depends on other values
     * that are not known at the moment the validator is constructed
     * For example, when you need to validate an email field matches another email field,
     * to confirm the email address
     *
     * @param array|object $context
     *
     * @return AbstractRule
     *@throws \InvalidArgumentException
     */
    public function setContext($context = null)
    {
        if ($context === null) {
            return $this;
        }
        if (is_array($context)) {
            $context = new ArrayWrapper($context);
        }
        if (! is_object($context) || ! $context instanceof WrapperInterface) {
            throw new \InvalidArgumentException(
                'Validator context must be either an array or an instance
                of ' . WrapperInterface::class
            );
        }
        $this->context = $context;

        return $this;
    }

    /**
     * Custom message for this validator to used instead of the the default one
     *
     * @param string $messageTemplate
     *
     * @return AbstractRule
     */
    public function setMessageTemplate($messageTemplate)
    {
        $this->messageTemplate = $messageTemplate;

        return $this;
    }

    /**
     * Retrieves the error message template (either the global one or the custom message)
     *
     * @return string
     */
    public function getMessageTemplate(): string
    {
        if ($this->messageTemplate) {
            return $this->messageTemplate;
        }
        if (isset($this->options['label'])) {
            return constant(get_class($this) . '::LABELED_MESSAGE');
        }

        return constant(get_class($this) . '::MESSAGE');
    }

    /**
     * Validates a value
     *
     * @param mixed $value
     * @param null|mixed $valueIdentifier
     *
     * @return mixed
     */
    abstract public function validate($value, string $valueIdentifier = null);

    /**
     * Sets the error message prototype that will be used when returning the error message
     * when validation fails.
     * This option can be used when you need translation
     *
     * @param ErrorMessage $errorMessagePrototype
     *
     * @return AbstractRule
     * @throws \InvalidArgumentException
     */
    public function setErrorMessagePrototype(ErrorMessage $errorMessagePrototype)
    {
        $this->errorMessagePrototype = $errorMessagePrototype;

        return $this;
    }

    /**
     * Returns the error message prototype.
     * It constructs one if there isn't one.
     *
     * @return ErrorMessage
     */
    public function getErrorMessagePrototype()
    {
        if (! $this->errorMessagePrototype) {
            $this->errorMessagePrototype = new ErrorMessage();
        }

        return $this->errorMessagePrototype;
    }

    /**
     * Retrieve the error message if validation failed
     *
     * @return NULL|ErrorMessage
     */
    public function getMessage()
    {
        if ($this->success) {
            return null;
        }
        $message = $this->getPotentialMessage();
        $message->setVariables([
            'value' => $this->value
        ]);

        return $message;
    }

    /**
     * Retrieve the potential error message.
     * Example: when you do client-side validation you need to access the "potential error message" to be displayed
     *
     * @return ErrorMessage
     */
    public function getPotentialMessage()
    {
        $message = clone $this->getErrorMessagePrototype();
        $message->setTemplate($this->getMessageTemplate());
        $message->setVariables($this->options);

        return $message;
    }

    /**
     * Method for determining the path to a related item.
     * Eg: for `lines[5][price]` the related item `lines[*][quantity]`
     * has the value identifier as `lines[5][quantity]`
     *
     * @param $valueIdentifier
     * @param $relatedItem
     *
     * @return string|null
     */
    protected function getRelatedValueIdentifier($valueIdentifier, $relatedItem)
    {
        // in case we don't have a related path
        if (strpos($relatedItem, '*') === false) {
            return $relatedItem;
        }

        // lines[*][quantity] is converted to ['lines', '*', 'quantity']
        $relatedItemParts = explode('[', str_replace(']', '', $relatedItem));
        // lines[5][price] is ['lines', '5', 'price']
        $valueIdentifierParts = explode('[', str_replace(']', '', $valueIdentifier));

        if (count($relatedItemParts) !== count($valueIdentifierParts)) {
            return $relatedItem;
        }

        // the result should be ['lines', '5', 'quantity']
        $relatedValueIdentifierParts = [];
        foreach ($relatedItemParts as $index => $part) {
            if ($part === '*' && isset($valueIdentifierParts[$index])) {
                $relatedValueIdentifierParts[] = $valueIdentifierParts[$index];
            } else {
                $relatedValueIdentifierParts[] = $part;
            }
        }

        $relatedValueIdentifier = implode('][', $relatedValueIdentifierParts) . ']';
        $relatedValueIdentifier = str_replace(
            $relatedValueIdentifierParts[0] . ']',
            $relatedValueIdentifierParts[0],
            $relatedValueIdentifier
        );

        return $relatedValueIdentifier;
    }
}


1		<?php
2		declare(strict_types=1);
3		namespace Sirius\Validation\Rule;
4
5		use Sirius\Validation\DataWrapper\ArrayWrapper;
6		use Sirius\Validation\DataWrapper\WrapperInterface;
7		use Sirius\Validation\ErrorMessage;
8		use Sirius\Validation\Util\RuleHelper;
9
10		abstract class AbstractRule
11		{
12		// default error message when there is no LABEL attached
13		const MESSAGE = 'Value is not valid';
14
15		// default error message when there is a LABEL attached
16		const LABELED_MESSAGE = '{label} is not valid';
17
18		/**
19		* The validation context
20		* This is the data set that the data being validated belongs to
21		* @var WrapperInterface
22		*/
23		protected $context;
24
25		/**
26		* Options for the validator.
27		* Also passed to the error message for customization.
28		*
29		* @var array
30		*/
31		protected $options = [];
32
33		/**
34		* Custom error message template for the validator instance
35		* If you don't agree with the default messages that were provided
36		*
37		* @var string
38		*/
39		protected $messageTemplate;
40
41		/**
42		* Result of the last validation
43		*
44		* @var boolean
45		*/
46		protected $success = false;
47
48		/**
49		* Last value validated with the validator.
50		* Stored in order to be passed to the errorMessage so that you get error
51		* messages like '"abc" is not a valid email'
52		*
53		* @var mixed
54		*/
55		protected $value;
56
57		/**
58		* The error message prototype that will be used to generate the error message
59		*
60		* @var ErrorMessage
61		*/
62		protected $errorMessagePrototype;
63
64		/**
65		* Options map in case the options are passed as list instead of associative array
66		*
67		* @var array
68		*/
69	153	protected $optionsIndexMap = [];
70
71	153	public function __construct($options = [])
72	152	{
73	59	$options = RuleHelper::normalizeOptions($options, $this->optionsIndexMap);
74	59	if (is_array($options) && ! empty($options)) {
75	59	foreach ($options as $k => $v) {
76	59	$this->setOption($k, $v);
77	152	}
78		}
79		}
80
81		/**
82		* Generates a unique string to identify the validator.
83		* It is used to compare 2 validators so you don't add the same rule twice in a validator object
84		*
85		* @return string
86		*/
87		public function getUniqueId(): string
88		{
89		return get_called_class() . '\|' . json_encode(ksort($this->options));
90		}
91	153
92		/**
93	153	* Set an option for the validator.
94	107	*
95		* The options are also be passed to the error message.
96		*
97	60	* @param string $name
98	49	* @param mixed $value
99		*
100		* @return AbstractRule
101	12	*/
102	12	public function setOption($name, $value)
103	11	{
104	11	$this->options[$name] = $value;
105	7
106	11	return $this;
107	5	}
108	5
109	1	/**
110		* Get an option for the validator.
111	11	*
112		* @param string $name
113	12	*
114	1	* @return mixed
115		*/
116		public function getOption($name)
117	11	{
118		if (isset($this->options[$name])) {
119		return $this->options[$name];
120		} else {
121		return null;
122		}
123		}
124
125		/**
126		* The context of the validator can be used when the validator depends on other values
127	5	* that are not known at the moment the validator is constructed
128		* For example, when you need to validate an email field matches another email field,
129	5	* to confirm the email address
130		*
131	5	* @param array\|object $context
132		*
133		* @return AbstractRule
134		*@throws \InvalidArgumentException
135		*/
136		public function setContext($context = null)
137		{
138		if ($context === null) {
139		return $this;
140		}
141	6	if (is_array($context)) {
142		$context = new ArrayWrapper($context);
143	6	}
144	6	if (! is_object($context) \|\| ! $context instanceof WrapperInterface) {
145		throw new \InvalidArgumentException(
146	6	'Validator context must be either an array or an instance
147	2	of ' . WrapperInterface::class
148		);
149	6	}
150	2	$this->context = $context;
151
152		return $this;
153	6	}
154
155		/**
156		* Custom message for this validator to used instead of the the default one
157		*
158		* @param string $messageTemplate
159		*
160		* @return AbstractRule
161		*/
162		public function setMessageTemplate($messageTemplate)
163		{
164	1	$this->messageTemplate = $messageTemplate;
165
166	1	return $this;
167		}
168
169		/**
170		* Retrieves the error message template (either the global one or the custom message)
171		*
172		* @return string
173	1	*/
174	1	public function getMessageTemplate(): string
175	1	{
176	1	if ($this->messageTemplate) {
177		return $this->messageTemplate;
178		}
179		if (isset($this->options['label'])) {
180		return constant(get_class($this) . '::LABELED_MESSAGE');
181		}
182
183	1	return constant(get_class($this) . '::MESSAGE');
184	1	}
185
186	1	/**
187		* Validates a value
188		*
189		* @param mixed $value
190		* @param null\|mixed $valueIdentifier
191		*
192		* @return mixed
193		*/
194		abstract public function validate($value, string $valueIdentifier = null);
195
196	49	/**
197		* Sets the error message prototype that will be used when returning the error message
198	49	* when validation fails.
199		* This option can be used when you need translation
200		*
201		* @param ErrorMessage $errorMessagePrototype
202		*
203		* @return AbstractRule
204		* @throws \InvalidArgumentException
205		*/
206		public function setErrorMessagePrototype(ErrorMessage $errorMessagePrototype)
207		{
208	21	$this->errorMessagePrototype = $errorMessagePrototype;
209
210	21	return $this;
211		}
212
213		/**
214		* Returns the error message prototype.
215		* It constructs one if there isn't one.
216		*
217		* @return ErrorMessage
218		*/
219		public function getErrorMessagePrototype()
220		{
221		if (! $this->errorMessagePrototype) {
222		$this->errorMessagePrototype = new ErrorMessage();
223	100	}
224
225	100	return $this->errorMessagePrototype;
226		}
227	100
228		/**
229		* Retrieve the error message if validation failed
230		*
231		* @return NULL\|ErrorMessage
232		*/
233		public function getMessage()
234		{
235		if ($this->success) {
236		return null;
237	1	}
238		$message = $this->getPotentialMessage();
239	1	$message->setVariables([
240	1	'value' => $this->value
241		]);
242	1
243		return $message;
244		}
245
246		/**
247		* Retrieve the potential error message.
248		* Example: when you do client-side validation you need to access the "potential error message" to be displayed
249		*
250		* @return ErrorMessage
251		*/
252		public function getPotentialMessage()
253		{
254		$message = clone $this->getErrorMessagePrototype();
255		$message->setTemplate($this->getMessageTemplate());
256		$message->setVariables($this->options);
257	36
258		return $message;
259	36	}
260	5
261		/**
262	31	* Method for determining the path to a related item.
263	3	* Eg: for `lines[5][price]` the related item `lines[*][quantity]`
264	3	* has the value identifier as `lines[5][quantity]`
265	31	*
266	1	* @param $valueIdentifier
267		* @param $relatedItem
268		*
269	1	* @return string\|null
270		*/
271	30	protected function getRelatedValueIdentifier($valueIdentifier, $relatedItem)
272		{
273	30	// in case we don't have a related path
274		if (strpos($relatedItem, '*') === false) {
275		return $relatedItem;
276		}
277
278		// lines[][quantity] is converted to ['lines', '', 'quantity']
279		$relatedItemParts = explode('[', str_replace(']', '', $relatedItem));
280		// lines[5][price] is ['lines', '5', 'price']
281		$valueIdentifierParts = explode('[', str_replace(']', '', $valueIdentifier));
282
283	22	if (count($relatedItemParts) !== count($valueIdentifierParts)) {
284		return $relatedItem;
285	22	}
286
287	22	// the result should be ['lines', '5', 'quantity']
288		$relatedValueIdentifierParts = [];
289		foreach ($relatedItemParts as $index => $part) {
290		if ($part === '*' && isset($valueIdentifierParts[$index])) {
291		$relatedValueIdentifierParts[] = $valueIdentifierParts[$index];
292		} else {
293		$relatedValueIdentifierParts[] = $part;
294		}
295	27	}
296
297	27	$relatedValueIdentifier = implode('][', $relatedValueIdentifierParts) . ']';
298	21	$relatedValueIdentifier = str_replace(
299		$relatedValueIdentifierParts[0] . ']',
300	8	$relatedValueIdentifierParts[0],
301	1	$relatedValueIdentifier
302		);
303
304	7	return $relatedValueIdentifier;
305		}
306		}
307

siriusphp / validation

Push — master ( 458234...a0327e )

AbstractRule::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like