DateInterval::after() - Code Metrics - Inspection of "create method MonthInterval::fromString()" - gpslab/interval - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( caad92...bf4c7a )

by Peter

created 2016-12-09 14:45 UTC

DateInterval::after() A

↳ Parent: DateInterval

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
rs	10
c	0
b	0
f	0
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\Date;

use GpsLab\Component\Interval\Exception\IncorrectIntervalException;
use GpsLab\Component\Interval\Exception\InvalidIntervalFormatException;
use GpsLab\Component\Interval\IntervalInterface;
use GpsLab\Component\Interval\IntervalType;

class DateInterval implements IntervalInterface

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

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

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

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

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

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

        $this->type = $type;
        $this->start = $start;
        $this->end = $end;
        $this->comparator = new DateIntervalComparator($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 DateIntervalPoint($start), new DateIntervalPoint($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-12-09, 2016-12-21]
     *   (2015-03-07, 2015-10-19]
     *   [2014-09-11, 2015-02-08)
     *   (2013-10-27, 2013-10-30)
     *
     * 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-MM-DD, YYYY-MM-DD]', $string);
        }

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

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

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

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

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

    /**
     * The point is after the interval
     *
     * @param \DateTime $point
     *
     * @return bool
     */
    public function after(\DateTime $point)
    {
        return $this->comparator->after(new DateIntervalPoint($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 DateIntervalPoint
     */
    public function startPoint()
    {
        return $this->start;
    }

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

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


1		<?php
2		/**
3		* GpsLab component.
4		*
5		* @author Peter Gribanov <[email protected]>
6		* @copyright Copyright (c) 2016, Peter Gribanov
7		* @license http://opensource.org/licenses/MIT
8		*/
9
10		namespace GpsLab\Component\Interval\Date;
11
12		use GpsLab\Component\Interval\Exception\IncorrectIntervalException;
13		use GpsLab\Component\Interval\Exception\InvalidIntervalFormatException;
14		use GpsLab\Component\Interval\IntervalInterface;
15		use GpsLab\Component\Interval\IntervalType;
16
17	View Code Duplication	class DateInterval implements IntervalInterface
		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...
18		{
19		/**
20		* @var string
21		*/
22		const REGEXP = '/^
23		(?:\(\|\[) # start type char
24		\s*
25		(?<start>\d{4}-\d{2}-\d{2}) # start point
26		\s,\s # separator
27		(?<end>\d{4}-\d{2}-\d{2}) # end point
28		\s*
29		(?:\)\|\]) # end type char
30		$/x';
31
32		/**
33		* @var IntervalType
34		*/
35		private $type;
36
37		/**
38		* @var DateIntervalComparator
39		*/
40		private $comparator;
41
42		/**
43		* @var DateIntervalPoint
44		*/
45		private $start;
46
47		/**
48		* @var DateIntervalPoint
49		*/
50		private $end;
51
52		/**
53		* @param DateIntervalPoint $start
54		* @param DateIntervalPoint $end
55		* @param IntervalType $type
56		*/
57		private function __construct(DateIntervalPoint $start, DateIntervalPoint $end, IntervalType $type)
58		{
59		if ($start->gte($end)) {
60		throw IncorrectIntervalException::create();
61		}
62
63		$this->type = $type;
64		$this->start = $start;
65		$this->end = $end;
66		$this->comparator = new DateIntervalComparator($this);
67		}
68
69		/**
70		* @param \DateTime $start
71		* @param \DateTime $end
72		* @param IntervalType $type
73		*
74		* @return self
75		*/
76		public static function create(\DateTime $start, \DateTime $end, IntervalType $type)
77		{
78		return new self(new DateIntervalPoint($start), new DateIntervalPoint($end), $type);
79		}
80
81		/**
82		* @param \DateTime $start
83		* @param \DateTime $end
84		*
85		* @return self
86		*/
87		public static function closed(\DateTime $start, \DateTime $end)
88		{
89		return static::create($start, $end, IntervalType::closed());
90		}
91
92		/**
93		* @param \DateTime $start
94		* @param \DateTime $end
95		*
96		* @return self
97		*/
98		public static function halfClosed(\DateTime $start, \DateTime $end)
99		{
100		return static::create($start, $end, IntervalType::halfClosed());
101		}
102
103		/**
104		* @param \DateTime $start
105		* @param \DateTime $end
106		*
107		* @return self
108		*/
109		public static function halfOpen(\DateTime $start, \DateTime $end)
110		{
111		return static::create($start, $end, IntervalType::halfOpen());
112		}
113
114		/**
115		* @param \DateTime $start
116		* @param \DateTime $end
117		*
118		* @return self
119		*/
120		public static function open(\DateTime $start, \DateTime $end)
121		{
122		return static::create($start, $end, IntervalType::open());
123		}
124
125		/**
126		* Create interval from string.
127		*
128		* Example formats for all interval types:
129		* [2016-12-09, 2016-12-21]
130		* (2015-03-07, 2015-10-19]
131		* [2014-09-11, 2015-02-08)
132		* (2013-10-27, 2013-10-30)
133		*
134		* Spaces are ignored in format.
135		*
136		* @param string $string
137		*
138		* @return self
139		*/
140		public static function fromString($string)
141		{
142		if (!preg_match(self::REGEXP, $string, $match)) {
143		throw InvalidIntervalFormatException::create('[YYYY-MM-DD, YYYY-MM-DD]', $string);
144		}
145
146		return self::create(
147		new \DateTime($match['start']),
148		new \DateTime($match['end']),
149		IntervalType::fromString($string)
150		);
151		}
152
153		/**
154		* @param \DateTime $point
155		*
156		* @return bool
157		*/
158		public function contains(\DateTime $point)
159		{
160		return $this->comparator->contains(new DateIntervalPoint($point));
161		}
162
163		/**
164		* @param DateInterval $interval
165		* @param bool $check_interval_type
166		*
167		* @return bool
168		*/
169		public function intersect(DateInterval $interval, $check_interval_type = true)
170		{
171		return $this->comparator->intersect($interval, $check_interval_type);
172		}
173
174		/**
175		* @param DateInterval $interval
176		*
177		* @return DateInterval\|null
178		*/
179		public function intersectInterval(DateInterval $interval)
180		{
181		return $this->comparator->intersectInterval($interval);
182		}
183
184		/**
185		* The point is before the interval
186		*
187		* @param \DateTime $point
188		*
189		* @return bool
190		*/
191		public function before(\DateTime $point)
192		{
193		return $this->comparator->before(new DateIntervalPoint($point));
194		}
195
196		/**
197		* The point is after the interval
198		*
199		* @param \DateTime $point
200		*
201		* @return bool
202		*/
203		public function after(\DateTime $point)
204		{
205		return $this->comparator->after(new DateIntervalPoint($point));
206		}
207
208		/**
209		* @return IntervalType
210		*/
211		public function type()
212		{
213		return $this->type;
214		}
215
216		/**
217		* @return \DateTime
218		*/
219		public function start()
220		{
221		return $this->start->value();
222		}
223
224		/**
225		* @return \DateTime
226		*/
227		public function end()
228		{
229		return $this->end->value();
230		}
231
232		/**
233		* @return DateIntervalPoint
234		*/
235		public function startPoint()
236		{
237		return $this->start;
238		}
239
240		/**
241		* @return DateIntervalPoint
242		*/
243		public function endPoint()
244		{
245		return $this->end;
246		}
247
248		/**
249		* @return string
250		*/
251		public function __toString()
252		{
253		return $this->type->getReadable($this);
254		}
255		}
256

gpslab / interval

Push — master ( caad92...bf4c7a )

DateInterval::after() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like