RegexBuilder::isUnicode() - Code Metrics - Inspection of "Make it possible to create regular expressions pro..." - spatie/regex - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

unknown

created 2016-08-21 15:55 UTC

RegexBuilder::isUnicode() A

↳ Parent: RegexBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Spatie\Regex\Builder;

use Spatie\Regex\Regex;
use Spatie\Regex\RegexFailed;

class RegexBuilder
{
    const DEFAULT_DELIMITER = '/';

    /**
     * @var string
     */
    private $startDelimiter = self::DEFAULT_DELIMITER;

    /**
     * @var string
     */
    private $endDelimiter = self::DEFAULT_DELIMITER;

    /**
     * @var array
     */
    private $modifiers = [];

    /**
     * @var string
     */
    private $startsWith = '';

    /**
     * @var string
     */
    private $endsWith = '';

    /**
     * @var array|string[]
     */
    private $expressions = [];

    /**
     * RegexBuilder constructor.
     *
     * @param array  $expressions
     * @param string $delimiter
     * @param array  $modifiers
     */
    public function __construct(array $expressions = [], $delimiter = self::DEFAULT_DELIMITER, array $modifiers = [])
    {
        $this->expressions = $expressions;
        $this->setDelimiter($delimiter);
        $this->addModifiers($modifiers);
    }

    /**
     * @param array  $expressions
     * @param string $delimiter
     * @param array  $modifiers
     *
     * @return RegexBuilder
     */
    public static function create(array $expressions = [], $delimiter = self::DEFAULT_DELIMITER, array $modifiers = []): self
    {
        return new self($expressions, $delimiter, $modifiers);
    }

    /**
     * @param string $part
     *
     * @return RegexBuilder
     */
    public function startsWith(string $part): self
    {
        $this->startsWith = $part;

        return $this;
    }

    /**
     * @param string $part
     *
     * @return RegexBuilder
     */
    public function endsWith(string $part): self
    {
        $this->endsWith = $part;

        return $this;
    }

    /**
     * @param string $expression
     *
     * @return RegexBuilder
     */
    public function addExpression(string $expression) : self
    {
        $this->expressions[] = $expression;

        return $this;
    }

    /**
     * @param string $modifier
     *
     * @return RegexBuilder
     * @throws \Spatie\Regex\RegexFailed
     */
    public function addModifier(string $modifier): self
    {
        if (strlen($modifier) !== 1 || false === strpos(Regex::MODIFIERS_ALL, $modifier)) {
            throw RegexFailed::invalidModifier($modifier);
        }

        if ($this->hasModifier($modifier)) {
            return $this;
        }

        $this->modifiers[] = $modifier;

        return $this;
    }

    /**
     * @param array|string[] $modifiers
     *
     * @return RegexBuilder
     */
    public function addModifiers(array $modifiers): self
    {
        foreach ($modifiers as $modifier) {
            $this->addModifier($modifier);
        }

        return $this;
    }

    /**
     * @return RegexBuilder
     */
    public function isCaseInsensitive(): self
    {
        $this->addModifier(Regex::MODIFIER_CASE_INSENSITIVE);

        return $this;
    }

    /**
     * @return RegexBuilder
     */
    public function isMultiline(): self
    {
        $this->addModifier(Regex::MODIFIER_MULTILINE);

        return $this;
    }

    /**
     * @return RegexBuilder
     */
    public function isFreeSpacing(): self
    {
        $this->addModifier(Regex::MODIFIER_FREE_SPACING_MODE);

        return $this;
    }

    /**
     * @return RegexBuilder
     */
    public function isUnicode(): self
    {
        $this->addModifier(Regex::MODIFIER_UNICODE);

        return $this;
    }

    /**
     * @param string $modifier
     *
     * @return bool
     */
    public function hasModifier(string $modifier): bool
    {
        return in_array($modifier, $this->modifiers);
    }

    /**
     * @param string $modifier
     *
     * @return RegexBuilder
     */
    public function removeModifier(string $modifier): self
    {
        if (! $this->hasModifier($modifier)) {
            return $this;
        }

        $this->modifiers = array_diff($this->modifiers, [$modifier]);

        return $this;
    }

    /**
     * @param string $delimiter
     *
     * @return RegexBuilder
     * @throws \Spatie\Regex\RegexFailed
     */
    public function setDelimiter(string $delimiter): self
    {
        if (strlen($delimiter) !== 1) {
            throw RegexFailed::invalidDelimiter($delimiter);
        }

        $bracketPos = strpos(Regex::DELIMITER_BRACKET_STYLE_START, $delimiter);

        $this->startDelimiter = $delimiter;
        $this->endDelimiter = ($bracketPos !== false) ? Regex::DELIMITER_BRACKET_STYLE_END[$bracketPos] : $delimiter;

        return $this;
    }

    /**
     * @param string $glue
     *
     * @return string
     * @throws RegexFailed
     */
    public function getRegex(string $glue = ''): string
    {
        $parts = $this->expressions;
        array_unshift($parts, $this->startsWith);
        array_push($parts, $this->endsWith);

        $meta = $this->startDelimiter.'%2$s%1$s%2$s'.$this->endDelimiter.implode('', $this->modifiers);
        $expression = implode($glue, array_filter($parts));
        $pattern = sprintf($meta, $expression, $glue);

        // Test the regular expression (which throws a RegexFailed on invalid regex)
        // Todo: custom error?
        Regex::match($pattern, '');

        return $pattern;
    }
}


1			<?php
2
3			namespace Spatie\Regex\Builder;
4
5			use Spatie\Regex\Regex;
6			use Spatie\Regex\RegexFailed;
7
8			class RegexBuilder
9			{
10			const DEFAULT_DELIMITER = '/';
11
12			/**
13			* @var string
14			*/
15			private $startDelimiter = self::DEFAULT_DELIMITER;
16
17			/**
18			* @var string
19			*/
20			private $endDelimiter = self::DEFAULT_DELIMITER;
21
22			/**
23			* @var array
24			*/
25			private $modifiers = [];
26
27			/**
28			* @var string
29			*/
30			private $startsWith = '';
31
32			/**
33			* @var string
34			*/
35			private $endsWith = '';
36
37			/**
38			* @var array\|string[]
39			*/
40			private $expressions = [];
41
42			/**
43			* RegexBuilder constructor.
44			*
45			* @param array $expressions
46			* @param string $delimiter
47			* @param array $modifiers
48			*/
49			public function __construct(array $expressions = [], $delimiter = self::DEFAULT_DELIMITER, array $modifiers = [])
50			{
51			$this->expressions = $expressions;
52			$this->setDelimiter($delimiter);
53			$this->addModifiers($modifiers);
54			}
55
56			/**
57			* @param array $expressions
58			* @param string $delimiter
59			* @param array $modifiers
60			*
61			* @return RegexBuilder
62			*/
63			public static function create(array $expressions = [], $delimiter = self::DEFAULT_DELIMITER, array $modifiers = []): self
64			{
65			return new self($expressions, $delimiter, $modifiers);
66			}
67
68			/**
69			* @param string $part
70			*
71			* @return RegexBuilder
72			*/
73			public function startsWith(string $part): self
74			{
75			$this->startsWith = $part;
76
77			return $this;
78			}
79
80			/**
81			* @param string $part
82			*
83			* @return RegexBuilder
84			*/
85			public function endsWith(string $part): self
86			{
87			$this->endsWith = $part;
88
89			return $this;
90			}
91
92			/**
93			* @param string $expression
94			*
95			* @return RegexBuilder
96			*/
97			public function addExpression(string $expression) : self
98			{
99			$this->expressions[] = $expression;
100
101			return $this;
102			}
103
104			/**
105			* @param string $modifier
106			*
107			* @return RegexBuilder
108			* @throws \Spatie\Regex\RegexFailed
109			*/
110			public function addModifier(string $modifier): self
111			{
112			if (strlen($modifier) !== 1 \|\| false === strpos(Regex::MODIFIERS_ALL, $modifier)) {
113			throw RegexFailed::invalidModifier($modifier);
114			}
115
116			if ($this->hasModifier($modifier)) {
117			return $this;
118			}
119
120			$this->modifiers[] = $modifier;
121
122			return $this;
123			}
124
125			/**
126			* @param array\|string[] $modifiers
127			*
128			* @return RegexBuilder
129			*/
130			public function addModifiers(array $modifiers): self
131			{
132			foreach ($modifiers as $modifier) {
133			$this->addModifier($modifier);
134			}
135
136			return $this;
137			}
138
139			/**
140			* @return RegexBuilder
141			*/
142			public function isCaseInsensitive(): self
143			{
144			$this->addModifier(Regex::MODIFIER_CASE_INSENSITIVE);
145
146			return $this;
147			}
148
149			/**
150			* @return RegexBuilder
151			*/
152			public function isMultiline(): self
153			{
154			$this->addModifier(Regex::MODIFIER_MULTILINE);
155
156			return $this;
157			}
158
159			/**
160			* @return RegexBuilder
161			*/
162			public function isFreeSpacing(): self
163			{
164			$this->addModifier(Regex::MODIFIER_FREE_SPACING_MODE);
165
166			return $this;
167			}
168
169			/**
170			* @return RegexBuilder
171			*/
172			public function isUnicode(): self
173			{
174			$this->addModifier(Regex::MODIFIER_UNICODE);
175
176			return $this;
177			}
178
179			/**
180			* @param string $modifier
181			*
182			* @return bool
183			*/
184			public function hasModifier(string $modifier): bool
185			{
186			return in_array($modifier, $this->modifiers);
187			}
188
189			/**
190			* @param string $modifier
191			*
192			* @return RegexBuilder
193			*/
194			public function removeModifier(string $modifier): self
195			{
196			if (! $this->hasModifier($modifier)) {
197			return $this;
198			}
199
200			$this->modifiers = array_diff($this->modifiers, [$modifier]);
201
202			return $this;
203			}
204
205			/**
206			* @param string $delimiter
207			*
208			* @return RegexBuilder
209			* @throws \Spatie\Regex\RegexFailed
210			*/
211			public function setDelimiter(string $delimiter): self
212			{
213			if (strlen($delimiter) !== 1) {
214			throw RegexFailed::invalidDelimiter($delimiter);
215			}
216
217			$bracketPos = strpos(Regex::DELIMITER_BRACKET_STYLE_START, $delimiter);
218
219			$this->startDelimiter = $delimiter;
220			$this->endDelimiter = ($bracketPos !== false) ? Regex::DELIMITER_BRACKET_STYLE_END[$bracketPos] : $delimiter;
221
222			return $this;
223			}
224
225			/**
226			* @param string $glue
227			*
228			* @return string
229			* @throws RegexFailed
230			*/
231			public function getRegex(string $glue = ''): string
232			{
233			$parts = $this->expressions;
234			array_unshift($parts, $this->startsWith);
235			array_push($parts, $this->endsWith);
236
237			$meta = $this->startDelimiter.'%2$s%1$s%2$s'.$this->endDelimiter.implode('', $this->modifiers);
238			$expression = implode($glue, array_filter($parts));
239			$pattern = sprintf($meta, $expression, $glue);
240
241			// Test the regular expression (which throws a RegexFailed on invalid regex)
242			// Todo: custom error?
243			Regex::match($pattern, '');
244
245			return $pattern;
246			}
247			}
248

spatie / regex

GitHub Access Token became invalid

Pull Request — master (#8)

RegexBuilder::isUnicode() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like