Key::parseNoun() - Code Metrics - Inspection of "Implement possessive noun support." - Chekote/noun-store - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#41)

by Donald

created 2020-02-18 20:02 UTC

Key::parseNoun() A

↳ Parent: Key

Complexity

Conditions	4
Paths	5

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

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

<?php namespace Chekote\NounStore;

use InvalidArgumentException;

class Key
{
    use Singleton;

    const ORDINAL_ST = 'st';
    const ORDINAL_ND = 'nd';
    const ORDINAL_RD = 'rd';
    const ORDINAL_TH = 'th';

    protected static $ordinals = [
        0 => self::ORDINAL_TH,
        1 => self::ORDINAL_ST,
        2 => self::ORDINAL_ND,
        3 => self::ORDINAL_RD,
        4 => self::ORDINAL_TH,
        5 => self::ORDINAL_TH,
        6 => self::ORDINAL_TH,
        7 => self::ORDINAL_TH,
        8 => self::ORDINAL_TH,
        9 => self::ORDINAL_TH,
    ];

    const POSSESSION = "'s ";

    /**
     * Builds a key from it's separate key and index values.
     *
     * @example buildKey("Item", null): "Item"
     * @example buildKey("Item", 0): "1st Item"
     * @example buildKey("Item", 1): "2nd Item"
     * @example buildKey("Item", 2): "3rd Item"
     *
     * @param  string                   $key   The key to check.
     * @param  int|null                 $index The index (zero indexed) value for the key. If not specified, the method
     *                                         will not add an index notation to the key.
     * @throws InvalidArgumentException if $index is less than -1. Note: It should really be zero or higher, but this
     *                                        method does not assert that. The error is bubbling up from getOrdinal()
     * @return string                   the key with the index, or just the key if index is null.
     */
    public function build($key, $index)
    {
        if ($index === null) {
            return $key;
        }

        $nth = $index + 1;

        return $nth . $this->getOrdinal($nth) . ' ' . $key;
    }

    /**
     * Provides the ordinal notation for the specified nth number.
     *
     * @param  int                      $nth the number to determine the ordinal for
     * @throws InvalidArgumentException if $nth is not a positive number.
     * @return string                   the ordinal
     */
    public function getOrdinal($nth)
    {
        if ($nth < 0) {
            throw new InvalidArgumentException('$nth must be a positive number');
        }

        return $nth > 9 && $nth < 20 ? self::ORDINAL_TH : self::$ordinals[substr($nth, -1)];
    }

    /**
     * Parses a key into its individual nouns and indexes.
     *
     * @example parseNoun("Customer"): [["Customer", null]]
     * @example parseNoun("2nd Customer"): [["Customer", 1]]
     * @example parseNoun("Customer's Car"): [["Customer", null], ["Car", null]]
     * @example parseNoun("2nd Customer's Car"): [["Customer", 1], ["Car", null]]
     * @example parseNoun("4th Customer's 3rd Car"): [["Customer", 3], ["Car", 2]]
     *
     * @param  string                   $key the key to parse.
     * @throws InvalidArgumentException if the key syntax is invalid.
     * @return array[]                  a array of tuples. With each tuple have the noun with the nth removed as the
     *                                      1st item, and the index that the nth translates to as the 2nd or null if no
     *                                      nth was specified.
     */
    public function parse($key)
    {
        return array_map([$this, 'parseNoun'], $this->splitPossessions($key));
    }

    /**
     * Parses a noun into the separate key and index value.
     *
     * @example parseNoun("Item"): ["Item", null]
     * @example parseNoun("1st Item"): ["Item", 0]
     * @example parseNoun("2nd Item"): ["Item", 1]
     * @example parseNoun("3rd Item"): ["Item", 2]
     *
     * @param  string                   $noun the key to parse.
     * @throws InvalidArgumentException if the key syntax is invalid.
     * @return array                    a tuple, the 1st being the key with the nth removed, and the 2nd being the
     *                                       index that the nth translates to, or null if no nth was specified.
     */
    public function parseNoun($noun)
    {
        if (!preg_match("/^(([1-9][0-9]*)(?:st|nd|rd|th) )?([^']+)$/", $noun, $matches)) {
            throw new InvalidArgumentException('Key syntax is invalid');
        }

        // @todo use null coalescing operator when upgrading to PHP 7
        $index = isset($matches[2]) && $matches[2] !== '' ? $matches[2] - 1 : null;
        $noun = $matches[3];

        return [$noun, $index];
    }

    /**
     * Resolves an index and parsed nth value to an index.
     *
     * Ensures that if both an index and parsed nth value are provided, that they are equivalent. If only one is
     * provided, then the appropriate index will be returned. e.g. if an index is provided, it is returned as-is, as
     * it is already an index. If an nth is provided, it will be returned decremented by 1.
     *
     * @param  int|null                 $index the index to process
     * @param  int|null                 $nth   the nth to process
     * @throws InvalidArgumentException if both an $index and $key are provided, but the $key contains an nth value
     *                                        that does not match the index.
     * @throws InvalidArgumentException if nth is not null and is less than 1
     * @return int                      the resolved index.
     */
    protected function resolveIndex($index, $nth)
    {
        // If we don't have an nth, there's nothing to process. We'll just return the $index, even if it's null.
        if ($nth === null) {
            return $index;
        }

        $decrementedNth = $nth - 1;

        // If both index and nth are provided, but they aren't equivalent, we need to error out.
        if ($index !== null && $index !== $decrementedNth) {
            throw new InvalidArgumentException("index $index was provided with nth $nth, but they are not equivalent");
        }

        if ($decrementedNth < 0) {
            throw new InvalidArgumentException('nth must be equal to or larger than 1');
        }

        return $decrementedNth;
    }

    /**
     * Determines if the specified key is a possessive noun.
     *
     * @param  string $key
     * @return bool   true if the key is possessive, false if not
     */
    protected function isPossessive($key)
    {
        return strpos($key, self::POSSESSION) !== false;
    }

    /**
     * Splits a possessive key into its separate nouns.
     *
     * @example splitPossessions("Customer's Car"): ['Customer', 'Car']
     * @example splitPossessions("8th Customer's Car"): ['8th Customer', 'Car']
     * @example splitPossessions("Customer's 2nd Car"): ['Customer', '2nd Car']
     * @example splitPossessions("7th Customer's 4th Car"): ['7th Customer', '4th Car']
     * @example splitPossessions("7th Customer's 4th Car's 2nd Wheel"): ['7th Customer', '4th Car', '2nd Wheel']
     *
     * @param  string   $key the possessive key to parse
     * @return string[] an array of nouns
     */
    protected function splitPossessions($key)
    {
        return ($nouns = preg_split('/' . self::POSSESSION . '/', $key)) ? $nouns : [];

    }
}


1		<?php namespace Chekote\NounStore;
2
3		use InvalidArgumentException;
4
5		class Key
6		{
7		use Singleton;
8
9		const ORDINAL_ST = 'st';
10		const ORDINAL_ND = 'nd';
11		const ORDINAL_RD = 'rd';
12		const ORDINAL_TH = 'th';
13
14		protected static $ordinals = [
15		0 => self::ORDINAL_TH,
16		1 => self::ORDINAL_ST,
17		2 => self::ORDINAL_ND,
18		3 => self::ORDINAL_RD,
19		4 => self::ORDINAL_TH,
20		5 => self::ORDINAL_TH,
21		6 => self::ORDINAL_TH,
22		7 => self::ORDINAL_TH,
23		8 => self::ORDINAL_TH,
24		9 => self::ORDINAL_TH,
25		];
26
27		const POSSESSION = "'s ";
28
29		/**
30		* Builds a key from it's separate key and index values.
31		*
32		* @example buildKey("Item", null): "Item"
33		* @example buildKey("Item", 0): "1st Item"
34		* @example buildKey("Item", 1): "2nd Item"
35		* @example buildKey("Item", 2): "3rd Item"
36		*
37		* @param string $key The key to check.
38		* @param int\|null $index The index (zero indexed) value for the key. If not specified, the method
39		* will not add an index notation to the key.
40		* @throws InvalidArgumentException if $index is less than -1. Note: It should really be zero or higher, but this
41		* method does not assert that. The error is bubbling up from getOrdinal()
42	3	* @return string the key with the index, or just the key if index is null.
43		*/
44	3	public function build($key, $index)
45	1	{
46		if ($index === null) {
47		return $key;
48	2	}
49
50	2	$nth = $index + 1;
51
52		return $nth . $this->getOrdinal($nth) . ' ' . $key;
53		}
54
55		/**
56		* Provides the ordinal notation for the specified nth number.
57		*
58		* @param int $nth the number to determine the ordinal for
59		* @throws InvalidArgumentException if $nth is not a positive number.
60	24	* @return string the ordinal
61		*/
62	24	public function getOrdinal($nth)
63	1	{
64		if ($nth < 0) {
65		throw new InvalidArgumentException('$nth must be a positive number');
66	23	}
67
68		return $nth > 9 && $nth < 20 ? self::ORDINAL_TH : self::$ordinals[substr($nth, -1)];
69		}
70
71		/**
72		* Parses a key into its individual nouns and indexes.
73		*
74		* @example parseNoun("Customer"): [["Customer", null]]
75		* @example parseNoun("2nd Customer"): [["Customer", 1]]
76		* @example parseNoun("Customer's Car"): [["Customer", null], ["Car", null]]
77		* @example parseNoun("2nd Customer's Car"): [["Customer", 1], ["Car", null]]
78		* @example parseNoun("4th Customer's 3rd Car"): [["Customer", 3], ["Car", 2]]
79		*
80		* @param string $key the key to parse.
81		* @throws InvalidArgumentException if the key syntax is invalid.
82		* @return array[] a array of tuples. With each tuple have the noun with the nth removed as the
83		* 1st item, and the index that the nth translates to as the 2nd or null if no
84		* nth was specified.
85	14	*/
86		public function parse($key)
87	14	{
88	11	return array_map([$this, 'parseNoun'], $this->splitPossessions($key));
89	5	}
90	5
91		/**
92		* Parses a noun into the separate key and index value.
93		*
94	6	* @example parseNoun("Item"): ["Item", null]
95	6	* @example parseNoun("1st Item"): ["Item", 0]
96		* @example parseNoun("2nd Item"): ["Item", 1]
97		* @example parseNoun("3rd Item"): ["Item", 2]
98	9	*
99		* @param string $noun the key to parse.
100		* @throws InvalidArgumentException if the key syntax is invalid.
101		* @return array a tuple, the 1st being the key with the nth removed, and the 2nd being the
102		* index that the nth translates to, or null if no nth was specified.
103		*/
104		public function parseNoun($noun)
105		{
106		if (!preg_match("/^(([1-9][0-9]*)(?:st\|nd\|rd\|th) )?([^']+)$/", $noun, $matches)) {
107		throw new InvalidArgumentException('Key syntax is invalid');
108		}
109
110		// @todo use null coalescing operator when upgrading to PHP 7
111		$index = isset($matches[2]) && $matches[2] !== '' ? $matches[2] - 1 : null;
112		$noun = $matches[3];
113
114		return [$noun, $index];
115		}
116
117		/**
118		* Resolves an index and parsed nth value to an index.
119		*
120		* Ensures that if both an index and parsed nth value are provided, that they are equivalent. If only one is
121		* provided, then the appropriate index will be returned. e.g. if an index is provided, it is returned as-is, as
122		* it is already an index. If an nth is provided, it will be returned decremented by 1.
123		*
124		* @param int\|null $index the index to process
125		* @param int\|null $nth the nth to process
126		* @throws InvalidArgumentException if both an $index and $key are provided, but the $key contains an nth value
127		* that does not match the index.
128		* @throws InvalidArgumentException if nth is not null and is less than 1
129		* @return int the resolved index.
130		*/
131		protected function resolveIndex($index, $nth)
132		{
133		// If we don't have an nth, there's nothing to process. We'll just return the $index, even if it's null.
134		if ($nth === null) {
135		return $index;
136		}
137
138		$decrementedNth = $nth - 1;
139
140		// If both index and nth are provided, but they aren't equivalent, we need to error out.
141		if ($index !== null && $index !== $decrementedNth) {
142		throw new InvalidArgumentException("index $index was provided with nth $nth, but they are not equivalent");
143		}
144
145		if ($decrementedNth < 0) {
146		throw new InvalidArgumentException('nth must be equal to or larger than 1');
147		}
148
149		return $decrementedNth;
150		}
151
152		/**
153		* Determines if the specified key is a possessive noun.
154		*
155		* @param string $key
156		* @return bool true if the key is possessive, false if not
157		*/
158		protected function isPossessive($key)
159		{
160		return strpos($key, self::POSSESSION) !== false;
161		}
162
163		/**
164		* Splits a possessive key into its separate nouns.
165		*
166		* @example splitPossessions("Customer's Car"): ['Customer', 'Car']
167		* @example splitPossessions("8th Customer's Car"): ['8th Customer', 'Car']
168		* @example splitPossessions("Customer's 2nd Car"): ['Customer', '2nd Car']
169		* @example splitPossessions("7th Customer's 4th Car"): ['7th Customer', '4th Car']
170		* @example splitPossessions("7th Customer's 4th Car's 2nd Wheel"): ['7th Customer', '4th Car', '2nd Wheel']
171		*
172		* @param string $key the possessive key to parse
173		* @return string[] an array of nouns
174		*/
175		protected function splitPossessions($key)
176		{
177		return ($nouns = preg_split('/' . self::POSSESSION . '/', $key)) ? $nouns : [];
		0 ignored issues – show Bug Best Practice introduced 2020-02-18 19:46 UTC by Report Bug Copy Issue Report The expression `return $nouns = preg_spl...key) ? $nouns : array()` returns an array which contains values of type `array` which are incompatible with the documented value type `string`. Loading history...
178		}
179		}
180

Chekote / noun-store

Pull Request — master (#41)

Key::parseNoun() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like