NumberInterval::equal() - Code Metrics - Inspection of "rename method BaseType::getIntervalClass()" - gpslab/interval - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8b40f4...1a4202 )

by Peter

created 2016-12-12 14:53 UTC

NumberInterval::equal() A

↳ Parent: NumberInterval

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	4
Ratio	100 %

Importance

Changes

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

<?php

/**
 * GpsLab component.
 *
 * @author    Peter Gribanov <[email protected]>
 * @copyright Copyright (c) 2016, Peter Gribanov
 * @license   http://opensource.org/licenses/MIT
 */

namespace GpsLab\Component\Interval\Number;

use GpsLab\Component\Interval\Exception\IncorrectIntervalException;
use GpsLab\Component\Interval\Exception\InvalidIntervalFormatException;
use GpsLab\Component\Interval\IntervalComparator;
use GpsLab\Component\Interval\ComparableIntervalInterface;
use GpsLab\Component\Interval\IntervalPointInterface;
use GpsLab\Component\Interval\IntervalType;

class NumberInterval implements ComparableIntervalInterface

{
    /**
     * @var string
     */
    const REGEXP = '/^
        (?:\(|\[)        # start type char
        \s*
        (?<start>\-?\d+) # start point
        \s*,\s*          # separator
        (?<end>\-?\d+)   # end point
        \s*
        (?:\)|\])        # end type char
    $/x';

    /**
     * @var IntervalType
     */
    private $type;

    /**
     * @var IntervalComparator
     */
    private $comparator;

    /**
     * @var NumberIntervalPoint
     */
    private $start;

    /**
     * @var NumberIntervalPoint
     */
    private $end;

    /**
     * @param NumberIntervalPoint $start
     * @param NumberIntervalPoint $end
     * @param IntervalType $type
     */
    private function __construct(NumberIntervalPoint $start, NumberIntervalPoint $end, IntervalType $type)
    {
        if ($start->gte($end)) {
            throw IncorrectIntervalException::create();
        }

        $this->start = $start;
        $this->end = $end;
        $this->type = $type;
        $this->comparator = new IntervalComparator($this);
    }

    /**
     * @param int|float $start
     * @param int|float $end
     * @param IntervalType $type
     *
     * @return self
     */
    public static function create($start, $end, IntervalType $type)
    {
        return new self(new NumberIntervalPoint($start), new NumberIntervalPoint($end), $type);
    }

    /**
     * @param int|float $start
     * @param int|float $end
     *
     * @return self
     */
    public static function closed($start, $end)
    {
        return self::create($start, $end, IntervalType::closed());
    }

    /**
     * @param int|float $start
     * @param int|float $end
     *
     * @return self
     */
    public static function halfClosed($start, $end)
    {
        return self::create($start, $end, IntervalType::halfClosed());
    }

    /**
     * @param int|float $start
     * @param int|float $end
     *
     * @return self
     */
    public static function halfOpen($start, $end)
    {
        return self::create($start, $end, IntervalType::halfOpen());
    }

    /**
     * @param int|float $start
     * @param int|float $end
     *
     * @return self
     */
    public static function open($start, $end)
    {
        return self::create($start, $end, IntervalType::open());
    }

    /**
     * Create interval from string.
     *
     * Example formats:
     *   [0, 5]
     *   (-3, 2]
     *   [-3, -1)
     *   (3, 9)
     *
     * Spaces are ignored in format.
     *
     * @param string $string
     *
     * @return self
     */
    public static function fromString($string)
    {
        if (!preg_match(self::REGEXP, $string, $match)) {
            throw InvalidIntervalFormatException::create('[N, N]', $string);
        }

        return self::create($match['start'], $match['end'], IntervalType::fromString($string));
    }

    /**
     * @param NumberInterval $interval
     *
     * @return bool
     */
    public function equal(NumberInterval $interval)
    {
        return $this->comparator->equal($interval);
    }

    /**
     * @param int|float $point
     *
     * @return bool
     */
    public function contains($point)
    {
        return $this->comparator->contains(new NumberIntervalPoint($point));
    }

    /**
     * @param NumberInterval $interval
     * @param bool $check_interval_type
     *
     * @return bool
     */
    public function intersects(NumberInterval $interval, $check_interval_type = true)
    {
        return $this->comparator->intersects($interval, $check_interval_type);
    }

    /**
     * @param NumberInterval $interval
     *
     * @return NumberInterval|null
     */
    public function intersection(NumberInterval $interval)
    {
        return $this->comparator->intersection($interval);
    }

    /**
     * The point is before the interval.
     *
     * @param int|float $point
     *
     * @return bool
     */
    public function before($point)
    {
        return $this->comparator->before(new NumberIntervalPoint($point));
    }

    /**
     * The point is after the interval.
     *
     * @param int|float $point
     *
     * @return bool
     */
    public function after($point)
    {
        return $this->comparator->after(new NumberIntervalPoint($point));
    }

    /**
     * @return IntervalType
     */
    public function type()
    {
        return $this->type;
    }

    /**
     * @return int|float
     */
    public function start()
    {
        return $this->start->value();
    }

    /**
     * @return int|float
     */
    public function end()
    {
        return $this->end->value();
    }

    /**
     * @return NumberIntervalPoint
     */
    public function startPoint()
    {
        return $this->start;
    }

    /**
     * @return NumberIntervalPoint
     */
    public function endPoint()
    {
        return $this->end;
    }

    /**
     * Returns a copy of this Interval with the start point altered.
     *
     * @param IntervalPointInterface|NumberIntervalPoint $start
     *
     * @return self
     */
    public function withStart(IntervalPointInterface $start)
    {
        return new self($start, $this->end, $this->type);

    }

    /**
     * Returns a copy of this Interval with the end point altered.
     *
     * @param IntervalPointInterface|NumberIntervalPoint $end
     *
     * @return self
     */
    public function withEnd(IntervalPointInterface $end)
    {
        return new self($this->start, $end, $this->type);

    }

    /**
     * Returns a copy of this Interval with the interval type altered.
     *
     * @param IntervalType $type
     *
     * @return self
     */
    public function withType(IntervalType $type)
    {
        return new self($this->start, $this->end, $type);
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return $this->type->getReadable($this);
    }
}


1		<?php
2
3		/**
4		* GpsLab component.
5		*
6		* @author Peter Gribanov <[email protected]>
7		* @copyright Copyright (c) 2016, Peter Gribanov
8		* @license http://opensource.org/licenses/MIT
9		*/
10
11		namespace GpsLab\Component\Interval\Number;
12
13		use GpsLab\Component\Interval\Exception\IncorrectIntervalException;
14		use GpsLab\Component\Interval\Exception\InvalidIntervalFormatException;
15		use GpsLab\Component\Interval\IntervalComparator;
16		use GpsLab\Component\Interval\ComparableIntervalInterface;
17		use GpsLab\Component\Interval\IntervalPointInterface;
18		use GpsLab\Component\Interval\IntervalType;
19
20	View Code Duplication	class NumberInterval implements ComparableIntervalInterface
		0 ignored issues – show Duplication introduced 2016-12-09 14:50 UTC by Report Bug Copy Issue Report This class seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
21		{
22		/**
23		* @var string
24		*/
25		const REGEXP = '/^
26		(?:\(\|\[) # start type char
27		\s*
28		(?<start>\-?\d+) # start point
29		\s,\s # separator
30		(?<end>\-?\d+) # end point
31		\s*
32		(?:\)\|\]) # end type char
33		$/x';
34
35		/**
36		* @var IntervalType
37		*/
38		private $type;
39
40		/**
41		* @var IntervalComparator
42		*/
43		private $comparator;
44
45		/**
46		* @var NumberIntervalPoint
47		*/
48		private $start;
49
50		/**
51		* @var NumberIntervalPoint
52		*/
53		private $end;
54
55		/**
56		* @param NumberIntervalPoint $start
57		* @param NumberIntervalPoint $end
58		* @param IntervalType $type
59		*/
60		private function __construct(NumberIntervalPoint $start, NumberIntervalPoint $end, IntervalType $type)
61		{
62		if ($start->gte($end)) {
63		throw IncorrectIntervalException::create();
64		}
65
66		$this->start = $start;
67		$this->end = $end;
68		$this->type = $type;
69		$this->comparator = new IntervalComparator($this);
70		}
71
72		/**
73		* @param int\|float $start
74		* @param int\|float $end
75		* @param IntervalType $type
76		*
77		* @return self
78		*/
79		public static function create($start, $end, IntervalType $type)
80		{
81		return new self(new NumberIntervalPoint($start), new NumberIntervalPoint($end), $type);
82		}
83
84		/**
85		* @param int\|float $start
86		* @param int\|float $end
87		*
88		* @return self
89		*/
90		public static function closed($start, $end)
91		{
92		return self::create($start, $end, IntervalType::closed());
93		}
94
95		/**
96		* @param int\|float $start
97		* @param int\|float $end
98		*
99		* @return self
100		*/
101		public static function halfClosed($start, $end)
102		{
103		return self::create($start, $end, IntervalType::halfClosed());
104		}
105
106		/**
107		* @param int\|float $start
108		* @param int\|float $end
109		*
110		* @return self
111		*/
112		public static function halfOpen($start, $end)
113		{
114		return self::create($start, $end, IntervalType::halfOpen());
115		}
116
117		/**
118		* @param int\|float $start
119		* @param int\|float $end
120		*
121		* @return self
122		*/
123		public static function open($start, $end)
124		{
125		return self::create($start, $end, IntervalType::open());
126		}
127
128		/**
129		* Create interval from string.
130		*
131		* Example formats:
132		* [0, 5]
133		* (-3, 2]
134		* [-3, -1)
135		* (3, 9)
136		*
137		* Spaces are ignored in format.
138		*
139		* @param string $string
140		*
141		* @return self
142		*/
143		public static function fromString($string)
144		{
145		if (!preg_match(self::REGEXP, $string, $match)) {
146		throw InvalidIntervalFormatException::create('[N, N]', $string);
147		}
148
149		return self::create($match['start'], $match['end'], IntervalType::fromString($string));
150		}
151
152		/**
153		* @param NumberInterval $interval
154		*
155		* @return bool
156		*/
157		public function equal(NumberInterval $interval)
158		{
159		return $this->comparator->equal($interval);
160		}
161
162		/**
163		* @param int\|float $point
164		*
165		* @return bool
166		*/
167		public function contains($point)
168		{
169		return $this->comparator->contains(new NumberIntervalPoint($point));
170		}
171
172		/**
173		* @param NumberInterval $interval
174		* @param bool $check_interval_type
175		*
176		* @return bool
177		*/
178		public function intersects(NumberInterval $interval, $check_interval_type = true)
179		{
180		return $this->comparator->intersects($interval, $check_interval_type);
181		}
182
183		/**
184		* @param NumberInterval $interval
185		*
186		* @return NumberInterval\|null
187		*/
188		public function intersection(NumberInterval $interval)
189		{
190		return $this->comparator->intersection($interval);
191		}
192
193		/**
194		* The point is before the interval.
195		*
196		* @param int\|float $point
197		*
198		* @return bool
199		*/
200		public function before($point)
201		{
202		return $this->comparator->before(new NumberIntervalPoint($point));
203		}
204
205		/**
206		* The point is after the interval.
207		*
208		* @param int\|float $point
209		*
210		* @return bool
211		*/
212		public function after($point)
213		{
214		return $this->comparator->after(new NumberIntervalPoint($point));
215		}
216
217		/**
218		* @return IntervalType
219		*/
220		public function type()
221		{
222		return $this->type;
223		}
224
225		/**
226		* @return int\|float
227		*/
228		public function start()
229		{
230		return $this->start->value();
231		}
232
233		/**
234		* @return int\|float
235		*/
236		public function end()
237		{
238		return $this->end->value();
239		}
240
241		/**
242		* @return NumberIntervalPoint
243		*/
244		public function startPoint()
245		{
246		return $this->start;
247		}
248
249		/**
250		* @return NumberIntervalPoint
251		*/
252		public function endPoint()
253		{
254		return $this->end;
255		}
256
257		/**
258		* Returns a copy of this Interval with the start point altered.
259		*
260		* @param IntervalPointInterface\|NumberIntervalPoint $start
261		*
262		* @return self
263		*/
264		public function withStart(IntervalPointInterface $start)
265		{
266		return new self($start, $this->end, $this->type);
		0 ignored issues – show Compatibility introduced 2016-12-12 11:21 UTC by Report Bug Copy Issue Report `$start` of type `object<GpsLab\Component\...IntervalPointInterface>` is not a sub-type of `object<GpsLab\Component\...er\NumberIntervalPoint>`. It seems like you assume a concrete implementation of the interface `GpsLab\Component\Interval\IntervalPointInterface` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
267		}
268
269		/**
270		* Returns a copy of this Interval with the end point altered.
271		*
272		* @param IntervalPointInterface\|NumberIntervalPoint $end
273		*
274		* @return self
275		*/
276		public function withEnd(IntervalPointInterface $end)
277		{
278		return new self($this->start, $end, $this->type);
		0 ignored issues – show Compatibility introduced 2016-12-12 11:21 UTC by Report Bug Copy Issue Report `$end` of type `object<GpsLab\Component\...IntervalPointInterface>` is not a sub-type of `object<GpsLab\Component\...er\NumberIntervalPoint>`. It seems like you assume a concrete implementation of the interface `GpsLab\Component\Interval\IntervalPointInterface` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
279		}
280
281		/**
282		* Returns a copy of this Interval with the interval type altered.
283		*
284		* @param IntervalType $type
285		*
286		* @return self
287		*/
288		public function withType(IntervalType $type)
289		{
290		return new self($this->start, $this->end, $type);
291		}
292
293		/**
294		* @return string
295		*/
296		public function __toString()
297		{
298		return $this->type->getReadable($this);
299		}
300		}
301

gpslab / interval

Push — master ( 8b40f4...1a4202 )

NumberInterval::equal() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like