WildcardPattern::getPatternPrepared() - Code Metrics - Inspection of "Increase Wildcard Pattern speed" - yiisoft/strings - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#117)

by Viktor

created 2023-10-26 13:59 UTC

WildcardPattern::getPatternPrepared() A

↳ Parent: WildcardPattern

Complexity

Conditions	4
Paths	5

Size

Total Lines	43
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	32
CRAP Score	4

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	28
c	1
b	0
f	0
nc	5
nop	0
dl	0
loc	43
ccs	32
cts	32
cp	1
crap	4
rs	9.472

<?php

declare(strict_types=1);

namespace Yiisoft\Strings;

use function implode;
use function preg_match;
use function preg_quote;
use function preg_replace;
use function strtr;

/**
 * A wildcard pattern to match strings against.
 *
 * - `\` escapes other special characters if usage of escape character is not turned off.
 * - `*` matches any string including the empty string except it has a delimiter (`/` and `\` by default).
 * - `**` matches any string including the empty string and delimiters.
 * - `?` matches any single character.
 * - `[seq]` matches any character in seq.
 * - `[a-z]` matches any character from a to z.
 * - `[!seq]` matches any character not in seq.
 * - `[[:alnum:]]` matches POSIX style character classes,
 *   see {@see https://www.php.net/manual/en/regexp.reference.character-classes.php}.
 */
final class WildcardPattern
{
    private bool $ignoreCase = false;
    private ?string $patternPrepared = null;

    /**
     * @param string $pattern The shell wildcard pattern to match against.
     * @param string[] $delimiters Delimiters to consider for "*" (`/` and `\` by default).
     */
    public function __construct(
        private string $pattern,
        private array $delimiters = ['\\\\', '/'],
    ) {
    }

    /**
     * Checks if the passed string would match the given shell wildcard pattern.
     *
     * @param string $string The tested string.
     *
     * @return bool Whether the string matches pattern or not.
     */
    public function match(string $string): bool
    {
        if ($this->pattern === '**') {
            return true;
        }

        return preg_match($this->getPatternPrepared(), $string) === 1;
    }

    /**
     * Make pattern case insensitive.
     */
    public function ignoreCase(bool $flag = true): self
    {
        $new = clone $this;
        $new->patternPrepared = null;
        $new->ignoreCase = $flag;

        return $new;
    }

    /**
     * Returns whether the pattern contains a dynamic part i.e.
     * has unescaped "*",  "{", "?", or "[" character.
     *
     * @param string $pattern The pattern to check.
     *
     * @return bool Whether the pattern contains a dynamic part.
     */
    public static function isDynamic(string $pattern): bool
    {
        $pattern = preg_replace('/\\\\./', '', $pattern);
        return preg_match('/[*{?\[]/', $pattern) === 1;
    }

    /**
     * Escapes pattern characters in a string.
     *
     * @param string $string Source string.
     *
     * @return string String with pattern characters escaped.
     */
    public static function quote(string $string): string
    {
        return preg_replace('#([\\\\?*\\[\\]])#', '\\\\$1', $string);
    }

    /**
     * @return non-empty-string

     */
    private function getPatternPrepared(): string
    {
        if ($this->patternPrepared === null) {
            $replacements = [
                '\*\*' => '.*',
                '\\\\\\\\' => '\\\\',
                '\\\\\\*' => '[*]',
                '\\\\\\?' => '[?]',
                '\\\\\\[' => '[\[]',
                '\\\\\\]' => '[\]]',
            ];

            if ($this->delimiters === []) {
                $replacements += [
                    '\*' => '.*',
                    '\?' => '?',
                ];
            } else {
                $notDelimiters = '[^' . preg_quote(implode('', $this->delimiters), '#') . ']';
                $replacements += [
                    '\*' => "$notDelimiters*",
                    '\?' => $notDelimiters,
                ];
            }

            $replacements += [
                '\[\!' => '[^',
                '\[' => '[',
                '\]' => ']',
                '\-' => '-',
            ];

            $pattern = strtr(preg_quote($this->pattern, '#'), $replacements);
            $pattern = '#^' . $pattern . '$#us';

            if ($this->ignoreCase) {
                $pattern .= 'i';
            }

            $this->patternPrepared = $pattern;
        }

        return $this->patternPrepared;

    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Strings;
6
7		use function implode;
8		use function preg_match;
9		use function preg_quote;
10		use function preg_replace;
11		use function strtr;
12
13		/**
14		* A wildcard pattern to match strings against.
15		*
16		* - `\` escapes other special characters if usage of escape character is not turned off.
17		* - `*` matches any string including the empty string except it has a delimiter (`/` and `\` by default).
18		* - `**` matches any string including the empty string and delimiters.
19		* - `?` matches any single character.
20		* - `[seq]` matches any character in seq.
21		* - `[a-z]` matches any character from a to z.
22		* - `[!seq]` matches any character not in seq.
23		* - `[[:alnum:]]` matches POSIX style character classes,
24		* see {@see https://www.php.net/manual/en/regexp.reference.character-classes.php}.
25		*/
26		final class WildcardPattern
27		{
28		private bool $ignoreCase = false;
29		private ?string $patternPrepared = null;
30
31		/**
32		* @param string $pattern The shell wildcard pattern to match against.
33		* @param string[] $delimiters Delimiters to consider for "*" (`/` and `\` by default).
34		*/
35	59	public function __construct(
36		private string $pattern,
37		private array $delimiters = ['\\\\', '/'],
38		) {
39	59	}
40
41		/**
42		* Checks if the passed string would match the given shell wildcard pattern.
43		*
44		* @param string $string The tested string.
45		*
46		* @return bool Whether the string matches pattern or not.
47		*/
48	58	public function match(string $string): bool
49		{
50	58	if ($this->pattern === '**') {
51	1	return true;
52		}
53
54	57	return preg_match($this->getPatternPrepared(), $string) === 1;
55		}
56
57		/**
58		* Make pattern case insensitive.
59		*/
60	3	public function ignoreCase(bool $flag = true): self
61		{
62	3	$new = clone $this;
63	3	$new->patternPrepared = null;
64	3	$new->ignoreCase = $flag;
65
66	3	return $new;
67		}
68
69		/**
70		* Returns whether the pattern contains a dynamic part i.e.
71		* has unescaped "*", "{", "?", or "[" character.
72		*
73		* @param string $pattern The pattern to check.
74		*
75		* @return bool Whether the pattern contains a dynamic part.
76		*/
77	5	public static function isDynamic(string $pattern): bool
78		{
79	5	$pattern = preg_replace('/\\\\./', '', $pattern);
80	5	return preg_match('/[*{?\[]/', $pattern) === 1;
81		}
82
83		/**
84		* Escapes pattern characters in a string.
85		*
86		* @param string $string Source string.
87		*
88		* @return string String with pattern characters escaped.
89		*/
90	2	public static function quote(string $string): string
91		{
92	2	return preg_replace('#([\\\\?*\\[\\]])#', '\\\\$1', $string);
93		}
94
95		/**
96		* @return non-empty-string
		0 ignored issues – show Documentation Bug introduced 2023-10-26 13:58 UTC by Report Bug Copy Issue Report The doc comment `non-empty-string` at position `0` could not be parsed: Unknown type name 'non-empty-string' at position 0 in non-empty-string. Loading history...
97		*/
98	57	private function getPatternPrepared(): string
99		{
100	57	if ($this->patternPrepared === null) {
101	57	$replacements = [
102	57	'\\' => '.*',
103	57	'\\\\\\\\' => '\\\\',
104	57	'\\\\\\' => '[]',
105	57	'\\\\\\?' => '[?]',
106	57	'\\\\\\[' => '[\[]',
107	57	'\\\\\\]' => '[\]]',
108	57	];
109
110	57	if ($this->delimiters === []) {
111	1	$replacements += [
112	1	'\' => '.',
113	1	'\?' => '?',
114	1	];
115		} else {
116	56	$notDelimiters = '[^' . preg_quote(implode('', $this->delimiters), '#') . ']';
117	56	$replacements += [
118	56	'\' => "$notDelimiters",
119	56	'\?' => $notDelimiters,
120	56	];
121		}
122
123	57	$replacements += [
124	57	'\[\!' => '[^',
125	57	'\[' => '[',
126	57	'\]' => ']',
127	57	'\-' => '-',
128	57	];
129
130	57	$pattern = strtr(preg_quote($this->pattern, '#'), $replacements);
131	57	$pattern = '#^' . $pattern . '$#us';
132
133	57	if ($this->ignoreCase) {
134	1	$pattern .= 'i';
135		}
136
137	57	$this->patternPrepared = $pattern;
138		}
139
140	57	return $this->patternPrepared;
		0 ignored issues – show Bug Best Practice introduced 2023-10-26 13:55 UTC by Report Bug Copy Issue Report The expression `return $this->patternPrepared` could return the type `null` which is incompatible with the type-hinted return `string`. Consider adding an additional type-check to rule them out. Loading history...
141		}
142		}
143

yiisoft / strings

Pull Request — master (#117)

WildcardPattern::getPatternPrepared() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like