Schedule::pingOnSuccess() - Code Metrics - zenstruck/schedule-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Schedule::pingOnSuccess() A
last analyzed 2022-02-21 22:53 UTC

↳ Parent: Schedule

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Zenstruck\ScheduleBundle;

use Symfony\Component\Process\Process;
use Zenstruck\ScheduleBundle\Schedule\Exception\SkipSchedule;
use Zenstruck\ScheduleBundle\Schedule\Extension\CallbackExtension;
use Zenstruck\ScheduleBundle\Schedule\Extension\EmailExtension;
use Zenstruck\ScheduleBundle\Schedule\Extension\EnvironmentExtension;
use Zenstruck\ScheduleBundle\Schedule\Extension\PingExtension;
use Zenstruck\ScheduleBundle\Schedule\Extension\SingleServerExtension;
use Zenstruck\ScheduleBundle\Schedule\HasExtensions;
use Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext;
use Zenstruck\ScheduleBundle\Schedule\Task;
use Zenstruck\ScheduleBundle\Schedule\Task\CallbackTask;
use Zenstruck\ScheduleBundle\Schedule\Task\CommandTask;
use Zenstruck\ScheduleBundle\Schedule\Task\CompoundTask;
use Zenstruck\ScheduleBundle\Schedule\Task\MessageTask;
use Zenstruck\ScheduleBundle\Schedule\Task\PingTask;
use Zenstruck\ScheduleBundle\Schedule\Task\ProcessTask;

/**
 * @author Kevin Bond <[email protected]>
 */
final class Schedule
{
    use HasExtensions;

    public const FILTER = 'Filter Schedule';
    public const BEFORE = 'Before Schedule';
    public const AFTER = 'After Schedule';
    public const SUCCESS = 'On Schedule Success';
    public const FAILURE = 'On Schedule Failure';

    /** @var Task[] */
    private $tasks = [];

    /** @var Task[]|null */
    private $allTasks;

    /** @var Task[]|null */
    private $dueTasks;

    /** @var \DateTimeZone|null */
    private $timezone;

    public function getId(): string
    {
        $tasks = \array_map(
            function(Task $task) {
                return $task->getId();
            },
            $this->all()
        );

        return \sha1(\implode('', $tasks));
    }

    /**
     * @template T of Task
     *
     * @param T $task
     *
     * @return T
     */
    public function add(Task $task): Task
    {
        $this->resetCache();

        return $this->tasks[] = $task;

    }

    /**
     * @see CommandTask::__construct()
     */
    public function addCommand(string $name, string ...$arguments): CommandTask
    {
        return $this->add(new CommandTask($name, ...$arguments));
    }

    /**
     * @see CallbackTask::__construct()
     */
    public function addCallback(callable $callback): CallbackTask
    {
        return $this->add(new CallbackTask($callback));
    }

    /**
     * @see ProcessTask::__construct()
     *
     * @param string|Process $process
     */
    public function addProcess($process): ProcessTask
    {
        return $this->add(new ProcessTask($process));
    }

    /**
     * @see PingTask::__construct()
     */
    public function addPing(string $url, string $method = 'GET', array $options = []): PingTask
    {
        return $this->add(new PingTask($url, $method, $options));
    }

    /**
     * @see MessageTask::__construct()
     */
    public function addMessage(object $message, array $stamps = []): MessageTask
    {
        return $this->add(new MessageTask($message, $stamps));
    }

    public function addCompound(): CompoundTask
    {
        return $this->add(new CompoundTask());
    }

    /**
     * Prevent schedule from running if callback throws \Zenstruck\ScheduleBundle\Schedule\Exception\SkipSchedule.
     *
     * @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
     */
    public function filter(callable $callback): self
    {
        return $this->addExtension(CallbackExtension::scheduleFilter($callback));
    }

    /**
     * Only run schedule if true.
     *
     * @param bool|callable $callback bool: skip if false, callable: skip if return value is false
     *                                callable receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
     */
    public function when(string $description, $callback): self
    {
        $callback = \is_callable($callback) ? $callback : function() use ($callback) {
            return (bool) $callback;
        };

        return $this->filter(function(ScheduleRunContext $context) use ($callback, $description) {
            if (!$callback($context)) {
                throw new SkipSchedule($description);
            }
        });
    }

    /**
     * Skip schedule if true.
     *
     * @param bool|callable $callback bool: skip if true, callable: skip if return value is true
     *                                callable receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
     */
    public function skip(string $description, $callback): self
    {
        $callback = \is_callable($callback) ? $callback : function() use ($callback) {
            return (bool) $callback;
        };

        return $this->filter(function(ScheduleRunContext $context) use ($callback, $description) {
            if ($callback($context)) {
                throw new SkipSchedule($description);
            }
        });
    }

    /**
     * Execute callback before tasks run (even if no tasks are due).
     *
     * @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
     */
    public function before(callable $callback): self
    {
        return $this->addExtension(CallbackExtension::scheduleBefore($callback));
    }

    /**
     * Execute callback after tasks run (even if no tasks ran).
     *
     * @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
     */
    public function after(callable $callback): self
    {
        return $this->addExtension(CallbackExtension::scheduleAfter($callback));
    }

    /**
     * Alias for after().
     */
    public function then(callable $callback): self
    {
        return $this->after($callback);
    }

    /**
     * Execute callback after tasks run if all tasks succeeded
     *  - even if no tasks ran
     *  - skipped tasks are considered successful.
     *
     * @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
     */
    public function onSuccess(callable $callback): self
    {
        return $this->addExtension(CallbackExtension::scheduleSuccess($callback));
    }

    /**
     * Execute callback after tasks run if one or more tasks failed
     *  - skipped tasks are considered successful.
     *
     * @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
     */
    public function onFailure(callable $callback): self
    {
        return $this->addExtension(CallbackExtension::scheduleFailure($callback));
    }

    /**
     * Ping a webhook before any tasks run (even if none are due).
     * If you want to control the HttpClient used, configure `zenstruck_schedule.http_client`.
     *
     * @param array $options See HttpClientInterface::OPTIONS_DEFAULTS
     */
    public function pingBefore(string $url, string $method = 'GET', array $options = []): self
    {
        return $this->addExtension(PingExtension::scheduleBefore($url, $method, $options));
    }

    /**
     * Ping a webhook after tasks ran (even if none ran).
     * If you want to control the HttpClient used, configure `zenstruck_schedule.http_client`.
     *
     * @param array $options See HttpClientInterface::OPTIONS_DEFAULTS
     */
    public function pingAfter(string $url, string $method = 'GET', array $options = []): self
    {
        return $this->addExtension(PingExtension::scheduleAfter($url, $method, $options));
    }

    /**
     * Alias for pingAfter().
     */
    public function thenPing(string $url, string $method = 'GET', array $options = []): self
    {
        return $this->pingAfter($url, $method, $options);
    }

    /**
     * Ping a webhook after tasks run if all tasks succeeded (skipped tasks are considered successful).
     * If you want to control the HttpClient used, configure `zenstruck_schedule.http_client`.
     *
     * @param array $options See HttpClientInterface::OPTIONS_DEFAULTS
     */
    public function pingOnSuccess(string $url, string $method = 'GET', array $options = []): self
    {
        return $this->addExtension(PingExtension::scheduleSuccess($url, $method, $options));
    }

    /**
     * Ping a webhook after tasks run if one or more tasks failed.
     * If you want to control the HttpClient used, configure `zenstruck_schedule.http_client`.
     *
     * @param array $options See HttpClientInterface::OPTIONS_DEFAULTS
     */
    public function pingOnFailure(string $url, string $method = 'GET', array $options = []): self
    {
        return $this->addExtension(PingExtension::scheduleFailure($url, $method, $options));
    }

    /**
     * Email failed task detail after tasks run if one or more tasks failed.
     * Be sure to configure `zenstruck_schedule.mailer`.
     *
     * @param string|string[] $to       Email address(es)
     * @param callable|null   $callback Add your own headers etc
     *                                  Receives an instance of \Symfony\Component\Mime\Email
     */
    public function emailOnFailure($to = null, ?string $subject = null, ?callable $callback = null): self
    {
        return $this->addExtension(EmailExtension::scheduleFailure($to, $subject, $callback));
    }

    /**
     * Restrict running of schedule to a single server.
     * Be sure to configure `zenstruck_schedule.single_server_lock_factory`.
     *
     * @param int $ttl Maximum expected lock duration in seconds
     */
    public function onSingleServer(int $ttl = SingleServerExtension::DEFAULT_TTL): self
    {
        return $this->addExtension(new SingleServerExtension($ttl));
    }

    /**
     * Define the application environment(s) you wish to run the schedule in. Trying to
     * run in another environment will skip the schedule.
     */
    public function environments(string $environment, string ...$environments): self
    {
        return $this->addExtension(new EnvironmentExtension(\array_merge([$environment], $environments)));
    }

    /**
     * The default timezone for tasks (tasks can override).
     *
     * @param string|\DateTimeZone $value
     */
    public function timezone($value): self
    {
        $this->resetCache();

        if (!$value instanceof \DateTimeZone) {
            $value = new \DateTimeZone($value);
        }

        $this->timezone = $value;

        return $this;
    }

    public function getTimezone(): ?\DateTimeZone
    {
        return $this->timezone;
    }

    public function getTask(string $id): Task
    {
        // check for duplicated task ids
        $tasks = [];

        foreach ($this->all() as $task) {
            $tasks[$task->getId()][] = $task;
        }

        if (!\array_key_exists($id, $tasks)) {
            throw new \InvalidArgumentException("Task with ID \"{$id}\" not found.");
        }

        if (1 !== $count = \count($tasks[$id])) {
            throw new \RuntimeException(\sprintf('Task ID "%s" is ambiguous, there are %d tasks this id.', $id, $count));
        }

        return $tasks[$id][0];
    }

    /**
     * @return Task[]
     */
    public function all(): array
    {
        if (null !== $this->allTasks) {
            return $this->allTasks;
        }

        $this->allTasks = [];

        foreach ($this->taskIterator() as $task) {
            if ($this->getTimezone() && !$task->getTimezone()) {
                $task->timezone($this->getTimezone());
            }

            $this->allTasks[] = $task;
        }

        return $this->allTasks;
    }

    /**
     * @return Task[]
     */
    public function due(\DateTimeInterface $timestamp): array
    {
        if (null !== $this->dueTasks) {
            return $this->dueTasks;
        }

        $this->dueTasks = [];

        foreach ($this->all() as $task) {
            if ($task->isDue($timestamp)) {
                $this->dueTasks[] = $task;
            }
        }

        return $this->dueTasks;
    }

    /**
     * @return Task[]
     */
    private function taskIterator(): iterable
    {
        foreach ($this->tasks as $task) {
            if ($task instanceof CompoundTask) {
                yield from $task;


                continue;
            }

            yield $task;
        }
    }

    private function resetCache(): void
    {
        $this->allTasks = $this->dueTasks = null;
    }
}


1		<?php
2
3		namespace Zenstruck\ScheduleBundle;
4
5		use Symfony\Component\Process\Process;
6		use Zenstruck\ScheduleBundle\Schedule\Exception\SkipSchedule;
7		use Zenstruck\ScheduleBundle\Schedule\Extension\CallbackExtension;
8		use Zenstruck\ScheduleBundle\Schedule\Extension\EmailExtension;
9		use Zenstruck\ScheduleBundle\Schedule\Extension\EnvironmentExtension;
10		use Zenstruck\ScheduleBundle\Schedule\Extension\PingExtension;
11		use Zenstruck\ScheduleBundle\Schedule\Extension\SingleServerExtension;
12		use Zenstruck\ScheduleBundle\Schedule\HasExtensions;
13		use Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext;
14		use Zenstruck\ScheduleBundle\Schedule\Task;
15		use Zenstruck\ScheduleBundle\Schedule\Task\CallbackTask;
16		use Zenstruck\ScheduleBundle\Schedule\Task\CommandTask;
17		use Zenstruck\ScheduleBundle\Schedule\Task\CompoundTask;
18		use Zenstruck\ScheduleBundle\Schedule\Task\MessageTask;
19		use Zenstruck\ScheduleBundle\Schedule\Task\PingTask;
20		use Zenstruck\ScheduleBundle\Schedule\Task\ProcessTask;
21
22		/**
23		* @author Kevin Bond <[email protected]>
24		*/
25		final class Schedule
26		{
27		use HasExtensions;
28
29		public const FILTER = 'Filter Schedule';
30		public const BEFORE = 'Before Schedule';
31		public const AFTER = 'After Schedule';
32		public const SUCCESS = 'On Schedule Success';
33		public const FAILURE = 'On Schedule Failure';
34
35		/** @var Task[] */
36		private $tasks = [];
37
38		/** @var Task[]\|null */
39	3	private $allTasks;
40
41	3	/** @var Task[]\|null */
42		private $dueTasks;
43	2
44	3	/** @var \DateTimeZone\|null */
45	3	private $timezone;
46
47		public function getId(): string
48	3	{
49		$tasks = \array_map(
50		function(Task $task) {
51	94	return $task->getId();
52		},
53	94	$this->all()
54		);
55	94
56		return \sha1(\implode('', $tasks));
57		}
58
59		/**
60		* @template T of Task
61	11	*
62		* @param T $task
63	11	*
64		* @return T
65		*/
66		public function add(Task $task): Task
67		{
68		$this->resetCache();
69	2
70		return $this->tasks[] = $task;
		0 ignored issues – show Bug Best Practice introduced 2022-02-16 15:06 UTC by Report Bug Copy Issue Report The expression `return $this->tasks[] = $task` returns the type `Zenstruck\ScheduleBundle\Schedule\Task` which is incompatible with the documented return type `Zenstruck\ScheduleBundle\T`. Loading history...
71	2	}
72
73		/**
74		* @see CommandTask::__construct()
75		*/
76		public function addCommand(string $name, string ...$arguments): CommandTask
77	2	{
78		return $this->add(new CommandTask($name, ...$arguments));
79	2	}
80
81		/**
82		* @see CallbackTask::__construct()
83		*/
84		public function addCallback(callable $callback): CallbackTask
85	1	{
86		return $this->add(new CallbackTask($callback));
87	1	}
88
89		/**
90		* @see ProcessTask::__construct()
91		*
92		* @param string\|Process $process
93	1	*/
94		public function addProcess($process): ProcessTask
95	1	{
96		return $this->add(new ProcessTask($process));
97		}
98	2
99		/**
100	2	* @see PingTask::__construct()
101		*/
102		public function addPing(string $url, string $method = 'GET', array $options = []): PingTask
103		{
104		return $this->add(new PingTask($url, $method, $options));
105		}
106
107		/**
108	12	* @see MessageTask::__construct()
109		*/
110	12	public function addMessage(object $message, array $stamps = []): MessageTask
111		{
112		return $this->add(new MessageTask($message, $stamps));
113		}
114
115		public function addCompound(): CompoundTask
116		{
117		return $this->add(new CompoundTask());
118		}
119	4
120		/**
121		* Prevent schedule from running if callback throws \Zenstruck\ScheduleBundle\Schedule\Exception\SkipSchedule.
122	2	*
123	4	* @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
124		*/
125		public function filter(callable $callback): self
126	4	{
127	2	return $this->addExtension(CallbackExtension::scheduleFilter($callback));
128		}
129	4
130		/**
131		* Only run schedule if true.
132		*
133		* @param bool\|callable $callback bool: skip if false, callable: skip if return value is false
134		* callable receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
135		*/
136		public function when(string $description, $callback): self
137		{
138	5	$callback = \is_callable($callback) ? $callback : function() use ($callback) {
139		return (bool) $callback;
140		};
141	3
142	5	return $this->filter(function(ScheduleRunContext $context) use ($callback, $description) {
143		if (!$callback($context)) {
144		throw new SkipSchedule($description);
145	5	}
146	3	});
147		}
148	5
149		/**
150		* Skip schedule if true.
151		*
152		* @param bool\|callable $callback bool: skip if true, callable: skip if return value is true
153		* callable receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
154		*/
155		public function skip(string $description, $callback): self
156	3	{
157		$callback = \is_callable($callback) ? $callback : function() use ($callback) {
158	3	return (bool) $callback;
159		};
160
161		return $this->filter(function(ScheduleRunContext $context) use ($callback, $description) {
162		if ($callback($context)) {
163		throw new SkipSchedule($description);
164		}
165		});
166	3	}
167
168	3	/**
169		* Execute callback before tasks run (even if no tasks are due).
170		*
171		* @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
172		*/
173		public function before(callable $callback): self
174	3	{
175		return $this->addExtension(CallbackExtension::scheduleBefore($callback));
176	3	}
177
178		/**
179		* Execute callback after tasks run (even if no tasks ran).
180		*
181		* @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
182		*/
183		public function after(callable $callback): self
184		{
185		return $this->addExtension(CallbackExtension::scheduleAfter($callback));
186	3	}
187
188	3	/**
189		* Alias for after().
190		*/
191		public function then(callable $callback): self
192		{
193		return $this->after($callback);
194		}
195
196		/**
197	3	* Execute callback after tasks run if all tasks succeeded
198		* - even if no tasks ran
199	3	* - skipped tasks are considered successful.
200		*
201		* @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
202		*/
203		public function onSuccess(callable $callback): self
204		{
205		return $this->addExtension(CallbackExtension::scheduleSuccess($callback));
206		}
207
208	2	/**
209		* Execute callback after tasks run if one or more tasks failed
210	2	* - skipped tasks are considered successful.
211		*
212		* @param callable $callback Receives an instance of \Zenstruck\ScheduleBundle\Schedule\ScheduleRunContext
213		*/
214		public function onFailure(callable $callback): self
215		{
216		return $this->addExtension(CallbackExtension::scheduleFailure($callback));
217		}
218
219	2	/**
220		* Ping a webhook before any tasks run (even if none are due).
221	2	* If you want to control the HttpClient used, configure `zenstruck_schedule.http_client`.
222		*
223		* @param array $options See HttpClientInterface::OPTIONS_DEFAULTS
224		*/
225		public function pingBefore(string $url, string $method = 'GET', array $options = []): self
226		{
227		return $this->addExtension(PingExtension::scheduleBefore($url, $method, $options));
228		}
229
230		/**
231		* Ping a webhook after tasks ran (even if none ran).
232		* If you want to control the HttpClient used, configure `zenstruck_schedule.http_client`.
233		*
234		* @param array $options See HttpClientInterface::OPTIONS_DEFAULTS
235		*/
236		public function pingAfter(string $url, string $method = 'GET', array $options = []): self
237		{
238	2	return $this->addExtension(PingExtension::scheduleAfter($url, $method, $options));
239		}
240	2
241		/**
242		* Alias for pingAfter().
243		*/
244		public function thenPing(string $url, string $method = 'GET', array $options = []): self
245		{
246		return $this->pingAfter($url, $method, $options);
247		}
248
249	2	/**
250		* Ping a webhook after tasks run if all tasks succeeded (skipped tasks are considered successful).
251	2	* If you want to control the HttpClient used, configure `zenstruck_schedule.http_client`.
252		*
253		* @param array $options See HttpClientInterface::OPTIONS_DEFAULTS
254		*/
255		public function pingOnSuccess(string $url, string $method = 'GET', array $options = []): self
256		{
257		return $this->addExtension(PingExtension::scheduleSuccess($url, $method, $options));
258		}
259
260		/**
261		* Ping a webhook after tasks run if one or more tasks failed.
262	7	* If you want to control the HttpClient used, configure `zenstruck_schedule.http_client`.
263		*
264	7	* @param array $options See HttpClientInterface::OPTIONS_DEFAULTS
265		*/
266		public function pingOnFailure(string $url, string $method = 'GET', array $options = []): self
267		{
268		return $this->addExtension(PingExtension::scheduleFailure($url, $method, $options));
269		}
270
271		/**
272		* Email failed task detail after tasks run if one or more tasks failed.
273	2	* Be sure to configure `zenstruck_schedule.mailer`.
274		*
275	2	* @param string\|string[] $to Email address(es)
276		* @param callable\|null $callback Add your own headers etc
277		* Receives an instance of \Symfony\Component\Mime\Email
278		*/
279		public function emailOnFailure($to = null, ?string $subject = null, ?callable $callback = null): self
280		{
281		return $this->addExtension(EmailExtension::scheduleFailure($to, $subject, $callback));
282	1	}
283
284	1	/**
285		* Restrict running of schedule to a single server.
286		* Be sure to configure `zenstruck_schedule.single_server_lock_factory`.
287		*
288		* @param int $ttl Maximum expected lock duration in seconds
289		*/
290		public function onSingleServer(int $ttl = SingleServerExtension::DEFAULT_TTL): self
291		{
292	2	return $this->addExtension(new SingleServerExtension($ttl));
293		}
294	2
295		/**
296	2	* Define the application environment(s) you wish to run the schedule in. Trying to
297	2	* run in another environment will skip the schedule.
298		*/
299		public function environments(string $environment, string ...$environments): self
300	2	{
301		return $this->addExtension(new EnvironmentExtension(\array_merge([$environment], $environments)));
302	2	}
303
304		/**
305	93	* The default timezone for tasks (tasks can override).
306		*
307	93	* @param string\|\DateTimeZone $value
308		*/
309		public function timezone($value): self
310	5	{
311		$this->resetCache();
312
313	5	if (!$value instanceof \DateTimeZone) {
314		$value = new \DateTimeZone($value);
315	5	}
316	5
317		$this->timezone = $value;
318
319	5	return $this;
320	1	}
321
322		public function getTimezone(): ?\DateTimeZone
323	4	{
324	1	return $this->timezone;
325		}
326
327	3	public function getTask(string $id): Task
328		{
329		// check for duplicated task ids
330		$tasks = [];
331
332		foreach ($this->all() as $task) {
333	114	$tasks[$task->getId()][] = $task;
334		}
335	114
336	39	if (!\array_key_exists($id, $tasks)) {
337		throw new \InvalidArgumentException("Task with ID \"{$id}\" not found.");
338		}
339	114
340		if (1 !== $count = \count($tasks[$id])) {
341	114	throw new \RuntimeException(\sprintf('Task ID "%s" is ambiguous, there are %d tasks this id.', $id, $count));
342	93	}
343	2
344		return $tasks[$id][0];
345		}
346	93
347		/**
348		* @return Task[]
349	114	*/
350		public function all(): array
351		{
352		if (null !== $this->allTasks) {
353		return $this->allTasks;
354		}
355	87
356		$this->allTasks = [];
357	87
358	2	foreach ($this->taskIterator() as $task) {
359		if ($this->getTimezone() && !$task->getTimezone()) {
360		$task->timezone($this->getTimezone());
361	87	}
362
363	87	$this->allTasks[] = $task;
364	67	}
365	67
366		return $this->allTasks;
367		}
368
369	87	/**
370		* @return Task[]
371		*/
372		public function due(\DateTimeInterface $timestamp): array
373		{
374		if (null !== $this->dueTasks) {
375	114	return $this->dueTasks;
376		}
377	114
378	93	$this->dueTasks = [];
379	5
380		foreach ($this->all() as $task) {
381	5	if ($task->isDue($timestamp)) {
382		$this->dueTasks[] = $task;
383		}
384	91	}
385
386	114	return $this->dueTasks;
387		}
388	94
389		/**
390	94	* @return Task[]
391	94	*/
392		private function taskIterator(): iterable
393		{
394		foreach ($this->tasks as $task) {
395		if ($task instanceof CompoundTask) {
396		yield from $task;
		0 ignored issues – show Bug Best Practice introduced 2020-01-13 12:54 UTC by Report Bug Copy Issue Report The expression `YieldFromNode` returns the type `Generator` which is incompatible with the documented return type `Zenstruck\ScheduleBundle\Schedule\Task[]`. Loading history...
397
398		continue;
399		}
400
401		yield $task;
402		}
403		}
404
405		private function resetCache(): void
406		{
407		$this->allTasks = $this->dueTasks = null;
408		}
409		}
410

zenstruck / schedule-bundle

Schedule::pingOnSuccess() A last analyzed 2022-02-21 22:53 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Schedule::pingOnSuccess() A
last analyzed 2022-02-21 22:53 UTC