Matcher::doMatch() - Code Metrics - Inspection of "Merge pull request #345 from giggsey/upstream-8.10..." - giggsey/libphonenumber-for-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 04d022...f3a55d )

by Joshua

created 2019-10-30 11:52 UTC

Matcher::doMatch() B

↳ Parent: Matcher

Complexity

Conditions	6
Paths	8

Size

Total Lines	37
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	22
CRAP Score	6

Importance

Changes

Metric	Value
cc	6
eloc	22
nc	8
nop	2
dl	0
loc	37
ccs	22
cts	22
cp	1
crap	6
rs	8.9457
c	0
b	0
f	0

<?php

namespace libphonenumber;

/**
 * Matcher for various regex matching
 *
 * Note that this is NOT the same as google's java PhoneNumberMatcher class.
 * This class is a minimal port of java's built-in matcher class, whereas PhoneNumberMatcher
 * is designed to recognize phone numbers embedded in any text.
 *
 * @internal
 */
class Matcher
{
    /**
     * @var string
     */
    protected $pattern;

    /**
     * @var string
     */
    protected $subject;

    /**
     * @var array
     */
    protected $groups = array();

    private $searchIndex = 0;

    /**
     * @param string $pattern
     * @param string $subject
     */
    public function __construct($pattern, $subject)
    {
        $this->pattern = str_replace('/', '\/', $pattern);
        $this->subject = $subject;
    }

    protected function doMatch($type = 'find', $offset = 0)
    {
        $final_pattern = '(?:' . $this->pattern . ')';
        switch ($type) {
            case 'matches':
                $final_pattern = '^' . $final_pattern . '$';
                break;
            case 'lookingAt':
                $final_pattern = '^' . $final_pattern;
                break;
            case 'find':
            default:
                // no changes
                break;
        }
        $final_pattern = '/' . $final_pattern . '/ui';

        $search = mb_substr($this->subject, $offset);

        $result = preg_match($final_pattern, $search, $groups, PREG_OFFSET_CAPTURE);

        if ($result === 1) {
            // Expand $groups into $this->groups, but being multi-byte aware

            $positions = array();

            foreach ($groups as $group) {
                $positions[] = array(
                    $group[0],
                    $offset + mb_strlen(mb_strcut($search, 0, $group[1]))
                );
            }

            $this->groups = $positions;
        }

        return ($result === 1);
    }

    /**
     * @return bool
     */
    public function matches()
    {
        return $this->doMatch('matches');
    }

    /**
     * @return bool
     */
    public function lookingAt()
    {
        return $this->doMatch('lookingAt');
    }

    /**
     * @return bool
     */
    public function find($offset = null)
    {
        if ($offset === null) {
            $offset = $this->searchIndex;
        }

        // Increment search index for the next time we call this
        $this->searchIndex++;
        return $this->doMatch('find', $offset);
    }

    /**
     * @return int
     */
    public function groupCount()
    {
        if (empty($this->groups)) {
            return null;
        }

        return count($this->groups) - 1;
    }

    /**
     * @param int $group
     * @return string
     */
    public function group($group = null)
    {
        if ($group === null) {
            $group = 0;
        }
        return isset($this->groups[$group][0]) ? $this->groups[$group][0] : null;
    }

    /**
     * @param int|null $group
     * @return int
     */
    public function end($group = null)
    {
        if ($group === null) {
            $group = 0;
        }
        if (!isset($this->groups[$group])) {
            return null;
        }
        return $this->groups[$group][1] + mb_strlen($this->groups[$group][0]);
    }

    public function start($group = null)
    {
        if ($group === null) {
            $group = 0;
        }
        if (!isset($this->groups[$group])) {
            return null;
        }

        return $this->groups[$group][1];
    }

    /**
     * @param string $replacement
     * @return string
     */
    public function replaceFirst($replacement)
    {
        return preg_replace('/' . $this->pattern . '/x', $replacement, $this->subject, 1);
    }

    /**
     * @param string $replacement
     * @return string
     */
    public function replaceAll($replacement)
    {
        return preg_replace('/' . $this->pattern . '/x', $replacement, $this->subject);
    }

    /**
     * @param string $input
     * @return Matcher
     */
    public function reset($input = '')
    {
        $this->subject = $input;

        return $this;
    }
}


1		<?php
2
3		namespace libphonenumber;
4
5		/**
6		* Matcher for various regex matching
7		*
8		* Note that this is NOT the same as google's java PhoneNumberMatcher class.
9		* This class is a minimal port of java's built-in matcher class, whereas PhoneNumberMatcher
10		* is designed to recognize phone numbers embedded in any text.
11		*
12		* @internal
13		*/
14		class Matcher
15		{
16		/**
17		* @var string
18		*/
19		protected $pattern;
20
21		/**
22		* @var string
23		*/
24		protected $subject;
25
26		/**
27		* @var array
28		*/
29		protected $groups = array();
30
31		private $searchIndex = 0;
32
33		/**
34		* @param string $pattern
35		* @param string $subject
36		*/
37	3399	public function __construct($pattern, $subject)
38		{
39	3399	$this->pattern = str_replace('/', '\/', $pattern);
40	3399	$this->subject = $subject;
41	3399	}
42
43	3399	protected function doMatch($type = 'find', $offset = 0)
44		{
45	3399	$final_pattern = '(?:' . $this->pattern . ')';
46	3399	switch ($type) {
47	3399	case 'matches':
48	3367	$final_pattern = '^' . $final_pattern . '$';
49	3367	break;
50	3391	case 'lookingAt':
51	3365	$final_pattern = '^' . $final_pattern;
52	3365	break;
53	3333	case 'find':
54		default:
55		// no changes
56	3333	break;
57		}
58	3399	$final_pattern = '/' . $final_pattern . '/ui';
59
60	3399	$search = mb_substr($this->subject, $offset);
61
62	3399	$result = preg_match($final_pattern, $search, $groups, PREG_OFFSET_CAPTURE);
63
64	3399	if ($result === 1) {
65		// Expand $groups into $this->groups, but being multi-byte aware
66
67	2960	$positions = array();
68
69	2960	foreach ($groups as $group) {
70	2960	$positions[] = array(
71	2960	$group[0],
72	2960	$offset + mb_strlen(mb_strcut($search, 0, $group[1]))
73		);
74		}
75
76	2960	$this->groups = $positions;
77		}
78
79	3399	return ($result === 1);
80		}
81
82		/**
83		* @return bool
84		*/
85	3367	public function matches()
86		{
87	3367	return $this->doMatch('matches');
88		}
89
90		/**
91		* @return bool
92		*/
93	3365	public function lookingAt()
94		{
95	3365	return $this->doMatch('lookingAt');
96		}
97
98		/**
99		* @return bool
100		*/
101	3333	public function find($offset = null)
102		{
103	3333	if ($offset === null) {
104	3332	$offset = $this->searchIndex;
105		}
106
107		// Increment search index for the next time we call this
108	3333	$this->searchIndex++;
109	3333	return $this->doMatch('find', $offset);
110		}
111
112		/**
113		* @return int
114		*/
115	169	public function groupCount()
116		{
117	169	if (empty($this->groups)) {
118		return null;
119		}
120
121	169	return count($this->groups) - 1;
122		}
123
124		/**
125		* @param int $group
126		* @return string
127		*/
128	103	public function group($group = null)
129		{
130	103	if ($group === null) {
131	31	$group = 0;
132		}
133	103	return isset($this->groups[$group][0]) ? $this->groups[$group][0] : null;
134		}
135
136		/**
137		* @param int\|null $group
138		* @return int
139		*/
140	337	public function end($group = null)
141		{
142	337	if ($group === null) {
143	337	$group = 0;
144		}
145	337	if (!isset($this->groups[$group])) {
146		return null;
147		}
148	337	return $this->groups[$group][1] + mb_strlen($this->groups[$group][0]);
149		}
150
151	233	public function start($group = null)
152		{
153	233	if ($group === null) {
154	233	$group = 0;
155		}
156	233	if (!isset($this->groups[$group])) {
157		return null;
158		}
159
160	233	return $this->groups[$group][1];
161		}
162
163		/**
164		* @param string $replacement
165		* @return string
166		*/
167	60	public function replaceFirst($replacement)
168		{
169	60	return preg_replace('/' . $this->pattern . '/x', $replacement, $this->subject, 1);
170		}
171
172		/**
173		* @param string $replacement
174		* @return string
175		*/
176	121	public function replaceAll($replacement)
177		{
178	121	return preg_replace('/' . $this->pattern . '/x', $replacement, $this->subject);
179		}
180
181		/**
182		* @param string $input
183		* @return Matcher
184		*/
185	59	public function reset($input = '')
186		{
187	59	$this->subject = $input;
188
189	59	return $this;
190		}
191		}
192

giggsey / libphonenumber-for-php

Push — master ( 04d022...f3a55d )

Matcher::doMatch() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like