Passed
Push — master ( f7c3a7...3fd83b )
by Smoren
02:26
created

StringRule::numeric()   A

Complexity

Conditions 1
Paths 1

Size

Total Lines 6
Code Lines 4

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 5
CRAP Score 1

Importance

Changes 1
Bugs 0 Features 1
Metric Value
cc 1
eloc 4
c 1
b 0
f 1
nc 1
nop 0
dl 0
loc 6
ccs 5
cts 5
cp 1
crap 1
rs 10
1
<?php
2
3
namespace Smoren\Validator\Rules;
4
5
use Smoren\Validator\Factories\CheckBuilder;
6
use Smoren\Validator\Interfaces\IntegerRuleInterface;
7
use Smoren\Validator\Interfaces\StringRuleInterface;
8
use Smoren\Validator\Structs\CheckErrorName;
9
use Smoren\Validator\Structs\CheckName;
10
11
class StringRule extends Rule implements StringRuleInterface
12
{
13
    /**
14
     * @param string $name
15
     */
16 20
    public function __construct(string $name)
17
    {
18 20
        parent::__construct($name);
19 20
        $this->check(
20 20
            CheckBuilder::create(CheckName::STRING, CheckErrorName::NOT_STRING)
21 20
                ->withPredicate(fn ($value) => \is_string($value))
22 20
                ->build(),
23 20
            true
24 20
        );
25
    }
26
27 2
    public function numeric(): StringRuleInterface
28
    {
29 2
        return $this->check(
30 2
            CheckBuilder::create(CheckName::NUMERIC, CheckErrorName::NOT_NUMERIC)
31 2
                ->withPredicate(fn ($value) => \is_numeric($value))
32 2
                ->build()
33 2
        );
34
    }
35
36 2
    public function empty(): StringRuleInterface
37
    {
38 2
        return $this->check(
39 2
            CheckBuilder::create(CheckName::EMPTY, CheckErrorName::NOT_EMPTY)
40 2
                ->withPredicate(fn ($value) => $value === '')
41 2
                ->build()
42 2
        );
43
    }
44
45 2
    public function notEmpty(): StringRuleInterface
46
    {
47 2
        return $this->check(
48 2
            CheckBuilder::create(CheckName::NOT_EMPTY, CheckErrorName::EMPTY)
49 2
                ->withPredicate(fn ($value) => $value !== '')
50 2
                ->build()
51 2
        );
52
    }
53
54 2
    public function match(string $regex): StringRuleInterface
55
    {
56 2
        return $this->check(
57 2
            CheckBuilder::create(CheckName::MATCH, CheckErrorName::NOT_MATCH)
58 2
                ->withPredicate(fn ($value, string $regex) => \boolval(\preg_match($regex, $value)))
59 2
                ->withParams(['regex' => $regex])
60 2
                ->build()
61 2
        );
62
    }
63
64 2
    public function hasSubstring(string $substr): StringRuleInterface
65
    {
66 2
        return $this->check(
67 2
            CheckBuilder::create(CheckName::HAS_SUBSTRING, CheckErrorName::HAS_NOT_SUBSTRING)
68 2
                ->withPredicate(fn ($value, string $substr) => \mb_strpos($value, $substr) !== false)
69 2
                ->withParams(['substring' => $substr])
70 2
                ->build()
71 2
        );
72
    }
73
74 2
    public function startsWith(string $substr): StringRuleInterface
75
    {
76 2
        return $this->check(
77 2
            CheckBuilder::create(CheckName::STARTS_WITH, CheckErrorName::NOT_STARTS_WITH)
78 2
                ->withPredicate(fn ($value, string $substr) => \mb_strpos($value, $substr) === 0)
79 2
                ->withParams(['substring' => $substr])
80 2
                ->build()
81 2
        );
82
    }
83
84 2
    public function endsWith(string $substr): StringRuleInterface
85
    {
86 2
        return $this->check(
87 2
            CheckBuilder::create(CheckName::ENDS_WITH, CheckErrorName::NOT_ENDS_WITH)
88 2
                ->withPredicate(static function ($value, string $substr) {
89 2
                    return \substr($value, \mb_strlen($value) - \mb_strlen($substr)) === $substr;
90 2
                })
91 2
                ->withParams(['substring' => $substr])
92 2
                ->build()
93 2
        );
94
    }
95
96 2
    public function lengthIs(IntegerRuleInterface $rule): StringRuleInterface
97
    {
98 2
        return $this->check(
99 2
            CheckBuilder::create(CheckName::LENGTH_IS, CheckErrorName::INVALID_LENGTH)
100 2
                ->withPredicate(static function ($value) use ($rule) {
101
                    /** @var string $value */
102 2
                    $rule->validate(\mb_strlen($value));
103 1
                    return true;
104 2
                })
105 2
                ->build()
106 2
        );
107
    }
108
}
109