ExpressionBuilder::oneOrMoreTimes() - 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

ExpressionBuilder::oneOrMoreTimes() A

↳ Parent: ExpressionBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Spatie\Regex\Builder;

class ExpressionBuilder
{
    /**
     * @return ExpressionBuilder
     */
    public static function create(): self
    {
        return new self();
    }

    /**
     * @param $characters
     *
     * @return string
     */
    public function characterClass($characters): string
    {
        return sprintf('[%s]', $characters);
    }

    /**
     * @param string $from
     * @param string $to
     *
     * @return string
     */
    public function range(string $from, string $to): string
    {
        return sprintf('%s-%s', $from, $to);
    }

    /**
     * @param string $pattern
     *
     * @return string
     */
    public function group(string $pattern): string
    {
        return sprintf('(%s)', $pattern);
    }

    /**
     * @param string $name
     * @param string $pattern
     *
     * @return string
     */
    public function namedGroup(string $name, string $pattern): string
    {
        return $this->group(sprintf('?P<%s>%s', $name, $pattern));
    }

    /**
     * @param int $groupNumber
     *
     * @return string
     */
    public function backReferenceToNumericGroup(int $groupNumber): string
    {
        return sprintf('\%s', $groupNumber);
    }

    /**
     * @param string $groupName
     *
     * @return string
     */
    public function backReferenceToNamedGroup(string $groupName): string
    {
        return sprintf('(?P=%s)', $groupName);
    }

    /**
     * @param string $pattern
     *
     * @return string
     */
    public function startsWith(string $pattern): string
    {
        return sprintf('^%s', $pattern);
    }

    /**
     * @param string $pattern
     *
     * @return string
     */
    public function endsWith(string $pattern): string
    {
        return sprintf('%s$', $pattern);
    }

    /**
     * @param string $pattern
     *
     * @return string
     */
    public function lookBehind(string $pattern): string
    {
        return sprintf('(?<=%s)', $pattern);
    }

    /**
     * @param string $pattern
     *
     * @return string
     */
    public function lookAhead(string $pattern): string
    {
        return sprintf('(?=%s)', $pattern);
    }

    /**
     * @param string $pattern
     *
     * @return string
     */
    public function lookNotBehind(string $pattern): string
    {
        return sprintf('(?<!%s)', $pattern);
    }

    /**
     * @param string $pattern
     *
     * @return string
     */
    public function lookNotAhead(string $pattern): string
    {
        return sprintf('(?!%s)', $pattern);
    }

    /**
     * @return string
     */
    public function zeroOrOneTimes(): string
    {
        return '?';
    }

    /**
     * @return string
     */
    public function zeroOrMoreTimes(): string
    {
        return '*';
    }

    /**
     * @return string
     */
    public function oneOrMoreTimes(): string
    {
        return '+';
    }

    /**
     * @return string
     */
    public function possesiveOneOrMoreTimes(): string
    {
        return '++';
    }

    /**
     * @return string
     */
    public function lazyOneOrMoreTimes(): string
    {
        return $this->oneOrMoreTimes().'?';
    }

    /**
     * @param int $n
     * @param int $m
     *
     * @return string
     */
    public function betweenTimes(int $n, int $m): string
    {
        return sprintf('{%s,%s}', $n, $m);
    }

    /**
     * @param int $n
     * @param int $m
     *
     * @return string
     */
    public function lazyBetweenTimes(int $n, int $m): string
    {
        return $this->betweenTimes($n, $m).'?';
    }

    /**
     * @param string $comment
     *
     * @return string
     */
    public function comment(string $comment): string
    {
        return sprintf('(?# %s)', str_replace(')', '\\)', $comment));
    }

    /**
     * This method requires the free spaces modifier 'x'.
     *
     * @param string $comment
     *
     * @return string
     */
    public function extendedComment(string $comment): string
    {
        return sprintf('# %s', $comment);
    }

    /**
     * @param string      $raw
     * @param string|null $delimiter
     *
     * @return string
     */
    public function escape(string $raw, string $delimiter = null): string
    {
        return preg_quote($raw, $delimiter);
    }

    /**
     * @param array ...$expressions
     *
     * @return string
     */
    public function alternate(...$expressions): string
    {
        return implode('|', $expressions);
    }

    /**
     * @param array ...$expressions
     *
     * @return string
     */
    public function concat(...$expressions): string
    {
        return implode('', $expressions);
    }
}


1			<?php
2
3			namespace Spatie\Regex\Builder;
4
5			class ExpressionBuilder
6			{
7			/**
8			* @return ExpressionBuilder
9			*/
10			public static function create(): self
11			{
12			return new self();
13			}
14
15			/**
16			* @param $characters
17			*
18			* @return string
19			*/
20			public function characterClass($characters): string
21			{
22			return sprintf('[%s]', $characters);
23			}
24
25			/**
26			* @param string $from
27			* @param string $to
28			*
29			* @return string
30			*/
31			public function range(string $from, string $to): string
32			{
33			return sprintf('%s-%s', $from, $to);
34			}
35
36			/**
37			* @param string $pattern
38			*
39			* @return string
40			*/
41			public function group(string $pattern): string
42			{
43			return sprintf('(%s)', $pattern);
44			}
45
46			/**
47			* @param string $name
48			* @param string $pattern
49			*
50			* @return string
51			*/
52			public function namedGroup(string $name, string $pattern): string
53			{
54			return $this->group(sprintf('?P<%s>%s', $name, $pattern));
55			}
56
57			/**
58			* @param int $groupNumber
59			*
60			* @return string
61			*/
62			public function backReferenceToNumericGroup(int $groupNumber): string
63			{
64			return sprintf('\%s', $groupNumber);
65			}
66
67			/**
68			* @param string $groupName
69			*
70			* @return string
71			*/
72			public function backReferenceToNamedGroup(string $groupName): string
73			{
74			return sprintf('(?P=%s)', $groupName);
75			}
76
77			/**
78			* @param string $pattern
79			*
80			* @return string
81			*/
82			public function startsWith(string $pattern): string
83			{
84			return sprintf('^%s', $pattern);
85			}
86
87			/**
88			* @param string $pattern
89			*
90			* @return string
91			*/
92			public function endsWith(string $pattern): string
93			{
94			return sprintf('%s$', $pattern);
95			}
96
97			/**
98			* @param string $pattern
99			*
100			* @return string
101			*/
102			public function lookBehind(string $pattern): string
103			{
104			return sprintf('(?<=%s)', $pattern);
105			}
106
107			/**
108			* @param string $pattern
109			*
110			* @return string
111			*/
112			public function lookAhead(string $pattern): string
113			{
114			return sprintf('(?=%s)', $pattern);
115			}
116
117			/**
118			* @param string $pattern
119			*
120			* @return string
121			*/
122			public function lookNotBehind(string $pattern): string
123			{
124			return sprintf('(?<!%s)', $pattern);
125			}
126
127			/**
128			* @param string $pattern
129			*
130			* @return string
131			*/
132			public function lookNotAhead(string $pattern): string
133			{
134			return sprintf('(?!%s)', $pattern);
135			}
136
137			/**
138			* @return string
139			*/
140			public function zeroOrOneTimes(): string
141			{
142			return '?';
143			}
144
145			/**
146			* @return string
147			*/
148			public function zeroOrMoreTimes(): string
149			{
150			return '*';
151			}
152
153			/**
154			* @return string
155			*/
156			public function oneOrMoreTimes(): string
157			{
158			return '+';
159			}
160
161			/**
162			* @return string
163			*/
164			public function possesiveOneOrMoreTimes(): string
165			{
166			return '++';
167			}
168
169			/**
170			* @return string
171			*/
172			public function lazyOneOrMoreTimes(): string
173			{
174			return $this->oneOrMoreTimes().'?';
175			}
176
177			/**
178			* @param int $n
179			* @param int $m
180			*
181			* @return string
182			*/
183			public function betweenTimes(int $n, int $m): string
184			{
185			return sprintf('{%s,%s}', $n, $m);
186			}
187
188			/**
189			* @param int $n
190			* @param int $m
191			*
192			* @return string
193			*/
194			public function lazyBetweenTimes(int $n, int $m): string
195			{
196			return $this->betweenTimes($n, $m).'?';
197			}
198
199			/**
200			* @param string $comment
201			*
202			* @return string
203			*/
204			public function comment(string $comment): string
205			{
206			return sprintf('(?# %s)', str_replace(')', '\\)', $comment));
207			}
208
209			/**
210			* This method requires the free spaces modifier 'x'.
211			*
212			* @param string $comment
213			*
214			* @return string
215			*/
216			public function extendedComment(string $comment): string
217			{
218			return sprintf('# %s', $comment);
219			}
220
221			/**
222			* @param string $raw
223			* @param string\|null $delimiter
224			*
225			* @return string
226			*/
227			public function escape(string $raw, string $delimiter = null): string
228			{
229			return preg_quote($raw, $delimiter);
230			}
231
232			/**
233			* @param array ...$expressions
234			*
235			* @return string
236			*/
237			public function alternate(...$expressions): string
238			{
239			return implode('\|', $expressions);
240			}
241
242			/**
243			* @param array ...$expressions
244			*
245			* @return string
246			*/
247			public function concat(...$expressions): string
248			{
249			return implode('', $expressions);
250			}
251			}
252

spatie / regex

GitHub Access Token became invalid

Pull Request — master (#8)

ExpressionBuilder::oneOrMoreTimes() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like