RecurrenceRule - Code Metrics - Inspection of "Cleanup recurrence id" - markuspoerschke/iCal - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.x ( c7de71...29da9d )

by Markus

created 2016-04-26 17:24 UTC

RecurrenceRule B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	422
Duplicated Lines	7.11 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

34.83%

Importance

Changes	9
Bugs	4	Features	3

Metric	Value
wmc	47
c	9
b	4
f	3
lcom	1
cbo	1
dl	30
loc	422
ccs	31
cts	89
cp	0.3483
rs	8.439

19 Methods

Rating	Name	Duplication	Size	Complexity
A	getEscapedValue()	0	4	1
A	setCount()	0	6	1
A	getCount()	0	4	1
A	setUntil()	0	6	1
A	getUntil()	0	4	1
A	getFreq()	0	4	1
A	setInterval()	0	6	1
A	getInterval()	0	4	1
A	setWkst()	0	6	1
A	setByMonth()	0	10	4
A	setByWeekNo()	0	6	1
A	setByYearDay()	0	6	1
A	setByMonthDay()	0	6	1
A	setByDay()	0	6	1
A	setByHour()	10	10	4
A	setByMinute()	10	10	4
A	setBySecond()	10	10	4
F	buildParameterBag()	0	56	13
B	setFreq()	0	13	5

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like RecurrenceRule often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use RecurrenceRule, and based on these observations, apply Extract Interface, too.

<?php

/*
 * This file is part of the eluceo/iCal package.
 *
 * (c) Markus Poerschke <[email protected]>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Eluceo\iCal\Property\Event;

use Eluceo\iCal\Property\ValueInterface;
use Eluceo\iCal\ParameterBag;
use InvalidArgumentException;

/**
 * Implementation of Recurrence Rule.
 *
 * @see http://www.ietf.org/rfc/rfc2445.txt 3.3.10.  Recurrence Rule
 */
class RecurrenceRule implements ValueInterface
{
    const FREQ_YEARLY  = 'YEARLY';
    const FREQ_MONTHLY = 'MONTHLY';
    const FREQ_WEEKLY  = 'WEEKLY';
    const FREQ_DAILY   = 'DAILY';

    const WEEKDAY_SUNDAY    = 'SU';
    const WEEKDAY_MONDAY    = 'MO';
    const WEEKDAY_TUESDAY   = 'TU';
    const WEEKDAY_WEDNESDAY = 'WE';
    const WEEKDAY_THURSDAY  = 'TH';
    const WEEKDAY_FRIDAY    = 'FR';
    const WEEKDAY_SATURDAY  = 'SA';

    /**
     * The frequency of an Event.
     *
     * @var string
     */
    protected $freq = self::FREQ_YEARLY;

    /**
     * @var null|int
     */
    protected $interval = 1;

    /**
     * @var null|int
     */
    protected $count = null;

    /**
     * @var null|\DateTime
     */
    protected $until = null;

    /**
     * @var null|string
     */
    protected $wkst;

    /**
     * @var null|string
     */
    protected $byMonth;

    /**
     * @var null|string
     */
    protected $byWeekNo;

    /**
     * @var null|string
     */
    protected $byYearDay;

    /**
     * @var null|string
     */
    protected $byMonthDay;

    /**
     * @var null|string
     */
    protected $byDay;

    /**
     * @var null|string
     */
    protected $byHour;

    /**
     * @var null|string
     */
    protected $byMinute;

    /**
     * @var null|string
     */
    protected $bySecond;

    /**
     * Return the value of the Property as an escaped string.
     *
     * Escape values as per RFC 2445. See http://www.kanzaki.com/docs/ical/text.html
     *
     * @return string
     */
    public function getEscapedValue()
    {
        return $this->buildParameterBag()->toString();
    }

    /**
     * @return ParameterBag
     */
    protected function buildParameterBag()
    {
        $parameterBag = new ParameterBag();

        $parameterBag->setParam('FREQ', $this->freq);

        if (null !== $this->interval) {
            $parameterBag->setParam('INTERVAL', $this->interval);
        }

        if (null !== $this->count) {
            $parameterBag->setParam('COUNT', $this->count);
        }

        if (null != $this->until) {
            $parameterBag->setParam('UNTIL', $this->until->format('Ymd\THis\Z'));
        }

        if (null !== $this->wkst) {
            $parameterBag->setParam('WKST', $this->wkst);
        }

        if (null !== $this->byMonth) {
            $parameterBag->setParam('BYMONTH', $this->byMonth);
        }

        if (null !== $this->byWeekNo) {
            $parameterBag->setParam('BYWEEKNO', $this->byWeekNo);
        }

        if (null !== $this->byYearDay) {
            $parameterBag->setParam('BYYEARDAY', $this->byYearDay);
        }

        if (null !== $this->byMonthDay) {
            $parameterBag->setParam('BYMONTHDAY', $this->byMonthDay);
        }

        if (null !== $this->byDay) {
            $parameterBag->setParam('BYDAY', $this->byDay);
        }

        if (null !== $this->byHour) {
            $parameterBag->setParam('BYHOUR', $this->byHour);
        }

        if (null !== $this->byMinute) {
            $parameterBag->setParam('BYMINUTE', $this->byMinute);
        }

        if (null !== $this->bySecond) {
            $parameterBag->setParam('BYSECOND', $this->bySecond);
        }

        return $parameterBag;
    }

    /**
     * @param int|null $count
     *
     * @return $this
     */
    public function setCount($count)
    {
        $this->count = $count;

        return $this;
    }

    /**
     * @return int|null
     */
    public function getCount()
    {
        return $this->count;
    }

    /**
     * @param \DateTime|null $until
     *
     * @return $this
     */
    public function setUntil(\DateTime $until = null)
    {
        $this->until = $until;

        return $this;
    }

    /**
     * @return \DateTime|null
     */
    public function getUntil()
    {
        return $this->until;
    }

    /**
     * The FREQ rule part identifies the type of recurrence rule.  This
     * rule part MUST be specified in the recurrence rule.  Valid values
     * include.
     *
     * SECONDLY, to specify repeating events based on an interval of a second or more;
     * MINUTELY, to specify repeating events based on an interval of a minute or more;
     * HOURLY, to specify repeating events based on an interval of an hour or more;
     * DAILY, to specify repeating events based on an interval of a day or more;
     * WEEKLY, to specify repeating events based on an interval of a week or more;
     * MONTHLY, to specify repeating events based on an interval of a month or more;
     * YEARLY, to specify repeating events based on an interval of a year or more.
     *
     * @param string $freq
     *
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function setFreq($freq)
    {
        if (self::FREQ_YEARLY === $freq || self::FREQ_MONTHLY === $freq
            || self::FREQ_WEEKLY === $freq
            || self::FREQ_DAILY === $freq
        ) {
            $this->freq = $freq;
        } else {
            throw new \InvalidArgumentException("The Frequency {$freq} is not supported.");
        }

        return $this;
    }

    /**
     * @return string
     */
    public function getFreq()
    {
        return $this->freq;
    }

    /**
     * The INTERVAL rule part contains a positive integer representing at
     * which intervals the recurrence rule repeats.
     *
     * @param int|null $interval
     *
     * @return $this
     */
    public function setInterval($interval)
    {
        $this->interval = $interval;

        return $this;
    }

    /**
     * @return int|null
     */
    public function getInterval()
    {
        return $this->interval;
    }

    /**
     * The WKST rule part specifies the day on which the workweek starts.
     * Valid values are MO, TU, WE, TH, FR, SA, and SU.
     *
     * @param string $value
     *
     * @return $this
     */
    public function setWkst($value)
    {
        $this->wkst = $value;

        return $this;
    }

    /**
     * The BYMONTH rule part specifies a COMMA-separated list of months of the year.
     * Valid values are 1 to 12.
     *
     * @param int $month
     *
     * @throws InvalidArgumentException
     *
     * @return $this
     */
    public function setByMonth($month)
    {
        if (!is_integer($month) || $month < 0 || $month > 12) {
            throw new InvalidArgumentException('Invalid value for BYMONTH');
        }

        $this->byMonth = $month;


        return $this;
    }

    /**
     * The BYWEEKNO rule part specifies a COMMA-separated list of ordinals specifying weeks of the year.
     * Valid values are 1 to 53 or -53 to -1.
     *
     * @param int $value
     *
     * @return $this
     */
    public function setByWeekNo($value)
    {
        $this->byWeekNo = $value;


        return $this;
    }

    /**
     * The BYYEARDAY rule part specifies a COMMA-separated list of days of the year.
     * Valid values are 1 to 366 or -366 to -1.
     *
     * @param int $day
     *
     * @return $this
     */
    public function setByYearDay($day)
    {
        $this->byYearDay = $day;


        return $this;
    }

    /**
     * The BYMONTHDAY rule part specifies a COMMA-separated list of days of the month.
     * Valid values are 1 to 31 or -31 to -1.
     *
     * @param int $day
     *
     * @return $this
     */
    public function setByMonthDay($day)
    {
        $this->byMonthDay = $day;


        return $this;
    }

    /**
     * The BYDAY rule part specifies a COMMA-separated list of days of the week;.
     *
     * SU indicates Sunday; MO indicates Monday; TU indicates Tuesday;
     * WE indicates Wednesday; TH indicates Thursday; FR indicates Friday; and SA indicates Saturday.
     *
     * Each BYDAY value can also be preceded by a positive (+n) or negative (-n) integer.
     * If present, this indicates the nth occurrence of a specific day within the MONTHLY or YEARLY "RRULE".
     *
     * @param string $day
     *
     * @return $this
     */
    public function setByDay($day)
    {
        $this->byDay = $day;

        return $this;
    }

    /**
     * The BYHOUR rule part specifies a COMMA-separated list of hours of the day.
     * Valid values are 0 to 23.
     *
     * @param int $value
     *
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function setByHour($value)

    {
        if (!is_integer($value) || $value < 0 || $value > 23) {
            throw new \InvalidArgumentException('Invalid value for BYHOUR');
        }

        $this->byHour = $value;


        return $this;
    }

    /**
     * The BYMINUTE rule part specifies a COMMA-separated list of minutes within an hour.
     * Valid values are 0 to 59.
     *
     * @param int $value
     *
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function setByMinute($value)

    {
        if (!is_integer($value) || $value < 0 || $value > 59) {
            throw new \InvalidArgumentException('Invalid value for BYMINUTE');
        }

        $this->byMinute = $value;


        return $this;
    }

    /**
     * The BYSECOND rule part specifies a COMMA-separated list of seconds within a minute.
     * Valid values are 0 to 60.
     *
     * @param int $value
     *
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function setBySecond($value)

    {
        if (!is_integer($value) || $value < 0 || $value > 60) {
            throw new \InvalidArgumentException('Invalid value for BYSECOND');
        }

        $this->bySecond = $value;


        return $this;
    }
}


1			<?php
2
3			/*
4			* This file is part of the eluceo/iCal package.
5			*
6			* (c) Markus Poerschke <[email protected]>
7			*
8			* This source file is subject to the MIT license that is bundled
9			* with this source code in the file LICENSE.
10			*/
11
12			namespace Eluceo\iCal\Property\Event;
13
14			use Eluceo\iCal\Property\ValueInterface;
15			use Eluceo\iCal\ParameterBag;
16			use InvalidArgumentException;
17
18			/**
19			* Implementation of Recurrence Rule.
20			*
21			* @see http://www.ietf.org/rfc/rfc2445.txt 3.3.10. Recurrence Rule
22			*/
23			class RecurrenceRule implements ValueInterface
24			{
25			const FREQ_YEARLY = 'YEARLY';
26			const FREQ_MONTHLY = 'MONTHLY';
27			const FREQ_WEEKLY = 'WEEKLY';
28			const FREQ_DAILY = 'DAILY';
29
30			const WEEKDAY_SUNDAY = 'SU';
31			const WEEKDAY_MONDAY = 'MO';
32			const WEEKDAY_TUESDAY = 'TU';
33			const WEEKDAY_WEDNESDAY = 'WE';
34			const WEEKDAY_THURSDAY = 'TH';
35			const WEEKDAY_FRIDAY = 'FR';
36			const WEEKDAY_SATURDAY = 'SA';
37
38			/**
39			* The frequency of an Event.
40			*
41			* @var string
42			*/
43			protected $freq = self::FREQ_YEARLY;
44
45			/**
46			* @var null\|int
47			*/
48			protected $interval = 1;
49
50			/**
51			* @var null\|int
52			*/
53			protected $count = null;
54
55			/**
56			* @var null\|\DateTime
57			*/
58			protected $until = null;
59
60			/**
61			* @var null\|string
62			*/
63			protected $wkst;
64
65			/**
66			* @var null\|string
67			*/
68			protected $byMonth;
69
70			/**
71			* @var null\|string
72			*/
73			protected $byWeekNo;
74
75			/**
76			* @var null\|string
77			*/
78			protected $byYearDay;
79
80			/**
81			* @var null\|string
82			*/
83			protected $byMonthDay;
84
85			/**
86			* @var null\|string
87			*/
88			protected $byDay;
89
90			/**
91			* @var null\|string
92			*/
93			protected $byHour;
94
95			/**
96			* @var null\|string
97			*/
98			protected $byMinute;
99
100			/**
101			* @var null\|string
102			*/
103			protected $bySecond;
104
105			/**
106			* Return the value of the Property as an escaped string.
107			*
108			* Escape values as per RFC 2445. See http://www.kanzaki.com/docs/ical/text.html
109			*
110			* @return string
111			*/
112	1		public function getEscapedValue()
113			{
114	1		return $this->buildParameterBag()->toString();
115			}
116
117			/**
118			* @return ParameterBag
119			*/
120	1		protected function buildParameterBag()
121			{
122	1		$parameterBag = new ParameterBag();
123
124	1		$parameterBag->setParam('FREQ', $this->freq);
125
126	1		if (null !== $this->interval) {
127			$parameterBag->setParam('INTERVAL', $this->interval);
128			}
129
130	1		if (null !== $this->count) {
131			$parameterBag->setParam('COUNT', $this->count);
132			}
133
134	1		if (null != $this->until) {
135	1		$parameterBag->setParam('UNTIL', $this->until->format('Ymd\THis\Z'));
136			}
137
138	1		if (null !== $this->wkst) {
139			$parameterBag->setParam('WKST', $this->wkst);
140			}
141
142	1		if (null !== $this->byMonth) {
143			$parameterBag->setParam('BYMONTH', $this->byMonth);
144			}
145
146	1		if (null !== $this->byWeekNo) {
147			$parameterBag->setParam('BYWEEKNO', $this->byWeekNo);
148			}
149
150	1		if (null !== $this->byYearDay) {
151			$parameterBag->setParam('BYYEARDAY', $this->byYearDay);
152			}
153
154	1		if (null !== $this->byMonthDay) {
155			$parameterBag->setParam('BYMONTHDAY', $this->byMonthDay);
156			}
157
158	1		if (null !== $this->byDay) {
159			$parameterBag->setParam('BYDAY', $this->byDay);
160			}
161
162	1		if (null !== $this->byHour) {
163			$parameterBag->setParam('BYHOUR', $this->byHour);
164			}
165
166	1		if (null !== $this->byMinute) {
167			$parameterBag->setParam('BYMINUTE', $this->byMinute);
168			}
169
170	1		if (null !== $this->bySecond) {
171			$parameterBag->setParam('BYSECOND', $this->bySecond);
172			}
173
174	1		return $parameterBag;
175			}
176
177			/**
178			* @param int\|null $count
179			*
180			* @return $this
181			*/
182			public function setCount($count)
183			{
184			$this->count = $count;
185
186			return $this;
187			}
188
189			/**
190			* @return int\|null
191			*/
192			public function getCount()
193			{
194			return $this->count;
195			}
196
197			/**
198			* @param \DateTime\|null $until
199			*
200			* @return $this
201			*/
202	1		public function setUntil(\DateTime $until = null)
203			{
204	1		$this->until = $until;
205
206	1		return $this;
207			}
208
209			/**
210			* @return \DateTime\|null
211			*/
212			public function getUntil()
213			{
214			return $this->until;
215			}
216
217			/**
218			* The FREQ rule part identifies the type of recurrence rule. This
219			* rule part MUST be specified in the recurrence rule. Valid values
220			* include.
221			*
222			* SECONDLY, to specify repeating events based on an interval of a second or more;
223			* MINUTELY, to specify repeating events based on an interval of a minute or more;
224			* HOURLY, to specify repeating events based on an interval of an hour or more;
225			* DAILY, to specify repeating events based on an interval of a day or more;
226			* WEEKLY, to specify repeating events based on an interval of a week or more;
227			* MONTHLY, to specify repeating events based on an interval of a month or more;
228			* YEARLY, to specify repeating events based on an interval of a year or more.
229			*
230			* @param string $freq
231			*
232			* @return $this
233			*
234			* @throws \InvalidArgumentException
235			*/
236	1		public function setFreq($freq)
237			{
238	1		if (self::FREQ_YEARLY === $freq \|\| self::FREQ_MONTHLY === $freq
239	1		\|\| self::FREQ_WEEKLY === $freq
240	1		\|\| self::FREQ_DAILY === $freq
241			) {
242	1		$this->freq = $freq;
243			} else {
244			throw new \InvalidArgumentException("The Frequency {$freq} is not supported.");
245			}
246
247	1		return $this;
248			}
249
250			/**
251			* @return string
252			*/
253			public function getFreq()
254			{
255			return $this->freq;
256			}
257
258			/**
259			* The INTERVAL rule part contains a positive integer representing at
260			* which intervals the recurrence rule repeats.
261			*
262			* @param int\|null $interval
263			*
264			* @return $this
265			*/
266	1		public function setInterval($interval)
267			{
268	1		$this->interval = $interval;
269
270	1		return $this;
271			}
272
273			/**
274			* @return int\|null
275			*/
276			public function getInterval()
277			{
278			return $this->interval;
279			}
280
281			/**
282			* The WKST rule part specifies the day on which the workweek starts.
283			* Valid values are MO, TU, WE, TH, FR, SA, and SU.
284			*
285			* @param string $value
286			*
287			* @return $this
288			*/
289			public function setWkst($value)
290			{
291			$this->wkst = $value;
292
293			return $this;
294			}
295
296			/**
297			* The BYMONTH rule part specifies a COMMA-separated list of months of the year.
298			* Valid values are 1 to 12.
299			*
300			* @param int $month
301			*
302			* @throws InvalidArgumentException
303			*
304			* @return $this
305			*/
306			public function setByMonth($month)
307			{
308			if (!is_integer($month) \|\| $month < 0 \|\| $month > 12) {
309			throw new InvalidArgumentException('Invalid value for BYMONTH');
310			}
311
312			$this->byMonth = $month;
			0 ignored issues – show Documentation Bug introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report It seems like `$month` of type `integer` is incompatible with the declared type `null\|string` of property `$byMonth`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
313
314			return $this;
315			}
316
317			/**
318			* The BYWEEKNO rule part specifies a COMMA-separated list of ordinals specifying weeks of the year.
319			* Valid values are 1 to 53 or -53 to -1.
320			*
321			* @param int $value
322			*
323			* @return $this
324			*/
325			public function setByWeekNo($value)
326			{
327			$this->byWeekNo = $value;
			0 ignored issues – show Documentation Bug introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report It seems like `$value` of type `integer` is incompatible with the declared type `null\|string` of property `$byWeekNo`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
328
329			return $this;
330			}
331
332			/**
333			* The BYYEARDAY rule part specifies a COMMA-separated list of days of the year.
334			* Valid values are 1 to 366 or -366 to -1.
335			*
336			* @param int $day
337			*
338			* @return $this
339			*/
340			public function setByYearDay($day)
341			{
342			$this->byYearDay = $day;
			0 ignored issues – show Documentation Bug introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report It seems like `$day` of type `integer` is incompatible with the declared type `null\|string` of property `$byYearDay`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
343
344			return $this;
345			}
346
347			/**
348			* The BYMONTHDAY rule part specifies a COMMA-separated list of days of the month.
349			* Valid values are 1 to 31 or -31 to -1.
350			*
351			* @param int $day
352			*
353			* @return $this
354			*/
355			public function setByMonthDay($day)
356			{
357			$this->byMonthDay = $day;
			0 ignored issues – show Documentation Bug introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report It seems like `$day` of type `integer` is incompatible with the declared type `null\|string` of property `$byMonthDay`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
358
359			return $this;
360			}
361
362			/**
363			* The BYDAY rule part specifies a COMMA-separated list of days of the week;.
364			*
365			* SU indicates Sunday; MO indicates Monday; TU indicates Tuesday;
366			* WE indicates Wednesday; TH indicates Thursday; FR indicates Friday; and SA indicates Saturday.
367			*
368			* Each BYDAY value can also be preceded by a positive (+n) or negative (-n) integer.
369			* If present, this indicates the nth occurrence of a specific day within the MONTHLY or YEARLY "RRULE".
370			*
371			* @param string $day
372			*
373			* @return $this
374			*/
375			public function setByDay($day)
376			{
377			$this->byDay = $day;
378
379			return $this;
380			}
381
382			/**
383			* The BYHOUR rule part specifies a COMMA-separated list of hours of the day.
384			* Valid values are 0 to 23.
385			*
386			* @param int $value
387			*
388			* @return $this
389			*
390			* @throws \InvalidArgumentException
391			*/
392		View Code Duplication	public function setByHour($value)
			0 ignored issues – show Duplication introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report This method 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...
393			{
394			if (!is_integer($value) \|\| $value < 0 \|\| $value > 23) {
395			throw new \InvalidArgumentException('Invalid value for BYHOUR');
396			}
397
398			$this->byHour = $value;
			0 ignored issues – show Documentation Bug introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report It seems like `$value` of type `integer` is incompatible with the declared type `null\|string` of property `$byHour`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
399
400			return $this;
401			}
402
403			/**
404			* The BYMINUTE rule part specifies a COMMA-separated list of minutes within an hour.
405			* Valid values are 0 to 59.
406			*
407			* @param int $value
408			*
409			* @return $this
410			*
411			* @throws \InvalidArgumentException
412			*/
413		View Code Duplication	public function setByMinute($value)
			0 ignored issues – show Duplication introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report This method 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...
414			{
415			if (!is_integer($value) \|\| $value < 0 \|\| $value > 59) {
416			throw new \InvalidArgumentException('Invalid value for BYMINUTE');
417			}
418
419			$this->byMinute = $value;
			0 ignored issues – show Documentation Bug introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report It seems like `$value` of type `integer` is incompatible with the declared type `null\|string` of property `$byMinute`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
420
421			return $this;
422			}
423
424			/**
425			* The BYSECOND rule part specifies a COMMA-separated list of seconds within a minute.
426			* Valid values are 0 to 60.
427			*
428			* @param int $value
429			*
430			* @return $this
431			*
432			* @throws \InvalidArgumentException
433			*/
434		View Code Duplication	public function setBySecond($value)
			0 ignored issues – show Duplication introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report This method 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...
435			{
436			if (!is_integer($value) \|\| $value < 0 \|\| $value > 60) {
437			throw new \InvalidArgumentException('Invalid value for BYSECOND');
438			}
439
440			$this->bySecond = $value;
			0 ignored issues – show Documentation Bug introduced 2015-12-04 09:21 UTC by Report Bug Copy Issue Report It seems like `$value` of type `integer` is incompatible with the declared type `null\|string` of property `$bySecond`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
441
442			return $this;
443			}
444			}
445

markuspoerschke / iCal