YearInterval::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

YearInterval::equal() A

↳ Parent: YearInterval

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
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\Year;

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 YearInterval implements ComparableIntervalInterface
{
    /**
     * @var string
     */
    const REGEXP = '/^
        (?:\(|\[)       # start type char
        \s*
        (?<start>\d{4}) # start point
        \s*,\s*         # separator
        (?<end>\d{4})   # end point
        \s*
        (?:\)|\])       # end type char
    $/x';

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

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

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

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

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

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

    /**
     * @param \DateTime $start
     * @param \DateTime $end
     * @param IntervalType $type
     *
     * @return self
     */
    public static function create(\DateTime $start, \DateTime $end, IntervalType $type)
    {
        return new self(new YearIntervalPoint($start), new YearIntervalPoint($end), $type);
    }

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

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

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

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

    /**
     * Create interval from string.
     *
     * Example formats for all interval types:
     *   [2016, 2017]
     *   (2015, 2016]
     *   [2014, 2015)
     *   (2013, 2014)
     *
     * 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('[YYYY, YYYY]', $string);
        }

        return self::create(
            (new \DateTime())->setDate($match['start'], 1, 1),
            (new \DateTime())->setDate($match['end'], 1, 1),
            IntervalType::fromString($string)
        );
    }

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

    /**
     * @param \DateTime $point
     *
     * @return bool
     */
    public function contains(\DateTime $point)
    {
        return $this->comparator->contains(new YearIntervalPoint($point));
    }

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

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

    /**
     * The point is before the interval.
     *
     * @param \DateTime $point
     *
     * @return bool
     */
    public function before(\DateTime $point)
    {
        return $this->comparator->before(new YearIntervalPoint($point));
    }

    /**
     * The point is after the interval.
     *
     * @param \DateTime $point
     *
     * @return bool
     */
    public function after(\DateTime $point)
    {
        return $this->comparator->after(new YearIntervalPoint($point));
    }

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

    /**
     * @return \DateTime
     */
    public function start()
    {
        return $this->start->value();
    }

    /**
     * @return \DateTime
     */
    public function end()
    {
        return $this->end->value();
    }

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

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

    /**
     * Returns a copy of this Interval with the start point altered.
     *
     * @param IntervalPointInterface|YearIntervalPoint $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|YearIntervalPoint $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\Year;
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			class YearInterval implements ComparableIntervalInterface
21			{
22			/**
23			* @var string
24			*/
25			const REGEXP = '/^
26			(?:\(\|\[) # start type char
27			\s*
28			(?<start>\d{4}) # start point
29			\s,\s # separator
30			(?<end>\d{4}) # 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 YearIntervalPoint
47			*/
48			private $start;
49
50			/**
51			* @var YearIntervalPoint
52			*/
53			private $end;
54
55			/**
56			* @param YearIntervalPoint $start
57			* @param YearIntervalPoint $end
58			* @param IntervalType $type
59			*/
60			private function __construct(YearIntervalPoint $start, YearIntervalPoint $end, IntervalType $type)
61			{
62			if ($start->gte($end)) {
63			throw IncorrectIntervalException::create();
64			}
65
66			$this->type = $type;
67			$this->start = $start;
68			$this->end = $end;
69			$this->comparator = new IntervalComparator($this);
70			}
71
72			/**
73			* @param \DateTime $start
74			* @param \DateTime $end
75			* @param IntervalType $type
76			*
77			* @return self
78			*/
79			public static function create(\DateTime $start, \DateTime $end, IntervalType $type)
80			{
81			return new self(new YearIntervalPoint($start), new YearIntervalPoint($end), $type);
82			}
83
84			/**
85			* @param \DateTime $start
86			* @param \DateTime $end
87			*
88			* @return self
89			*/
90			public static function closed(\DateTime $start, \DateTime $end)
91			{
92			return static::create($start, $end, IntervalType::closed());
93			}
94
95			/**
96			* @param \DateTime $start
97			* @param \DateTime $end
98			*
99			* @return self
100			*/
101			public static function halfClosed(\DateTime $start, \DateTime $end)
102			{
103			return static::create($start, $end, IntervalType::halfClosed());
104			}
105
106			/**
107			* @param \DateTime $start
108			* @param \DateTime $end
109			*
110			* @return self
111			*/
112			public static function halfOpen(\DateTime $start, \DateTime $end)
113			{
114			return static::create($start, $end, IntervalType::halfOpen());
115			}
116
117			/**
118			* @param \DateTime $start
119			* @param \DateTime $end
120			*
121			* @return self
122			*/
123			public static function open(\DateTime $start, \DateTime $end)
124			{
125			return static::create($start, $end, IntervalType::open());
126			}
127
128			/**
129			* Create interval from string.
130			*
131			* Example formats for all interval types:
132			* [2016, 2017]
133			* (2015, 2016]
134			* [2014, 2015)
135			* (2013, 2014)
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('[YYYY, YYYY]', $string);
147			}
148
149			return self::create(
150			(new \DateTime())->setDate($match['start'], 1, 1),
151			(new \DateTime())->setDate($match['end'], 1, 1),
152			IntervalType::fromString($string)
153			);
154			}
155
156			/**
157			* @param YearInterval $interval
158			*
159			* @return bool
160			*/
161			public function equal(YearInterval $interval)
162			{
163			return $this->comparator->equal($interval);
164			}
165
166			/**
167			* @param \DateTime $point
168			*
169			* @return bool
170			*/
171			public function contains(\DateTime $point)
172			{
173			return $this->comparator->contains(new YearIntervalPoint($point));
174			}
175
176			/**
177			* @param YearInterval $interval
178			* @param bool $check_interval_type
179			*
180			* @return bool
181			*/
182			public function intersects(YearInterval $interval, $check_interval_type = true)
183			{
184			return $this->comparator->intersects($interval, $check_interval_type);
185			}
186
187			/**
188			* @param YearInterval $interval
189			*
190			* @return YearInterval\|null
191			*/
192			public function intersection(YearInterval $interval)
193			{
194			return $this->comparator->intersection($interval);
195			}
196
197			/**
198			* The point is before the interval.
199			*
200			* @param \DateTime $point
201			*
202			* @return bool
203			*/
204			public function before(\DateTime $point)
205			{
206			return $this->comparator->before(new YearIntervalPoint($point));
207			}
208
209			/**
210			* The point is after the interval.
211			*
212			* @param \DateTime $point
213			*
214			* @return bool
215			*/
216			public function after(\DateTime $point)
217			{
218			return $this->comparator->after(new YearIntervalPoint($point));
219			}
220
221			/**
222			* @return IntervalType
223			*/
224			public function type()
225			{
226			return $this->type;
227			}
228
229			/**
230			* @return \DateTime
231			*/
232			public function start()
233			{
234			return $this->start->value();
235			}
236
237			/**
238			* @return \DateTime
239			*/
240			public function end()
241			{
242			return $this->end->value();
243			}
244
245			/**
246			* @return YearIntervalPoint
247			*/
248			public function startPoint()
249			{
250			return $this->start;
251			}
252
253			/**
254			* @return YearIntervalPoint
255			*/
256			public function endPoint()
257			{
258			return $this->end;
259			}
260
261			/**
262			* Returns a copy of this Interval with the start point altered.
263			*
264			* @param IntervalPointInterface\|YearIntervalPoint $start
265			*
266			* @return self
267			*/
268			public function withStart(IntervalPointInterface $start)
269			{
270			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\...Year\YearIntervalPoint>`. 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...
271			}
272
273			/**
274			* Returns a copy of this Interval with the end point altered.
275			*
276			* @param IntervalPointInterface\|YearIntervalPoint $end
277			*
278			* @return self
279			*/
280			public function withEnd(IntervalPointInterface $end)
281			{
282			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\...Year\YearIntervalPoint>`. 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...
283			}
284
285			/**
286			* Returns a copy of this Interval with the interval type altered.
287			*
288			* @param IntervalType $type
289			*
290			* @return self
291			*/
292			public function withType(IntervalType $type)
293			{
294			return new self($this->start, $this->end, $type);
295			}
296
297			/**
298			* @return string
299			*/
300			public function __toString()
301			{
302			return $this->type->getReadable($this);
303			}
304			}
305

gpslab / interval

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

YearInterval::equal() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like