YearInterval::closed() - Code Metrics - Inspection of "Merge remote-tracking branch 'origin/master'" - gpslab/interval - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ef97c3...705b1d )

by Peter

created 2016-12-12 16:30 UTC

YearInterval::closed() A

↳ Parent: YearInterval

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?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
     *
     * @return bool
     */
    public function intersects(YearInterval $interval)
    {
        return $this->comparator->intersects($interval);
    }

    /**
     * @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	2	private function __construct(YearIntervalPoint $start, YearIntervalPoint $end, IntervalType $type)
61		{
62	2	if ($start->gte($end)) {
63		throw IncorrectIntervalException::create();
64		}
65
66	2	$this->type = $type;
67	2	$this->start = $start;
68	2	$this->end = $end;
69	2	$this->comparator = new IntervalComparator($this);
70	2	}
71
72		/**
73		* @param \DateTime $start
74		* @param \DateTime $end
75		* @param IntervalType $type
76		*
77		* @return self
78		*/
79	2	public static function create(\DateTime $start, \DateTime $end, IntervalType $type)
80		{
81	2	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	2	public static function fromString($string)
144		{
145	2	if (!preg_match(self::REGEXP, $string, $match)) {
146		throw InvalidIntervalFormatException::create('[YYYY, YYYY]', $string);
147		}
148
149	2	return self::create(
150	2	(new \DateTime())->setDate($match['start'], 1, 1),
151	2	(new \DateTime())->setDate($match['end'], 1, 1),
152	2	IntervalType::fromString($string)
153	2	);
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		*
179		* @return bool
180		*/
181		public function intersects(YearInterval $interval)
182		{
183		return $this->comparator->intersects($interval);
184		}
185
186		/**
187		* @param YearInterval $interval
188		*
189		* @return YearInterval\|null
190		*/
191		public function intersection(YearInterval $interval)
192		{
193		return $this->comparator->intersection($interval);
194		}
195
196		/**
197		* The point is before the interval.
198		*
199		* @param \DateTime $point
200		*
201		* @return bool
202		*/
203		public function before(\DateTime $point)
204		{
205		return $this->comparator->before(new YearIntervalPoint($point));
206		}
207
208		/**
209		* The point is after the interval.
210		*
211		* @param \DateTime $point
212		*
213		* @return bool
214		*/
215		public function after(\DateTime $point)
216		{
217		return $this->comparator->after(new YearIntervalPoint($point));
218		}
219
220		/**
221		* @return IntervalType
222		*/
223		public function type()
224		{
225		return $this->type;
226		}
227
228		/**
229		* @return \DateTime
230		*/
231		public function start()
232		{
233		return $this->start->value();
234		}
235
236		/**
237		* @return \DateTime
238		*/
239		public function end()
240		{
241		return $this->end->value();
242		}
243
244		/**
245		* @return YearIntervalPoint
246		*/
247	1	public function startPoint()
248		{
249	1	return $this->start;
250		}
251
252		/**
253		* @return YearIntervalPoint
254		*/
255	1	public function endPoint()
256		{
257	1	return $this->end;
258		}
259
260		/**
261		* Returns a copy of this Interval with the start point altered.
262		*
263		* @param IntervalPointInterface\|YearIntervalPoint $start
264		*
265		* @return self
266		*/
267		public function withStart(IntervalPointInterface $start)
268		{
269		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...
270		}
271
272		/**
273		* Returns a copy of this Interval with the end point altered.
274		*
275		* @param IntervalPointInterface\|YearIntervalPoint $end
276		*
277		* @return self
278		*/
279		public function withEnd(IntervalPointInterface $end)
280		{
281		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...
282		}
283
284		/**
285		* Returns a copy of this Interval with the interval type altered.
286		*
287		* @param IntervalType $type
288		*
289		* @return self
290		*/
291		public function withType(IntervalType $type)
292		{
293		return new self($this->start, $this->end, $type);
294		}
295
296		/**
297		* @return string
298		*/
299	1	public function __toString()
300		{
301	1	return $this->type->getReadable($this);
302		}
303		}
304

gpslab / interval

Push — master ( ef97c3...705b1d )

YearInterval::closed() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like