RuleSet::isEmptyInput() - Code Metrics - Inspection of "empty validation" - brenoroosevelt/php-validation - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( c8bc71...34003d )

by Breno

created 2022-02-08 19:34 UTC

RuleSet::isEmptyInput() A

↳ Parent: RuleSet

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	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php
declare(strict_types=1);

namespace BrenoRoosevelt\Validation;

use BrenoRoosevelt\Validation\Factories\ComparisonFactory;
use BrenoRoosevelt\Validation\Rules\AllowsEmpty;
use BrenoRoosevelt\Validation\Rules\AllowsNull;
use BrenoRoosevelt\Validation\Rules\IsEmpty;
use BrenoRoosevelt\Validation\Rules\NotRequired;
use Countable;
use IteratorAggregate;
use SplObjectStorage;

class RuleSet implements Rule, IteratorAggregate, Countable
{
    use GuardForValidation,
        ComparisonFactory,
        MaybeBelongsToField {
        setField as private;
    }

    private SplObjectStorage $rules;

    /**
     * @throws ValidationException if the field is provided and is blank
     */
    final public function __construct(?string $field = null, Rule|RuleSet ...$rules)
    {
        $this->rules = new SplObjectStorage;
        $this->field = $field;
        $this->attachRules(...$rules);
    }

    public static function new(): self
    {
        return new self;
    }

    public static function forField(string $field, Rule|RuleSet ...$rules): self
    {
        return new self($field, ...$rules);
    }

    public static function withRules(Rule|RuleSet ...$rules): self
    {
        return new self(null, ...$rules);
    }

    private function attachRules(Rule|RuleSet ...$rules): void
    {
        foreach ($rules as $validationOrSet) {
            if ($validationOrSet instanceof Rule) {
                $this->rules->attach($validationOrSet);
            }

            if ($validationOrSet instanceof RuleSet) {
                foreach ($validationOrSet as $validation) {
                    $this->rules->attach($validation);
                }
            }
        }
    }

    public function add(Rule|RuleSet ...$rules): self
    {
        $instance = clone $this;
        $instance->attachRules(...$rules);
        return $instance;
    }

    public function validate(mixed $input, array $context = []): ValidationResult|ValidationResultByField
    {
        $violations = $empty = $this->newEmptyValidationResult();
        if (!$this->shouldValidate($input)) {
            return $empty;
        }

        foreach ($this->rules as $rule) {
            $violations = $violations->error(...$rule->validate($input, $context)->getErrors());
        }

        return $violations;
    }

    private function shouldValidate(mixed $input): bool
    {
        if (null === $input && $this->allowsNull()) {
            return false;
        }

        if ($this->isEmptyInput($input) && $this->allowsEmpty()) {
            return false;
        }

        return true;
    }

    private function isEmptyInput($input): bool
    {
        return (new IsEmpty)->isValid($input);
    }

    public function isRequired(): bool
    {
        if ($this->isEmpty()) {
            return false;
        }

        foreach ($this->rules as $rule) {
            if ($rule instanceof NotRequired) {
                return false;
            }
        }

        return true;
    }

    public function allowsEmpty(): bool
    {
        if ($this->isEmpty()) {
            return true;
        }

        foreach ($this->rules as $rule) {
            if ($rule instanceof AllowsEmpty) {
                return true;
            }
        }

        return false;
    }

    public function allowsNull(): bool
    {
        if ($this->isEmpty()) {
            return true;
        }

        foreach ($this->rules as $rule) {
            if ($rule instanceof AllowsNull) {
                return true;
            }
        }

        return false;
    }

    public function setNotRequired(): self
    {
        return $this->add(NotRequired::instance());
    }

    /**
     * Allows empty arrays or strings (only)
     */
    public function setAllowsEmpty(): self
    {
        return $this->add(AllowsEmpty::instance());
    }

    /**
     * Allows null values
     */
    public function setAllowsNull(): self
    {
        return $this->add(AllowsNull::instance());
    }

    public function isEmpty(): bool
    {
        return $this->rules->count() === 0;
    }

    /** @return Rule[] */
    public function toArray(): array
    {
        return iterator_to_array($this->rules);
    }

    public function getIterator(): SplObjectStorage
    {
        return clone $this->rules;
    }

    public function count(): int
    {
        return $this->rules->count();
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace BrenoRoosevelt\Validation;
5
6			use BrenoRoosevelt\Validation\Factories\ComparisonFactory;
7			use BrenoRoosevelt\Validation\Rules\AllowsEmpty;
8			use BrenoRoosevelt\Validation\Rules\AllowsNull;
9			use BrenoRoosevelt\Validation\Rules\IsEmpty;
10			use BrenoRoosevelt\Validation\Rules\NotRequired;
11			use Countable;
12			use IteratorAggregate;
13			use SplObjectStorage;
14
15			class RuleSet implements Rule, IteratorAggregate, Countable
16			{
17			use GuardForValidation,
18			ComparisonFactory,
19			MaybeBelongsToField {
20			setField as private;
21			}
22
23			private SplObjectStorage $rules;
24
25			/**
26			* @throws ValidationException if the field is provided and is blank
27			*/
28			final public function __construct(?string $field = null, Rule\|RuleSet ...$rules)
29			{
30			$this->rules = new SplObjectStorage;
31			$this->field = $field;
32			$this->attachRules(...$rules);
33			}
34
35			public static function new(): self
36			{
37			return new self;
38			}
39
40			public static function forField(string $field, Rule\|RuleSet ...$rules): self
41			{
42			return new self($field, ...$rules);
43			}
44
45			public static function withRules(Rule\|RuleSet ...$rules): self
46			{
47			return new self(null, ...$rules);
48			}
49
50			private function attachRules(Rule\|RuleSet ...$rules): void
51			{
52			foreach ($rules as $validationOrSet) {
53			if ($validationOrSet instanceof Rule) {
54			$this->rules->attach($validationOrSet);
55			}
56
57			if ($validationOrSet instanceof RuleSet) {
58			foreach ($validationOrSet as $validation) {
59			$this->rules->attach($validation);
60			}
61			}
62			}
63			}
64
65			public function add(Rule\|RuleSet ...$rules): self
66			{
67			$instance = clone $this;
68			$instance->attachRules(...$rules);
69			return $instance;
70			}
71
72			public function validate(mixed $input, array $context = []): ValidationResult\|ValidationResultByField
73			{
74			$violations = $empty = $this->newEmptyValidationResult();
75			if (!$this->shouldValidate($input)) {
76			return $empty;
77			}
78
79			foreach ($this->rules as $rule) {
80			$violations = $violations->error(...$rule->validate($input, $context)->getErrors());
81			}
82
83			return $violations;
84			}
85
86			private function shouldValidate(mixed $input): bool
87			{
88			if (null === $input && $this->allowsNull()) {
89			return false;
90			}
91
92			if ($this->isEmptyInput($input) && $this->allowsEmpty()) {
93			return false;
94			}
95
96			return true;
97			}
98
99			private function isEmptyInput($input): bool
100			{
101			return (new IsEmpty)->isValid($input);
102			}
103
104			public function isRequired(): bool
105			{
106			if ($this->isEmpty()) {
107			return false;
108			}
109
110			foreach ($this->rules as $rule) {
111			if ($rule instanceof NotRequired) {
112			return false;
113			}
114			}
115
116			return true;
117			}
118
119			public function allowsEmpty(): bool
120			{
121			if ($this->isEmpty()) {
122			return true;
123			}
124
125			foreach ($this->rules as $rule) {
126			if ($rule instanceof AllowsEmpty) {
127			return true;
128			}
129			}
130
131			return false;
132			}
133
134			public function allowsNull(): bool
135			{
136			if ($this->isEmpty()) {
137			return true;
138			}
139
140			foreach ($this->rules as $rule) {
141			if ($rule instanceof AllowsNull) {
142			return true;
143			}
144			}
145
146			return false;
147			}
148
149			public function setNotRequired(): self
150			{
151			return $this->add(NotRequired::instance());
152			}
153
154			/**
155			* Allows empty arrays or strings (only)
156			*/
157			public function setAllowsEmpty(): self
158			{
159			return $this->add(AllowsEmpty::instance());
160			}
161
162			/**
163			* Allows null values
164			*/
165			public function setAllowsNull(): self
166			{
167			return $this->add(AllowsNull::instance());
168			}
169
170			public function isEmpty(): bool
171			{
172			return $this->rules->count() === 0;
173			}
174
175			/** @return Rule[] */
176			public function toArray(): array
177			{
178			return iterator_to_array($this->rules);
179			}
180
181			public function getIterator(): SplObjectStorage
182			{
183			return clone $this->rules;
184			}
185
186			public function count(): int
187			{
188			return $this->rules->count();
189			}
190			}
191

brenoroosevelt / php-validation

Push — main ( c8bc71...34003d )

RuleSet::isEmptyInput() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like