MetaCharacters::isQuantifiable() - Code Metrics - Inspection of "WiP" - s9e/RegexpBuilder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — MetaCharacters (da2f1d)

by Josh

created 2018-01-05 04:01 UTC

MetaCharacters::isQuantifiable() A

↳ Parent: MetaCharacters

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	2

Importance

Changes

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

<?php

/**
* @package   s9e\RegexpBuilder
* @copyright Copyright (c) 2016-2018 The s9e Authors
* @license   http://www.opensource.org/licenses/mit-license.php The MIT License
*/
namespace s9e\RegexpBuilder;

use InvalidArgumentException;
use s9e\RegexpBuilder\Input\InputInterface;

class MetaCharacters
{
	/**
	* @const Bit value that indicates whether a meta-character represents a single character
	*/
	const IS_CHAR = 1;

	/**
	* @const Bit value that indicates whether a meta-character represents a quantifiable expression
	*/
	const IS_QUANTIFIABLE = 2;

	/**
	* @var array Map of meta values and the expression they represent
	*/
	protected $exprs = [];

	/**
	* @var InputInterface
	*/
	protected $input;

	/**
	* @var array Map of meta-characters' codepoints and their value
	*/
	protected $meta = [];

	/**
	* @param InputInterface $input
	*/
	public function __construct(InputInterface $input)
	{
		$this->input = $input;
	}

	/**
	* Add a meta-character to the list
	*
	* @param  string $char Meta-character
	* @param  string $expr Regular expression
	* @return void
	*/
	public function add($char, $expr)
	{
		$split = $this->input->split($char);
		if (count($split) !== 1)
		{
			throw new InvalidArgumentException('Meta-characters must be represented by exactly one character');
		}
		if (@preg_match('(' . $expr . ')u', '') === false)
		{
			throw new InvalidArgumentException("Invalid expression '" . $expr . "'");
		}

		$inputValue = $split[0];
		$metaValue  = $this->computeValue($expr);

		$this->exprs[$metaValue] = $expr;
		$this->meta[$inputValue] = $metaValue;
	}

	/**
	* Get the expression associated with a meta value
	*
	* @param  integer $metaValue
	* @return string
	*/
	public function getExpression($metaValue)
	{
		if (!isset($this->exprs[$metaValue]))
		{
			throw new InvalidArgumentException('Invalid meta value ' . $metaValue);
		}

		return $this->exprs[$metaValue];
	}

	/**
	* Return whether a given value represents a single character
	*
	* @param  integer $value
	* @return bool
	*/
	public static function isChar($value)
	{
		return ($value >= 0 || ($value & self::IS_CHAR));
	}

	/**
	* Return whether a given value represents a quantifiable expression
	*
	* @param  integer $value
	* @return bool
	*/
	public static function isQuantifiable($value)
	{
		return ($value >= 0 || ($value & self::IS_QUANTIFIABLE));
	}

	/**
	* Replace values from meta-characters in a list of strings with their meta value
	*
	* @param  array[] $strings
	* @return array[]
	*/
	public function replaceMeta(array $strings)
	{
		foreach ($strings as &$string)
		{
			foreach ($string as &$value)
			{
				if (isset($this->meta[$value]))
				{
					$value = $this->meta[$value];
				}
			}
		}

		return $strings;
	}

	/**
	* Compute and return a value for given expression
	*
	* Values are meant to be a unique negative integer. The last 2 bits indicate whether the
	* expression is quantifiable and/or represents a single character.
	*
	* @param  string  $expr Regular expression
	* @return integer
	*/
	protected function computeValue($expr)
	{
		$value = (1 + count($this->meta)) * -4;
		if ($this->exprIsChar($expr))
		{
			$value |= self::IS_CHAR;
		}
		if ($this->exprIsQuantifiable($expr))
		{
			$value |= self::IS_QUANTIFIABLE;
		}

		return $value;
	}

	/**
	* Test whether given expression represents a single character usable in a character class
	*
	* @param  string $expr
	* @return bool
	*/
	protected function exprIsChar($expr)
	{
		$regexps = [
			// A dot
			'(^\\.$)D',

			// Escaped literal or escape sequence such as \w but not \R
			'(^\\\\[adefhnrstvwDHNSVW\\W]$)D',

			// Unicode properties such as \pL or \p{Lu}
			'(^\\\\p(?:.|\\{[^}]+\\})$)Di',

			// An escape sequence such as \x1F or \x{2600}
			'(^\\\\x(?:[0-9a-f]{2}|\\{[^}]+\\})$)Di',

			// A character class
			'(^\\[\\^?(?:([^\\\\\\]]|\\\\.)(?:-(?-1))?)++\\]$)D'
		];
		foreach ($regexps as $regexp)
		{
			if (preg_match($regexp, $expr))
			{
				return true;
			}
		}

		return false;
	}

	/**
	* Test whether given expression is quantifiable
	*
	* @param  string $expr
	* @return bool
	*/
	protected function exprIsQuantifiable($expr)
	{
		return $this->exprIsChar($expr);
	}
}

1		<?php
2
3		/**
4		* @package s9e\RegexpBuilder
5		* @copyright Copyright (c) 2016-2018 The s9e Authors
6		* @license http://www.opensource.org/licenses/mit-license.php The MIT License
7		*/
8		namespace s9e\RegexpBuilder;
9
10		use InvalidArgumentException;
11		use s9e\RegexpBuilder\Input\InputInterface;
12
13		class MetaCharacters
14		{
15		/**
16		* @const Bit value that indicates whether a meta-character represents a single character
17		*/
18		const IS_CHAR = 1;
19
20		/**
21		* @const Bit value that indicates whether a meta-character represents a quantifiable expression
22		*/
23		const IS_QUANTIFIABLE = 2;
24
25		/**
26		* @var array Map of meta values and the expression they represent
27		*/
28		protected $exprs = [];
29
30		/**
31		* @var InputInterface
32		*/
33		protected $input;
34
35		/**
36		* @var array Map of meta-characters' codepoints and their value
37		*/
38		protected $meta = [];
39
40		/**
41		* @param InputInterface $input
42		*/
43	13	public function __construct(InputInterface $input)
44		{
45	13	$this->input = $input;
46	13	}
47
48		/**
49		* Add a meta-character to the list
50		*
51		* @param string $char Meta-character
52		* @param string $expr Regular expression
53		* @return void
54		*/
55	12	public function add($char, $expr)
56		{
57	12	$split = $this->input->split($char);
58	12	if (count($split) !== 1)
59		{
60	1	throw new InvalidArgumentException('Meta-characters must be represented by exactly one character');
61		}
62	11	if (@preg_match('(' . $expr . ')u', '') === false)
63		{
64	1	throw new InvalidArgumentException("Invalid expression '" . $expr . "'");
65		}
66
67	10	$inputValue = $split[0];
68	10	$metaValue = $this->computeValue($expr);
69
70	10	$this->exprs[$metaValue] = $expr;
71	10	$this->meta[$inputValue] = $metaValue;
72	10	}
73
74		/**
75		* Get the expression associated with a meta value
76		*
77		* @param integer $metaValue
78		* @return string
79		*/
80	2	public function getExpression($metaValue)
81		{
82	2	if (!isset($this->exprs[$metaValue]))
83		{
84	1	throw new InvalidArgumentException('Invalid meta value ' . $metaValue);
85		}
86
87	1	return $this->exprs[$metaValue];
88		}
89
90		/**
91		* Return whether a given value represents a single character
92		*
93		* @param integer $value
94		* @return bool
95		*/
96	9	public static function isChar($value)
97		{
98	9	return ($value >= 0 \|\| ($value & self::IS_CHAR));
99		}
100
101		/**
102		* Return whether a given value represents a quantifiable expression
103		*
104		* @param integer $value
105		* @return bool
106		*/
107	9	public static function isQuantifiable($value)
108		{
109	9	return ($value >= 0 \|\| ($value & self::IS_QUANTIFIABLE));
110		}
111
112		/**
113		* Replace values from meta-characters in a list of strings with their meta value
114		*
115		* @param array[] $strings
116		* @return array[]
117		*/
118	10	public function replaceMeta(array $strings)
119		{
120	10	foreach ($strings as &$string)
121		{
122	10	foreach ($string as &$value)
123		{
124	10	if (isset($this->meta[$value]))
125		{
126	10	$value = $this->meta[$value];
127		}
128		}
129		}
130
131	10	return $strings;
132		}
133
134		/**
135		* Compute and return a value for given expression
136		*
137		* Values are meant to be a unique negative integer. The last 2 bits indicate whether the
138		* expression is quantifiable and/or represents a single character.
139		*
140		* @param string $expr Regular expression
141		* @return integer
142		*/
143	10	protected function computeValue($expr)
144		{
145	10	$value = (1 + count($this->meta)) * -4;
146	10	if ($this->exprIsChar($expr))
147		{
148	5	$value \|= self::IS_CHAR;
149		}
150	10	if ($this->exprIsQuantifiable($expr))
151		{
152	5	$value \|= self::IS_QUANTIFIABLE;
153		}
154
155	10	return $value;
156		}
157
158		/**
159		* Test whether given expression represents a single character usable in a character class
160		*
161		* @param string $expr
162		* @return bool
163		*/
164	10	protected function exprIsChar($expr)
165		{
166		$regexps = [
167		// A dot
168	10	'(^\\.$)D',
169
170		// Escaped literal or escape sequence such as \w but not \R
171		'(^\\\\[adefhnrstvwDHNSVW\\W]$)D',
172
173		// Unicode properties such as \pL or \p{Lu}
174		'(^\\\\p(?:.\|\\{[^}]+\\})$)Di',
175
176		// An escape sequence such as \x1F or \x{2600}
177		'(^\\\\x(?:[0-9a-f]{2}\|\\{[^}]+\\})$)Di',
178
179		// A character class
180		'(^\\[\\^?(?:([^\\\\\\]]\|\\\\.)(?:-(?-1))?)++\\]$)D'
181		];
182	10	foreach ($regexps as $regexp)
183		{
184	10	if (preg_match($regexp, $expr))
185		{
186	10	return true;
187		}
188		}
189
190	5	return false;
191		}
192
193		/**
194		* Test whether given expression is quantifiable
195		*
196		* @param string $expr
197		* @return bool
198		*/
199	10	protected function exprIsQuantifiable($expr)
200		{
201	10	return $this->exprIsChar($expr);
202		}
203		}

s9e / RegexpBuilder

Branch — MetaCharacters (da2f1d)

MetaCharacters::isQuantifiable() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like