CallableTask::run() - Code Metrics - consolidation/robo - Measure and Improve Code Quality continuously with Scrutinizer

CallableTask::run() A
last analyzed 2020-08-27 17:44 UTC

↳ Parent: CallableTask

Complexity

Conditions	3
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
rs	9.7
c	0
b	0
f	0
cc	3
nc	4
nop	0

<?php

namespace Robo\Collection;

use Robo\Result;
use Robo\Contract\TaskInterface;
use Robo\State\StateAwareInterface;
use Robo\State\Data;

/**
 * Creates a task wrapper that converts any Callable into an
 * object that can be used directly with a task collection.
 *
 * It is not necessary to use this class directly; Collection will
 * automatically wrap Callables when they are added.
 */
class CallableTask implements TaskInterface
{
    /**
     * @var callable
     */
    protected $fn;

    /**
     * @var \Robo\Contract\TaskInterface
     */
    protected $reference;

    public function __construct(callable $fn, TaskInterface $reference)
    {
        $this->fn = $fn;
        $this->reference = $reference;
    }

    /**
     * {@inheritdoc}
     */
    public function run()
    {
        $result = call_user_func($this->fn, $this->getState());
        // If the function returns no result, then count it
        // as a success.
        if (!isset($result)) {
            $result = Result::success($this->reference);
        }
        // If the function returns a result, it must either return
        // a \Robo\Result or an exit code.  In the later case, we
        // convert it to a \Robo\Result.
        if (!$result instanceof Result) {
            $result = new Result($this->reference, $result);
        }

        return $result;
    }

    /**
     * @return \Robo\State\Data
     */
    public function getState()
    {
        if ($this->reference instanceof StateAwareInterface) {
            return $this->reference->getState();
        }
        return new Data();
    }
}


1			<?php
2
3			namespace Robo\Collection;
4
5			use Robo\Result;
6			use Robo\Contract\TaskInterface;
7			use Robo\State\StateAwareInterface;
8			use Robo\State\Data;
9
10			/**
11			* Creates a task wrapper that converts any Callable into an
12			* object that can be used directly with a task collection.
13			*
14			* It is not necessary to use this class directly; Collection will
15			* automatically wrap Callables when they are added.
16			*/
17			class CallableTask implements TaskInterface
18			{
19			/**
20			* @var callable
21			*/
22			protected $fn;
23
24			/**
25			* @var \Robo\Contract\TaskInterface
26			*/
27			protected $reference;
28
29			public function __construct(callable $fn, TaskInterface $reference)
30			{
31			$this->fn = $fn;
32			$this->reference = $reference;
33			}
34
35			/**
36			* {@inheritdoc}
37			*/
38			public function run()
39			{
40			$result = call_user_func($this->fn, $this->getState());
41			// If the function returns no result, then count it
42			// as a success.
43			if (!isset($result)) {
44			$result = Result::success($this->reference);
45			}
46			// If the function returns a result, it must either return
47			// a \Robo\Result or an exit code. In the later case, we
48			// convert it to a \Robo\Result.
49			if (!$result instanceof Result) {
50			$result = new Result($this->reference, $result);
51			}
52
53			return $result;
54			}
55
56			/**
57			* @return \Robo\State\Data
58			*/
59			public function getState()
60			{
61			if ($this->reference instanceof StateAwareInterface) {
62			return $this->reference->getState();
63			}
64			return new Data();
65			}
66			}
67

consolidation / robo

CallableTask::run() A last analyzed 2020-08-27 17:44 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CallableTask::run() A
last analyzed 2020-08-27 17:44 UTC