Text::compare() - Code Metrics - Inspection of ":up: Improve `Extensions\Arrays::compare()`" - nelson6e65/php_nml - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 78328e...488bc1 )

by Nelson

created 2019-01-03 09:50 UTC

Text::compare() A

↳ Parent: Text

Complexity

Conditions	6
Paths	6

Size

Total Lines	21
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	6

Importance

Changes

Metric	Value
cc	6
eloc	13
nc	6
nop	2
dl	0
loc	21
ccs	13
cts	13
cp	1
crap	6
rs	9.2222
c	0
b	0
f	0

<?php
/**
 * PHP: Nelson Martell Library file
 *
 * Copyright © 2015-2019 Nelson Martell (http://nelson6e65.github.io)
 *
 * Licensed under The MIT License (MIT)
 * For full copyright and license information, please see the LICENSE
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright 2015-2019 Nelson Martell
 * @link      http://nelson6e65.github.io/php_nml/
 * @since     0.7.0
 * @license   http://www.opensource.org/licenses/mit-license.php The MIT License (MIT)
 * */
namespace NelsonMartell\Extensions;

use InvalidArgumentException;
use Cake\Utility\Text as TextBase;

use function NelsonMartell\msg;
use function NelsonMartell\typeof;
use NelsonMartell\IComparer;
use NelsonMartell\StrictObject;

/**
 * Provides extension methods to handle strings.
 * This class is based on \Cake\Utility\Text of CakePHP(tm) class.
 *
 * @since 0.7.0
 * @author Nelson Martell <[email protected]>
 * @see \Cake\Utility\Text::insert()
 * @link http://book.cakephp.org/3.0/en/core-libraries/text.html
 * */
class Text extends TextBase implements IComparer
{

    /**
     * Replaces format elements in a string with the string representation of an
     * object matching the list of arguments specified. You can give as many
     * params as you need, or an array with values.
     *
     * ##Usage
     * Using numbers as placeholders (encloses between `{` and `}`), you can get
     * the matching string representation of each object given. Use `{0}` for
     * the fist object, `{1}` for the second, and so on:
     *
     * ```php
     * $format = '{0} is {1} years old, and have {2} cats.';
     * echo Text::format($format, 'Bob', 65, 101); // 'Bob is 65 years old, and have 101 cats.'
     * ```
     *
     * You can also use an array to give objects values:
     *
     * ```php
     * $format = '{0} is {1} years old, and have {2} cats.';
     * $data   = ['Bob', 65, 101];
     * echo Text::format($format, $data); // 'Bob is 65 years old, and have 101 cats.'
     * ```
     *
     * This is specially useful to be able to use non-numeric placeholders (named placeholders):
     *
     * ```php
     * $format = '{name} is {age} years old, and have {n} cats.';
     * $data = ['name' => 'Bob', 'n' => 101, 'age' => 65];
     * echo Text::format($format, $data); // 'Bob is 65 years old, and have 101 cats.'
     * ```
     *
     * For numeric placeholders, yo can convert the array into a list of arguments.
     *
     * ```php
     * $format = '{0} is {1} years old, and have {2} cats.';
     * $data   = ['Bob', 65, 101];
     * echo Text::format($format, ...$data); // 'Bob is 65 years old, and have 101 cats.'
     * ```
     *
     * > Note: If objects are not convertible to string, it will throws and catchable exception
     * (`InvalidArgumentException`).
     *
     * @param string      $format An string containing variable placeholders to be replaced. If you provide name
     *   placeholders, you must pass the target array as
     * @param array|mixed $args   Object(s) to be replaced into $format placeholders.
     *   You can provide one item only of type array for named placeholders replacement. For numeric placeholders, you
     *   can still pass the array or convert it into arguments by using the '...' syntax instead.
     *
     * @return string
     * @throws InvalidArgumentException if $format is not an string or placeholder values are not string-convertibles.
     * @todo   Implement formatting, like IFormatProvider or something like that.
     * @author Nelson Martell <[email protected]>
     */
    public static function format($format, ...$args)
    {
        static $options = [
            'before'  => '{',
            'after'   => '}',
        ];

        $originalData = $args;

        // Make it compatible with named placeholders along numeric ones if passed only 1 array as argument
        if (count($args) === 1 && is_array($args[0])) {
            $originalData = $args[0];
        }

        $data = [];
        // Sanitize values to be convertibles into strings
        foreach ($originalData as $placeholder => $value) {
            $valueType = typeof($value);

            if ($valueType->canBeString() === false) {
                $msg = 'Value for "{{0}}" placeholder is not convertible to string; "{1}" type given.';
                throw new InvalidArgumentException(msg($msg, $placeholder, $valueType));
            }

            // This is to work-arround a bug in use of ``asort()`` function in ``Text::insert`` (at v3.2.5)
            // without SORT_STRING flag... by forcing value to be string.
            settype($value, 'string');
            $data[$placeholder] = $value;
        }

        return static::insert($format, $data, $options);
    }

    /**
     * Ensures that object given is not null. If is `null`, throws and exception.
     *
     * @param mixed $obj Object to validate
     *
     * @return mixed Same object
     * @throws InvalidArgumentException if object is `null`.
     */
    public static function ensureIsNotNull($obj)
    {
        if (is_null($obj)) {
            $msg = msg('Provided object must not be NULL.');
            throw new InvalidArgumentException($msg);
        }

        return $obj;
    }

    /**
     * Ensures that object given is an string. Else, thows an exception
     *
     * @param mixed $obj Object to validate.
     *
     * @return string Same object given, but ensured that is an string.
     * @throws InvalidArgumentException if object is not an `string`.
     */
    public static function ensureIsString($obj)
    {
        if (!is_string(static::ensureIsNotNull($obj))) {
            $msg = msg('Provided object must to be an string; "{0}" given.', typeof($obj));
            throw new InvalidArgumentException($msg);
        }

        return $obj;
    }

    /**
     * Ensures that given string is not empty.
     *
     * @param string $string String to validate.
     *
     * @return string Same string given, but ensured that is not empty.
     * @throws InvalidArgumentException if string is null or empty.
     */
    public static function ensureIsNotEmpty($string)
    {
        if (static::ensureIsString($string) === '') {
            $msg = msg('Provided string must not be empty.');
            throw new InvalidArgumentException($msg);
        }

        return $string;
    }

    /**
     * Ensures that given string is not empty or whitespaces.
     *
     * @param string $string String to validate.
     *
     * @return string Same string given, but ensured that is not whitespaces.
     * @throws InvalidArgumentException if object is not an `string`.
     * @see    \trim()
     */
    public static function ensureIsNotWhiteSpaces($string)
    {
        if (trim(static::ensureIsNotEmpty($string)) === '') {
            $msg = msg('Provided string must not be white spaces.');
            throw new InvalidArgumentException($msg);
        }

        return $string;
    }

    /**
     * Ensures that an string follows the PHP variables naming convention.
     *
     * @param string $string String to be ensured.
     *
     * @return string
     * @throws InvalidArgumentException if object is not an `string` or do not
     *   follows the PHP variables naming convention.
     */
    public static function ensureIsValidVarName($string)
    {
        $pattern = '/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/';

        if (!preg_match($pattern, static::ensureIsString($string))) {
            $msg = msg('Provided string do not follows PHP variables naming convention: "{0}".', $string);
            throw new InvalidArgumentException($msg);
        }

        return $string;
    }


    /**
     * {@inheritDoc}
     *
     * This methods is specific for the case when one of them are `string`. In other case, will fallback to
     * `StrictObject::compare()`.` You should use it directly instead of this method as comparation function
     * for `usort()`.
     *
     * @param string|mixed $left
     * @param string|mixed $right
     *
     * @return int|null
     *
     * @since 1.0.0
     * @see StrictObject::compare()
     */
    public static function compare($left, $right)
    {
        if (is_string($left)) {
            if (typeof($right)->isCustom()) { // String are minor than classes
                return -1;
            } elseif (typeof($right)->canBeString()) {
                return strnatcmp($left, $right);
            } else {
                return -1;
            }
        } elseif (is_string($right)) {
            $r = static::compare($right, $left);

            if ($r !== null) {

                $r *= -1; // Invert result
            }

            return $r;
        }

        return StrictObject::compare($left, $right);
    }
}


1		<?php
2		/**
3		* PHP: Nelson Martell Library file
4		*
5		* Copyright © 2015-2019 Nelson Martell (http://nelson6e65.github.io)
6		*
7		* Licensed under The MIT License (MIT)
8		* For full copyright and license information, please see the LICENSE
9		* Redistributions of files must retain the above copyright notice.
10		*
11		* @copyright 2015-2019 Nelson Martell
12		* @link http://nelson6e65.github.io/php_nml/
13		* @since 0.7.0
14		* @license http://www.opensource.org/licenses/mit-license.php The MIT License (MIT)
15		* */
16		namespace NelsonMartell\Extensions;
17
18		use InvalidArgumentException;
19		use Cake\Utility\Text as TextBase;
20
21		use function NelsonMartell\msg;
22		use function NelsonMartell\typeof;
23		use NelsonMartell\IComparer;
24		use NelsonMartell\StrictObject;
25
26		/**
27		* Provides extension methods to handle strings.
28		* This class is based on \Cake\Utility\Text of CakePHP(tm) class.
29		*
30		* @since 0.7.0
31		* @author Nelson Martell <[email protected]>
32		* @see \Cake\Utility\Text::insert()
33		* @link http://book.cakephp.org/3.0/en/core-libraries/text.html
34		* */
35		class Text extends TextBase implements IComparer
36		{
37
38		/**
39		* Replaces format elements in a string with the string representation of an
40		* object matching the list of arguments specified. You can give as many
41		* params as you need, or an array with values.
42		*
43		* ##Usage
44		* Using numbers as placeholders (encloses between `{` and `}`), you can get
45		* the matching string representation of each object given. Use `{0}` for
46		* the fist object, `{1}` for the second, and so on:
47		*
48		* ```php
49		* $format = '{0} is {1} years old, and have {2} cats.';
50		* echo Text::format($format, 'Bob', 65, 101); // 'Bob is 65 years old, and have 101 cats.'
51		* ```
52		*
53		* You can also use an array to give objects values:
54		*
55		* ```php
56		* $format = '{0} is {1} years old, and have {2} cats.';
57		* $data = ['Bob', 65, 101];
58		* echo Text::format($format, $data); // 'Bob is 65 years old, and have 101 cats.'
59		* ```
60		*
61		* This is specially useful to be able to use non-numeric placeholders (named placeholders):
62		*
63		* ```php
64		* $format = '{name} is {age} years old, and have {n} cats.';
65		* $data = ['name' => 'Bob', 'n' => 101, 'age' => 65];
66		* echo Text::format($format, $data); // 'Bob is 65 years old, and have 101 cats.'
67		* ```
68		*
69		* For numeric placeholders, yo can convert the array into a list of arguments.
70		*
71		* ```php
72		* $format = '{0} is {1} years old, and have {2} cats.';
73		* $data = ['Bob', 65, 101];
74		* echo Text::format($format, ...$data); // 'Bob is 65 years old, and have 101 cats.'
75		* ```
76		*
77		* > Note: If objects are not convertible to string, it will throws and catchable exception
78		* (`InvalidArgumentException`).
79		*
80		* @param string $format An string containing variable placeholders to be replaced. If you provide name
81		* placeholders, you must pass the target array as
82		* @param array\|mixed $args Object(s) to be replaced into $format placeholders.
83		* You can provide one item only of type array for named placeholders replacement. For numeric placeholders, you
84		* can still pass the array or convert it into arguments by using the '...' syntax instead.
85		*
86		* @return string
87		* @throws InvalidArgumentException if $format is not an string or placeholder values are not string-convertibles.
88		* @todo Implement formatting, like IFormatProvider or something like that.
89		* @author Nelson Martell <[email protected]>
90		*/
91	342	public static function format($format, ...$args)
92		{
93	342	static $options = [
94		'before' => '{',
95		'after' => '}',
96		];
97
98	342	$originalData = $args;
99
100		// Make it compatible with named placeholders along numeric ones if passed only 1 array as argument
101	342	if (count($args) === 1 && is_array($args[0])) {
102	333	$originalData = $args[0];
103		}
104
105	342	$data = [];
106		// Sanitize values to be convertibles into strings
107	342	foreach ($originalData as $placeholder => $value) {
108	342	$valueType = typeof($value);
109
110	342	if ($valueType->canBeString() === false) {
111	3	$msg = 'Value for "{{0}}" placeholder is not convertible to string; "{1}" type given.';
112	3	throw new InvalidArgumentException(msg($msg, $placeholder, $valueType));
113		}
114
115		// This is to work-arround a bug in use of ``asort()`` function in ``Text::insert`` (at v3.2.5)
116		// without SORT_STRING flag... by forcing value to be string.
117	342	settype($value, 'string');
118	342	$data[$placeholder] = $value;
119		}
120
121	342	return static::insert($format, $data, $options);
122		}
123
124		/**
125		* Ensures that object given is not null. If is `null`, throws and exception.
126		*
127		* @param mixed $obj Object to validate
128		*
129		* @return mixed Same object
130		* @throws InvalidArgumentException if object is `null`.
131		*/
132	190	public static function ensureIsNotNull($obj)
133		{
134	190	if (is_null($obj)) {
135		$msg = msg('Provided object must not be NULL.');
136		throw new InvalidArgumentException($msg);
137		}
138
139	190	return $obj;
140		}
141
142		/**
143		* Ensures that object given is an string. Else, thows an exception
144		*
145		* @param mixed $obj Object to validate.
146		*
147		* @return string Same object given, but ensured that is an string.
148		* @throws InvalidArgumentException if object is not an `string`.
149		*/
150	190	public static function ensureIsString($obj)
151		{
152	190	if (!is_string(static::ensureIsNotNull($obj))) {
153	1	$msg = msg('Provided object must to be an string; "{0}" given.', typeof($obj));
154	1	throw new InvalidArgumentException($msg);
155		}
156
157	189	return $obj;
158		}
159
160		/**
161		* Ensures that given string is not empty.
162		*
163		* @param string $string String to validate.
164		*
165		* @return string Same string given, but ensured that is not empty.
166		* @throws InvalidArgumentException if string is null or empty.
167		*/
168		public static function ensureIsNotEmpty($string)
169		{
170		if (static::ensureIsString($string) === '') {
171		$msg = msg('Provided string must not be empty.');
172		throw new InvalidArgumentException($msg);
173		}
174
175		return $string;
176		}
177
178		/**
179		* Ensures that given string is not empty or whitespaces.
180		*
181		* @param string $string String to validate.
182		*
183		* @return string Same string given, but ensured that is not whitespaces.
184		* @throws InvalidArgumentException if object is not an `string`.
185		* @see \trim()
186		*/
187		public static function ensureIsNotWhiteSpaces($string)
188		{
189		if (trim(static::ensureIsNotEmpty($string)) === '') {
190		$msg = msg('Provided string must not be white spaces.');
191		throw new InvalidArgumentException($msg);
192		}
193
194		return $string;
195		}
196
197		/**
198		* Ensures that an string follows the PHP variables naming convention.
199		*
200		* @param string $string String to be ensured.
201		*
202		* @return string
203		* @throws InvalidArgumentException if object is not an `string` or do not
204		* follows the PHP variables naming convention.
205		*/
206	186	public static function ensureIsValidVarName($string)
207		{
208	186	$pattern = '/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/';
209
210	186	if (!preg_match($pattern, static::ensureIsString($string))) {
211		$msg = msg('Provided string do not follows PHP variables naming convention: "{0}".', $string);
212		throw new InvalidArgumentException($msg);
213		}
214
215	186	return $string;
216		}
217
218
219		/**
220		* {@inheritDoc}
221		*
222		* This methods is specific for the case when one of them are `string`. In other case, will fallback to
223		* `StrictObject::compare()`.` You should use it directly instead of this method as comparation function
224		* for `usort()`.
225		*
226		* @param string\|mixed $left
227		* @param string\|mixed $right
228		*
229		* @return int\|null
230		*
231		* @since 1.0.0
232		* @see StrictObject::compare()
233		*/
234	36	public static function compare($left, $right)
235		{
236	36	if (is_string($left)) {
237	36	if (typeof($right)->isCustom()) { // String are minor than classes
238	7	return -1;
239	30	} elseif (typeof($right)->canBeString()) {
240	26	return strnatcmp($left, $right);
241		} else {
242	4	return -1;
243		}
244	8	} elseif (is_string($right)) {
245	8	$r = static::compare($right, $left);
246
247	8	if ($r !== null) {
		0 ignored issues – show introduced 2019-01-03 09:53 UTC by Report Bug Copy Issue Report The condition `$r !== null` is always `true`. Loading history...
248	8	$r *= -1; // Invert result
249		}
250
251	8	return $r;
252		}
253
254	1	return StrictObject::compare($left, $right);
255		}
256		}
257

nelson6e65 / php_nml

Push — master ( 78328e...488bc1 )

Text::compare() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like