BaseEvent::between() - Code Metrics - Inspection of "add callback event type" - clansman-nl/scheduling - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#1)

by Sebastiaan

created 2017-06-09 13:40 UTC

BaseEvent::between() A

↳ Parent: BaseEvent

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	2

<?php

namespace Basebuilder\Scheduling\Event;

use Basebuilder\Scheduling\Event;
use Carbon\Carbon;
use Cron\CronExpression;
use Webmozart\Assert\Assert;

abstract class BaseEvent implements Event
{
    /**
     * The cron expression representing the event's frequency.
     * @var string
     */
    protected $expression = '* * * * * *';

    /**
     * The timezone the date should be evaluated on.
     * @var \DateTimeZone|string
     */
    protected $timezone;

    /**
     * The array of filter callbacks. These must return true
     * @var callable[]
     */
    protected $filters = [];

    /**
     * The array of callbacks to be run before the event is started.
     * @var callable[]
     */
    protected $beforeCallbacks = [];

    /**
     * The array of callbacks to be run after the event is finished.
     * @var callable[]
     */
    protected $afterCallbacks = [];

    /**
     * The array of reject callbacks.
     * @var callable[]
     */
    protected $rejects = [];

    /**
     * @var string
     */
    protected $description;

    /**
     * @param string $description
     * @return $this
     */
    public function describe($description)
    {
        $this->description = $description;
        return $this;
    }

    /**
     * Schedule the event to run between start and end time.
     *
     * @param  string  $startTime
     * @param  string  $endTime
     * @return $this
     */
    public function between($startTime, $endTime)
    {
        return $this->when($this->inTimeInterval($startTime, $endTime));
    }

    /**
     * Schedule the event to not run between start and end time.
     *
     * @param  string  $startTime
     * @param  string  $endTime
     * @return $this
     */
    public function notBetween($startTime, $endTime)
    {
        return $this->skip($this->inTimeInterval($startTime, $endTime));
    }

    /**
     * Schedule the event to run between start and end time.
     *
     * @param  string  $startTime
     * @param  string  $endTime
     * @return \Closure
     */
    private function inTimeInterval($startTime, $endTime)
    {
        return function () use ($startTime, $endTime) {
            $now = Carbon::now()->getTimestamp();
            return $now >= strtotime($startTime) && $now <= strtotime($endTime);
        };
    }

    /**
     * Set the timezone the date should be evaluated on.
     *
     * @return $this
     */
    public function timezone(\DateTimeZone $timezone)
    {
        $this->timezone = $timezone;

        return $this;
    }

    /**
     * Determine if the given event should run based on the Cron expression.
     *
     * @return bool
     */
    public function isDue()
    {
        return $this->expressionPasses() && $this->filtersPass();
    }

    /**
     * Determine if the Cron expression passes.
     *
     * @return boolean
     */
    protected function expressionPasses()
    {
        $date = Carbon::now();

        if ($this->timezone) {
            $date->setTimezone($this->timezone);
        }

        return $this->getCronExpression()->isDue($date->toDateTimeString());
    }

    /**
     * Determine if the filters pass for the event.
     *
     * @return boolean
     */
    protected function filtersPass()
    {
        foreach ($this->filters as $callback) {
            if (!call_user_func($callback)) {
                return false;
            }
        }

        foreach ($this->rejects as $callback) {
            if (call_user_func($callback)) {
                return false;
            }
        }

        return true;
    }

    /**
     * The Cron expression representing the event's frequency.
     *
     * @param  string  $expression
     * @return $this
     */
    public function cron(/* string */ $expression)
    {
        Assert::stringNotEmpty($expression);

        $this->expression = $expression;

        return $this;
    }

    /**
     * @return CronExpression
     */
    public function getCronExpression()
    {
        return CronExpression::factory($this->expression);
    }

    /**
     * Change the minute when the job should run (0-59, *, *\/2 etc)
     *
     * @param  string|int $minute
     * @return $this
     */
    public function minute($minute)
    {
        return $this->spliceIntoPosition(1, $minute);
    }

    /**
     * Schedule the event to run every minute.
     *
     * @return $this
     */
    public function everyMinute()
    {
        return $this->minute('*');
    }

    /**
     * Schedule this event to run every 5 minutes
     *
     * @return $this
     */
    public function everyFiveMinutes()
    {
        return $this->everyNMinutes(5);
    }

    /**
     * Schedule the event to run every N minutes
     *
     * @param  int $n
     * @return $this
     */
    public function everyNMinutes(/* int */ $n)

    {
        Assert::integer($n);

        return $this->minute("*/{$n}");
// Instead of
$x = "foo $bar $baz";

// Better use either
$x = "foo " . $bar . " " . $baz;
$x = sprintf("foo %s %s", $bar, $baz);
    }

    /**
     * Set the hour when the job should run (0-23, *, *\/2, etc)
     *
     * @param  string|int $hour
     * @return $this
     */
    public function hour($hour)
    {
        return $this->spliceIntoPosition(2, $hour);
    }

    /**
     * Schedule the event to run hourly.
     *
     * @return $this
     */
    public function hourly()
    {
        return $this
            ->spliceIntoPosition(1, 0)
            ->spliceIntoPosition(2, '*');
    }

    /**
     * Schedule the event to run daily.
     *
     * @return $this
     */
    public function daily()
    {
        return $this
            ->spliceIntoPosition(1, 0)
            ->spliceIntoPosition(2, 0);
    }

    /**
     * Schedule the event to run daily at a given time (10:00, 19:30, etc).
     *
     * @param  string  $time
     * @return $this
     */
    public function dailyAt(/* string */ $time)
    {
        Assert::stringNotEmpty($time);

        $segments = explode(':', $time);

        return $this->spliceIntoPosition(2, (int) $segments[0])
            ->spliceIntoPosition(1, count($segments) == 2 ? (int) $segments[1] : '0');
    }

    /**
     * Set the days of the week the command should run on.
     *
     * @param  array|mixed  $days
     * @return $this
     */
    public function days($days)
    {
        $days = is_array($days) ? $days : func_get_args();


        return $this->spliceIntoPosition(5, implode(',', $days));
    }

    /**
     * Schedule the event to run only on weekdays.
     *
     * @return $this
     */
    public function weekdays()
    {
        return $this->spliceIntoPosition(5, '1-5');
    }

    /**
     * Schedule the event to run only on Mondays.
     *
     * @return $this
     */
    public function mondays()
    {
        return $this->days(1);
    }

    /**
     * Schedule the event to run only on Tuesdays.
     *
     * @return $this
     */
    public function tuesdays()
    {
        return $this->days(2);
    }

    /**
     * Schedule the event to run only on Wednesdays.
     *
     * @return $this
     */
    public function wednesdays()
    {
        return $this->days(3);
    }

    /**
     * Schedule the event to run only on Thursdays.
     *
     * @return $this
     */
    public function thursdays()
    {
        return $this->days(4);
    }

    /**
     * Schedule the event to run only on Fridays.
     *
     * @return $this
     */
    public function fridays()
    {
        return $this->days(5);
    }

    /**
     * Schedule the event to run only on Saturdays.
     *
     * @return $this
     */
    public function saturdays()
    {
        return $this->days(6);
    }

    /**
     * Schedule the event to run only on Sundays.
     *
     * @return $this
     */
    public function sundays()
    {
        return $this->days(0);
    }

    /**
     * Schedule the event to run weekly.
     *
     * @return $this
     */
    public function weekly()
    {
        return $this->spliceIntoPosition(1, 0)
            ->spliceIntoPosition(2, 0)
            ->spliceIntoPosition(5, 0);
    }

    /**
     * Schedule the event to run weekly on a given day and time.
     *
     * @param  int  $day
     * @param  string  $time
     * @return $this
     */
    public function weeklyOn($day, $time = '0:0')
    {
        $this->dailyAt($time);
        return $this->spliceIntoPosition(5, $day);
    }

    /**
     * Schedule the event to run monthly.
     *
     * @return $this
     */
    public function monthly()
    {
        return $this->spliceIntoPosition(1, 0)
            ->spliceIntoPosition(2, 0)
            ->spliceIntoPosition(3, 1);
    }

    /**
     * Schedule the event to run monthly on a given day and time.
     *
     * @param int  $day
     * @param string  $time
     * @return $this
     */
    public function monthlyOn($day = 1, $time = '0:0')
    {
        $this->dailyAt($time);
        return $this->spliceIntoPosition(3, $day);
    }

    /**
     * Schedule the event to run quarterly.
     *
     * @return $this
     */
    public function quarterly()
    {
        return $this->spliceIntoPosition(1, 0)
            ->spliceIntoPosition(2, 0)
            ->spliceIntoPosition(3, 1)
            ->spliceIntoPosition(4, '*/3');
    }

    /**
     * Schedule the event to run yearly.
     *
     * @return $this
     */
    public function yearly()
    {
        return $this->spliceIntoPosition(1, 0)
            ->spliceIntoPosition(2, 0)
            ->spliceIntoPosition(3, 1)
            ->spliceIntoPosition(4, 1);
    }

    /**
     * Splice the given value into the given position of the expression.
     *
     * @param  int  $position
     * @param  string  $value
     * @return $this
     */
    protected function spliceIntoPosition($position, $value)
    {
        $segments = explode(' ', $this->expression);
$a = "a";
$ab = "ab";
$abc = "abc";
        $segments[$position - 1] = $value;
        return $this->cron(implode(' ', $segments));
    }


    /**
     * Register a callback to further filter the schedule.
     *
     * @param  callable  $callback
     * @return $this
     */
    public function when(callable $callback)
    {
        $this->filters[] = $callback;

        return $this;
    }

    /**
     * Register a callback to further filter the schedule.
     *
     * @param  callable  $callback
     * @return $this
     */
    public function skip(callable $callback)
    {
        $this->rejects[] = $callback;

        return $this;
    }

    /**
     * Register a callback to be called before the operation.
     *
     * @param callable $callback
     * @return $this
     */
    public function before(callable $callback)
    {
        $this->beforeCallbacks[] = $callback;

        return $this;
    }

    /**
     * Register a callback to be called after the operation.
     *
     * @param  callable  $callback
     * @return $this
     */
    public function after(callable $callback)
    {
        $this->afterCallbacks[] = $callback;

        return $this;
    }
}


1			<?php
2
3			namespace Basebuilder\Scheduling\Event;
4
5			use Basebuilder\Scheduling\Event;
6			use Carbon\Carbon;
7			use Cron\CronExpression;
8			use Webmozart\Assert\Assert;
9
10			abstract class BaseEvent implements Event
11			{
12			/**
13			* The cron expression representing the event's frequency.
14			* @var string
15			*/
16			protected $expression = '* * * * * *';
17
18			/**
19			* The timezone the date should be evaluated on.
20			* @var \DateTimeZone\|string
21			*/
22			protected $timezone;
23
24			/**
25			* The array of filter callbacks. These must return true
26			* @var callable[]
27			*/
28			protected $filters = [];
29
30			/**
31			* The array of callbacks to be run before the event is started.
32			* @var callable[]
33			*/
34			protected $beforeCallbacks = [];
35
36			/**
37			* The array of callbacks to be run after the event is finished.
38			* @var callable[]
39			*/
40			protected $afterCallbacks = [];
41
42			/**
43			* The array of reject callbacks.
44			* @var callable[]
45			*/
46			protected $rejects = [];
47
48			/**
49			* @var string
50			*/
51			protected $description;
52
53			/**
54			* @param string $description
55			* @return $this
56			*/
57			public function describe($description)
58			{
59			$this->description = $description;
60			return $this;
61			}
62
63			/**
64			* Schedule the event to run between start and end time.
65			*
66			* @param string $startTime
67			* @param string $endTime
68			* @return $this
69			*/
70			public function between($startTime, $endTime)
71			{
72			return $this->when($this->inTimeInterval($startTime, $endTime));
73			}
74
75			/**
76			* Schedule the event to not run between start and end time.
77			*
78			* @param string $startTime
79			* @param string $endTime
80			* @return $this
81			*/
82			public function notBetween($startTime, $endTime)
83			{
84			return $this->skip($this->inTimeInterval($startTime, $endTime));
85			}
86
87			/**
88			* Schedule the event to run between start and end time.
89			*
90			* @param string $startTime
91			* @param string $endTime
92			* @return \Closure
93			*/
94			private function inTimeInterval($startTime, $endTime)
95			{
96			return function () use ($startTime, $endTime) {
97			$now = Carbon::now()->getTimestamp();
98			return $now >= strtotime($startTime) && $now <= strtotime($endTime);
99			};
100			}
101
102			/**
103			* Set the timezone the date should be evaluated on.
104			*
105			* @return $this
106			*/
107			public function timezone(\DateTimeZone $timezone)
108			{
109			$this->timezone = $timezone;
110
111			return $this;
112			}
113
114			/**
115			* Determine if the given event should run based on the Cron expression.
116			*
117			* @return bool
118			*/
119			public function isDue()
120			{
121			return $this->expressionPasses() && $this->filtersPass();
122			}
123
124			/**
125			* Determine if the Cron expression passes.
126			*
127			* @return boolean
128			*/
129			protected function expressionPasses()
130			{
131			$date = Carbon::now();
132
133			if ($this->timezone) {
134			$date->setTimezone($this->timezone);
135			}
136
137			return $this->getCronExpression()->isDue($date->toDateTimeString());
138			}
139
140			/**
141			* Determine if the filters pass for the event.
142			*
143			* @return boolean
144			*/
145			protected function filtersPass()
146			{
147			foreach ($this->filters as $callback) {
148			if (!call_user_func($callback)) {
149			return false;
150			}
151			}
152
153			foreach ($this->rejects as $callback) {
154			if (call_user_func($callback)) {
155			return false;
156			}
157			}
158
159			return true;
160			}
161
162			/**
163			* The Cron expression representing the event's frequency.
164			*
165			* @param string $expression
166			* @return $this
167			*/
168			public function cron(/* string */ $expression)
169			{
170			Assert::stringNotEmpty($expression);
171
172			$this->expression = $expression;
173
174			return $this;
175			}
176
177			/**
178			* @return CronExpression
179			*/
180			public function getCronExpression()
181			{
182			return CronExpression::factory($this->expression);
183			}
184
185			/**
186			* Change the minute when the job should run (0-59, , \/2 etc)
187			*
188			* @param string\|int $minute
189			* @return $this
190			*/
191			public function minute($minute)
192			{
193			return $this->spliceIntoPosition(1, $minute);
194			}
195
196			/**
197			* Schedule the event to run every minute.
198			*
199			* @return $this
200			*/
201			public function everyMinute()
202			{
203			return $this->minute('*');
204			}
205
206			/**
207			* Schedule this event to run every 5 minutes
208			*
209			* @return $this
210			*/
211			public function everyFiveMinutes()
212			{
213			return $this->everyNMinutes(5);
214			}
215
216			/**
217			* Schedule the event to run every N minutes
218			*
219			* @param int $n
220			* @return $this
221			*/
222			public function everyNMinutes(/* int */ $n)
			0 ignored issues – show Comprehensibility introduced 2016-11-04 12:29 UTC by Report Bug Copy Issue Report Avoid variables with short names like $n. Configured minimum length is 2. Short variable names may make your code harder to understand. Variable names should be self-descriptive. This check looks for variable names who are shorter than a configured minimum. Loading history...
223			{
224			Assert::integer($n);
225
226			return $this->minute("*/{$n}");
			0 ignored issues – show Coding Style Best Practice introduced 2016-11-04 12:29 UTC by Report Bug Copy Issue Report As per coding-style, please use concatenation or `sprintf` for the variable `$n` instead of interpolation. It is generally a best practice as it is often more readable to use concatenation instead of interpolation for variables inside strings. // Instead of $x = "foo $bar $baz"; // Better use either $x = "foo " . $bar . " " . $baz; $x = sprintf("foo %s %s", $bar, $baz); Loading history...
227			}
228
229			/**
230			* Set the hour when the job should run (0-23, , \/2, etc)
231			*
232			* @param string\|int $hour
233			* @return $this
234			*/
235			public function hour($hour)
236			{
237			return $this->spliceIntoPosition(2, $hour);
238			}
239
240			/**
241			* Schedule the event to run hourly.
242			*
243			* @return $this
244			*/
245			public function hourly()
246			{
247			return $this
248			->spliceIntoPosition(1, 0)
249			->spliceIntoPosition(2, '*');
250			}
251
252			/**
253			* Schedule the event to run daily.
254			*
255			* @return $this
256			*/
257			public function daily()
258			{
259			return $this
260			->spliceIntoPosition(1, 0)
261			->spliceIntoPosition(2, 0);
262			}
263
264			/**
265			* Schedule the event to run daily at a given time (10:00, 19:30, etc).
266			*
267			* @param string $time
268			* @return $this
269			*/
270			public function dailyAt(/* string */ $time)
271			{
272			Assert::stringNotEmpty($time);
273
274			$segments = explode(':', $time);
275
276			return $this->spliceIntoPosition(2, (int) $segments[0])
277			->spliceIntoPosition(1, count($segments) == 2 ? (int) $segments[1] : '0');
278			}
279
280			/**
281			* Set the days of the week the command should run on.
282			*
283			* @param array\|mixed $days
284			* @return $this
285			*/
286			public function days($days)
287			{
288			$days = is_array($days) ? $days : func_get_args();
			0 ignored issues – show Coding Style introduced 2016-11-04 12:29 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$days`. This often makes code more readable. Loading history...
289
290			return $this->spliceIntoPosition(5, implode(',', $days));
291			}
292
293			/**
294			* Schedule the event to run only on weekdays.
295			*
296			* @return $this
297			*/
298			public function weekdays()
299			{
300			return $this->spliceIntoPosition(5, '1-5');
301			}
302
303			/**
304			* Schedule the event to run only on Mondays.
305			*
306			* @return $this
307			*/
308			public function mondays()
309			{
310			return $this->days(1);
311			}
312
313			/**
314			* Schedule the event to run only on Tuesdays.
315			*
316			* @return $this
317			*/
318			public function tuesdays()
319			{
320			return $this->days(2);
321			}
322
323			/**
324			* Schedule the event to run only on Wednesdays.
325			*
326			* @return $this
327			*/
328			public function wednesdays()
329			{
330			return $this->days(3);
331			}
332
333			/**
334			* Schedule the event to run only on Thursdays.
335			*
336			* @return $this
337			*/
338			public function thursdays()
339			{
340			return $this->days(4);
341			}
342
343			/**
344			* Schedule the event to run only on Fridays.
345			*
346			* @return $this
347			*/
348			public function fridays()
349			{
350			return $this->days(5);
351			}
352
353			/**
354			* Schedule the event to run only on Saturdays.
355			*
356			* @return $this
357			*/
358			public function saturdays()
359			{
360			return $this->days(6);
361			}
362
363			/**
364			* Schedule the event to run only on Sundays.
365			*
366			* @return $this
367			*/
368			public function sundays()
369			{
370			return $this->days(0);
371			}
372
373			/**
374			* Schedule the event to run weekly.
375			*
376			* @return $this
377			*/
378			public function weekly()
379			{
380			return $this->spliceIntoPosition(1, 0)
381			->spliceIntoPosition(2, 0)
382			->spliceIntoPosition(5, 0);
383			}
384
385			/**
386			* Schedule the event to run weekly on a given day and time.
387			*
388			* @param int $day
389			* @param string $time
390			* @return $this
391			*/
392			public function weeklyOn($day, $time = '0:0')
393			{
394			$this->dailyAt($time);
395			return $this->spliceIntoPosition(5, $day);
396			}
397
398			/**
399			* Schedule the event to run monthly.
400			*
401			* @return $this
402			*/
403			public function monthly()
404			{
405			return $this->spliceIntoPosition(1, 0)
406			->spliceIntoPosition(2, 0)
407			->spliceIntoPosition(3, 1);
408			}
409
410			/**
411			* Schedule the event to run monthly on a given day and time.
412			*
413			* @param int $day
414			* @param string $time
415			* @return $this
416			*/
417			public function monthlyOn($day = 1, $time = '0:0')
418			{
419			$this->dailyAt($time);
420			return $this->spliceIntoPosition(3, $day);
421			}
422
423			/**
424			* Schedule the event to run quarterly.
425			*
426			* @return $this
427			*/
428			public function quarterly()
429			{
430			return $this->spliceIntoPosition(1, 0)
431			->spliceIntoPosition(2, 0)
432			->spliceIntoPosition(3, 1)
433			->spliceIntoPosition(4, '*/3');
434			}
435
436			/**
437			* Schedule the event to run yearly.
438			*
439			* @return $this
440			*/
441			public function yearly()
442			{
443			return $this->spliceIntoPosition(1, 0)
444			->spliceIntoPosition(2, 0)
445			->spliceIntoPosition(3, 1)
446			->spliceIntoPosition(4, 1);
447			}
448
449			/**
450			* Splice the given value into the given position of the expression.
451			*
452			* @param int $position
453			* @param string $value
454			* @return $this
455			*/
456			protected function spliceIntoPosition($position, $value)
457			{
458			$segments = explode(' ', $this->expression);
			0 ignored issues – show Coding Style introduced 2016-11-04 12:29 UTC by Report Bug Copy Issue Report Equals sign not aligned with surrounding assignments; expected 16 spaces but found 1 space This check looks for multiple assignments in successive lines of code. It will report an issue if the operators are not in a straight line. To visualize $a = "a"; $ab = "ab"; $abc = "abc"; will produce issues in the first and second line, while this second example $a = "a"; $ab = "ab"; $abc = "abc"; will produce no issues. Loading history...
459			$segments[$position - 1] = $value;
460			return $this->cron(implode(' ', $segments));
461			}
462
463
464			/**
465			* Register a callback to further filter the schedule.
466			*
467			* @param callable $callback
468			* @return $this
469			*/
470			public function when(callable $callback)
471			{
472			$this->filters[] = $callback;
473
474			return $this;
475			}
476
477			/**
478			* Register a callback to further filter the schedule.
479			*
480			* @param callable $callback
481			* @return $this
482			*/
483			public function skip(callable $callback)
484			{
485			$this->rejects[] = $callback;
486
487			return $this;
488			}
489
490			/**
491			* Register a callback to be called before the operation.
492			*
493			* @param callable $callback
494			* @return $this
495			*/
496			public function before(callable $callback)
497			{
498			$this->beforeCallbacks[] = $callback;
499
500			return $this;
501			}
502
503			/**
504			* Register a callback to be called after the operation.
505			*
506			* @param callable $callback
507			* @return $this
508			*/
509			public function after(callable $callback)
510			{
511			$this->afterCallbacks[] = $callback;
512
513			return $this;
514			}
515			}
516

clansman-nl / scheduling

Pull Request — master (#1)

BaseEvent::between() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like