IntString::compareTo() - Code Metrics - Inspection of "Merge pull request #129 from nelson6e65/dependabot..." - nelson6e65/php_nml - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ec8404...680b0c )

by Nelson

created 2022-04-11 18:07 UTC

IntString::compareTo() A

↳ Parent: IntString

Complexity

Conditions	5
Paths	8

Size

Total Lines	17
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes

Metric	Value
cc	5
eloc	9
nc	8
nop	1
dl	0
loc	17
rs	9.6111
c	0
b	0
f	0
ccs	0
cts	9
cp	0
crap	30

<?php

/**
 * PHP: Nelson Martell Library file
 *
 * Copyright © 2015-2021 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-2021 Nelson Martell
 * @link      http://nelson6e65.github.io/php_nml/
 * @since     0.1.1
 * @license   http://www.opensource.org/licenses/mit-license.php The MIT License (MIT)
 * */

declare(strict_types=1);

namespace NelsonMartell;

use InvalidArgumentException;
use NelsonMartell\Extensions\Text;

/**
 * Representa un elemento mixto, compuesto por un entero y una cadena unidos
 * (en ese orden).
 * El método IntString::toString obtiene esa cadena compuesta.
 *
 * @author Nelson Martell <[email protected]>
 * @since 0.1.1
 *
 * @property-read int    $intValue    Gets the integer part.
 * @property-read string $stringValue Gets the string part.
 * */
class IntString extends StrictObject implements IEquatable, IComparable
{
    /**
     * Creates a new IntString instance.
     *
     * @param int|null     $intValue    Integer part. Default: `0` (zero).
     * @param string|null  $stringValue String part. Default: `''` (empty).
     *
     * @since 1.0.0-dev Allow `null` value for `$intValue`.
     */
    public function __construct(?int $intValue = 0, $stringValue = '')
    {
        $this->intValue = $intValue;

        if (!typeof($stringValue)->canBeString()) {
            $args = [
                'position' => '2nd',
                'expected' => typeof('string') . '", "' . typeof(null) . '" or "any object convertible to string',
                'actual'   => typeof($stringValue),
            ];

            $msg  = msg('Invalid argument type.');
            $msg .= msg(
                ' {position} parameter must to be an instance of "{expected}"; "{actual}" given.',
                $args
            );

            throw new InvalidArgumentException($msg);
        }

        $this->stringValue = (string) $stringValue;

    }

    /**
     * Converts the object to an instance of `IntString` if compatible.
     *
     * @param mixed $obj Object to convert to `IntString`.
     *
     * @return IntString
     * @throws InvalidArgumentException if object is not a string or format is invalid.
     */
    public static function parse($obj)
    {
        if ($obj instanceof IntString) {
            return $obj;
        }

        if (is_integer($obj)) {
            return new IntString($obj);
        }

        try {
            $intValue = (int) Text::ensureIsString($obj);
        } catch (InvalidArgumentException $e) {
            $args = [
                'position' => '1st',
                'expected' => 'string" or "integer',
                'actual'   => typeof($obj),
            ];

            $msg  = msg('Invalid argument type.');
            $msg .= msg(
                ' {position} parameter must to be an instance of "{expected}"; "{actual}" given.',
                $args
            );

            throw new InvalidArgumentException($msg, 1, $e);
        }

        $stringValue = ltrim($obj, "${intValue}");

        // Validate that 0 (zero) is not interpreted as '' (empty string)
        if ($stringValue === $obj) {
            $msg  = msg('Invalid argument value.');
            $msg .= msg(' "{0}" (string) must to start with an integer.', $obj);

            throw new InvalidArgumentException($msg);
        }

        return new IntString($intValue, $stringValue);
    }

    /**
     * Integer part of the instance.
     *
     * @var int
     */
    private $intValue;

    /**
     * String part of the instance.
     *
     * @var string
     */
    private $stringValue;

    /**
     * Getter for $intValue property.
     *
     * @return int|null
     */
    protected function getIntValue()
    {
        return $this->intValue;
    }

    /**
     * Getter for $stringValue property.
     *
     * @return string
     */
    protected function getStringValue(): string
    {
        return $this->stringValue;
    }

    /**
     * {@inheritDoc}
     */
    public function toString(): string
    {
        return $this->getIntValue() . $this->getStringValue();
    }

    /**
     * Indicates whether the specified object is equal to the current instance.
     *
     * @param mixed $other
     *
     * @return bool
     */
    public function equals($other): bool
    {
        if ($other instanceof IntString) {
            if ($this->getIntValue() === $other->getIntValue()) {
                if ($this->getStringValue() === $other->getStringValue()) {
                    return true;
                }
            }
        }

        return false;
    }


    /**
     * Determina la posición relativa de esta instancia con respecto al
     * objeto especificado.
     * Nota: Cualquier objeto que no sea instancia de IntString se
     * considerará menor.
     *
     * @param mixed $other Objeto con el que se va a comparar.
     *
     * @return int Cero (0), si esta instancia es igual a $other; mayor
     *   a cero (>0), si es mayor a $other; menor a cero (<0), si es menor.
     * */
    public function compareTo($other)
    {
        $r = $this->equals($other) ? 0 : 9999;

        if ($r != 0) {
            if ($other instanceof IntString) {
                $r = $this->intValue - $other->intValue;

                if ($r == 0) {
                    $r = strnatcmp($this->stringValue, $other->stringValue);
                }
            } else {
                $r = 1;
            }
        }

        return $r;
    }
}


1		<?php
2
3		/**
4		* PHP: Nelson Martell Library file
5		*
6		* Copyright © 2015-2021 Nelson Martell (http://nelson6e65.github.io)
7		*
8		* Licensed under The MIT License (MIT)
9		* For full copyright and license information, please see the LICENSE
10		* Redistributions of files must retain the above copyright notice.
11		*
12		* @copyright 2015-2021 Nelson Martell
13		* @link http://nelson6e65.github.io/php_nml/
14		* @since 0.1.1
15		* @license http://www.opensource.org/licenses/mit-license.php The MIT License (MIT)
16		* */
17
18		declare(strict_types=1);
19
20		namespace NelsonMartell;
21
22		use InvalidArgumentException;
23		use NelsonMartell\Extensions\Text;
24
25		/**
26		* Representa un elemento mixto, compuesto por un entero y una cadena unidos
27		* (en ese orden).
28		* El método IntString::toString obtiene esa cadena compuesta.
29		*
30		* @author Nelson Martell <[email protected]>
31		* @since 0.1.1
32		*
33		* @property-read int $intValue Gets the integer part.
34		* @property-read string $stringValue Gets the string part.
35		* */
36		class IntString extends StrictObject implements IEquatable, IComparable
37		{
38		/**
39		* Creates a new IntString instance.
40		*
41		* @param int\|null $intValue Integer part. Default: `0` (zero).
42		* @param string\|null $stringValue String part. Default: `''` (empty).
43		*
44		* @since 1.0.0-dev Allow `null` value for `$intValue`.
45		*/
46	38	public function __construct(?int $intValue = 0, $stringValue = '')
47		{
48	38	$this->intValue = $intValue;
49
50	38	if (!typeof($stringValue)->canBeString()) {
51		$args = [
52		'position' => '2nd',
53	2	'expected' => typeof('string') . '", "' . typeof(null) . '" or "any object convertible to string',
54	2	'actual' => typeof($stringValue),
55		];
56
57	2	$msg = msg('Invalid argument type.');
58	2	$msg .= msg(
59		' {position} parameter must to be an instance of "{expected}"; "{actual}" given.',
60		$args
61		);
62
63	2	throw new InvalidArgumentException($msg);
64		}
65
66	36	$this->stringValue = (string) $stringValue;
		0 ignored issues – show Bug introduced 2018-12-24 21:52 UTC by Report Bug Copy Issue Report The property `stringValue` is declared read-only in `NelsonMartell\IntString`. Loading history...
67		}
68
69		/**
70		* Converts the object to an instance of `IntString` if compatible.
71		*
72		* @param mixed $obj Object to convert to `IntString`.
73		*
74		* @return IntString
75		* @throws InvalidArgumentException if object is not a string or format is invalid.
76		*/
77	26	public static function parse($obj)
78		{
79	26	if ($obj instanceof IntString) {
80		return $obj;
81		}
82
83	26	if (is_integer($obj)) {
84	17	return new IntString($obj);
85		}
86
87		try {
88	10	$intValue = (int) Text::ensureIsString($obj);
89		} catch (InvalidArgumentException $e) {
90		$args = [
91		'position' => '1st',
92		'expected' => 'string" or "integer',
93		'actual' => typeof($obj),
94		];
95
96		$msg = msg('Invalid argument type.');
97		$msg .= msg(
98		' {position} parameter must to be an instance of "{expected}"; "{actual}" given.',
99		$args
100		);
101
102		throw new InvalidArgumentException($msg, 1, $e);
103		}
104
105	10	$stringValue = ltrim($obj, "${intValue}");
106
107		// Validate that 0 (zero) is not interpreted as '' (empty string)
108	10	if ($stringValue === $obj) {
109	2	$msg = msg('Invalid argument value.');
110	2	$msg .= msg(' "{0}" (string) must to start with an integer.', $obj);
111
112	2	throw new InvalidArgumentException($msg);
113		}
114
115	8	return new IntString($intValue, $stringValue);
116		}
117
118		/**
119		* Integer part of the instance.
120		*
121		* @var int
122		*/
123		private $intValue;
124
125		/**
126		* String part of the instance.
127		*
128		* @var string
129		*/
130		private $stringValue;
131
132		/**
133		* Getter for $intValue property.
134		*
135		* @return int\|null
136		*/
137	67	protected function getIntValue()
138		{
139	67	return $this->intValue;
140		}
141
142		/**
143		* Getter for $stringValue property.
144		*
145		* @return string
146		*/
147	64	protected function getStringValue(): string
148		{
149	64	return $this->stringValue;
150		}
151
152		/**
153		* {@inheritDoc}
154		*/
155	9	public function toString(): string
156		{
157	9	return $this->getIntValue() . $this->getStringValue();
158		}
159
160		/**
161		* Indicates whether the specified object is equal to the current instance.
162		*
163		* @param mixed $other
164		*
165		* @return bool
166		*/
167	15	public function equals($other): bool
168		{
169	15	if ($other instanceof IntString) {
170		if ($this->getIntValue() === $other->getIntValue()) {
171		if ($this->getStringValue() === $other->getStringValue()) {
172		return true;
173		}
174		}
175		}
176
177	15	return false;
178		}
179
180
181		/**
182		* Determina la posición relativa de esta instancia con respecto al
183		* objeto especificado.
184		* Nota: Cualquier objeto que no sea instancia de IntString se
185		* considerará menor.
186		*
187		* @param mixed $other Objeto con el que se va a comparar.
188		*
189		* @return int Cero (0), si esta instancia es igual a $other; mayor
190		* a cero (>0), si es mayor a $other; menor a cero (<0), si es menor.
191		* */
192		public function compareTo($other)
193		{
194		$r = $this->equals($other) ? 0 : 9999;
195
196		if ($r != 0) {
197		if ($other instanceof IntString) {
198		$r = $this->intValue - $other->intValue;
199
200		if ($r == 0) {
201		$r = strnatcmp($this->stringValue, $other->stringValue);
202		}
203		} else {
204		$r = 1;
205		}
206		}
207
208		return $r;
209		}
210		}
211

nelson6e65 / php_nml

Push — master ( ec8404...680b0c )

IntString::compareTo() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like