Steps::node() - Code Metrics - Inspection of "... scope topic" - ktomk/pipelines - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — steps ( cace08...74de34 )

by Tom

created 2020-03-14 19:02 UTC

Steps::node() A

↳ Parent: Steps

Complexity

Conditions	3
Paths	3

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

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

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines\File\Pipeline;

use Ktomk\Pipelines\File\ParseException;
use Ktomk\Pipelines\File\Pipeline;

/**
 * Class Steps
 *
 * A Pipeline consist of Steps. Some of them can be parallel.
 */
class Steps implements \ArrayAccess, \Countable, \IteratorAggregate
{
    /**
     * @var Pipeline
     */
    private $pipeline;

    /**
     * @var array pipeline definition
     */
    private $array;

    /**
     * @var array|Step[] steps of the pipeline
     * @see parseSteps
     */
    private $steps = array();

    /**
     * @var callable
     */
    private $getIteratorFunctor;

    /**
     * Get full iteration of steps' steps
     *
     * Gracefully handles null for steps.
     *
     * @param $steps
     *
     * @return StepsIterator
     */
    public static function fullIter($steps)
    {
        if (null === $steps) {
            return new StepsIterator(new \ArrayIterator(array()));
        }

        if (!$steps instanceof Steps) {
            throw new \InvalidArgumentException('Invalid steps argument');
        }

        $iter = $steps->getIterator();
        $iter->setNoManual(true);

        return $iter;
    }

    /**
     * Pipeline constructor.
     *
     * @param Pipeline $pipeline
     * @param array $definition
     *
     * @throws ParseException
     */
    public function __construct(Pipeline $pipeline, array $definition)
    {
        // quick validation
        if (!isset($definition[0])) {
            ParseException::__('Steps requires a tree of steps');
        }

        $this->pipeline = $pipeline;
        $this->parseSteps($definition);
    }

    /**
     * @return Pipeline
     */
    public function getPipeline()
    {
        return $this->pipeline;
    }

    /**
     * @return array|Step[]
     */
    public function getSteps()
    {
        return $this->steps;
    }

    /**
     * @param $functor
     *
     * @see getIterator
     */
    public function setGetIteratorFunctor($functor)
    {
        $this->getIteratorFunctor = $functor;
    }

    /**
     * Specify data which should be serialized to JSON
     *
     * @return array
     * @since 5.4.0
     */
    public function jsonSerialize()
    {
        $steps = array();
        foreach ($this->getSteps() as $step) {
            $steps[] = $step->jsonSerialize();
        }

        return array(
            'steps' => $steps,
        );
    }

    /* @see \ArrayAccess */

    public function offsetExists($offset)
    {
        return isset($this->steps[$offset]);
    }

    /**
     * @param mixed $offset
     *
     * @return Step
     */
    public function offsetGet($offset)
    {
        return $this->steps[$offset];
    }

    public function offsetSet($offset, $value)
    {
        throw new \BadMethodCallException('Steps offsets are read-only');
    }

    public function offsetUnset($offset)
    {
        throw new \BadMethodCallException('Steps offsets are read-only');
    }

    /* @see \Countable */

    public function count()
    {
        return count($this->steps);
    }

    /* @see \IteratorAggregate */

    /**
     * @return Step[]|StepsIterator
     */
    public function getIterator()
    {
        if (is_callable($this->getIteratorFunctor)) {
            return new StepsIterator(
                call_user_func($this->getIteratorFunctor, $this)
            );
        }

        return new StepsIterator(
            new \ArrayIterator($this->steps)
        );
    }

    private function parseSteps(array $definition)
    {
        $this->array = array();
        $this->steps = array();

        foreach ($definition as $node) {
            if (!is_array($node)) {
                ParseException::__(sprintf('Step expected, got %s', gettype($node)));
            }
            if (empty($node)) {
                ParseException::__('Step expected, got empty array');
            }

            $keys = array_keys($node);
            $name = $keys[0];
            if (!in_array($name, array('step', 'parallel'), true)) {
                ParseException::__(sprintf("Unexpected pipeline property '%s', expected 'step' or 'parallel'", $name));
            }

            $this->parseNode($node, $name);
        }
    }

    /**
     * @param int $index of step, from the zero based index in the list of steps
     * @param array $step
     * @param array $env [optional] environment variables in array notation for the new step
     *
     * @return Step
     */
    private function parseStep($index, array $step, array $env = array())
    {
        if (0 === $index && isset($step['trigger']) && 'manual' === $step['trigger']) {
            ParseException::__("The first step of a pipeline can't be manually triggered");
        }

        return new Step($this->pipeline, $index, $step, $env);
    }

    /**
     * @param array $node
     * @param $name
     */
    private function parseNode(array $node, $name)
    {
        $this->array[] = $node;
        switch ($name) {
            case 'step':
                $this->steps[] = $this->parseStep(count($this->steps), $node[$name]);

                break;
            case 'parallel':
                $this->parallel($node[$name]);

                break;
            default:
                // @codeCoverageIgnoreStart
                throw new \BadMethodCallException(
                    sprintf('Unchecked name condition: "%s"', $name)
                );
            // @codeCoverageIgnoreEnd
        }
    }

    /**
     * @param $node
     */
    private function parallel(array $node)
    {
        $group = array();
        foreach ($node as $step) {
            if (!(isset($step['step']) && is_array($step['step']))) {
                ParseException::__('Parallel step must consist of steps only');
            }
            $group[] = $step['step'];
        }

        $total = count($group);
        foreach ($group as $index => $step) {
            $this->steps[] = $this->parseStep(
                count($this->steps),
                $step,
                array(
                    'BITBUCKET_PARALLEL_STEP' => $index,
                    'BITBUCKET_PARALLEL_STEP_COUNT' => $total,
                )
            );
        }
    }
}


1		<?php
2
3		/* this file is part of pipelines */
4
5		namespace Ktomk\Pipelines\File\Pipeline;
6
7		use Ktomk\Pipelines\File\ParseException;
8		use Ktomk\Pipelines\File\Pipeline;
9
10		/**
11		* Class Steps
12		*
13		* A Pipeline consist of Steps. Some of them can be parallel.
14		*/
15		class Steps implements \ArrayAccess, \Countable, \IteratorAggregate
16		{
17		/**
18		* @var Pipeline
19		*/
20		private $pipeline;
21
22		/**
23		* @var array pipeline definition
24		*/
25		private $array;
26
27		/**
28		* @var array\|Step[] steps of the pipeline
29		* @see parseSteps
30		*/
31		private $steps = array();
32
33		/**
34		* @var callable
35		*/
36		private $getIteratorFunctor;
37
38		/**
39		* Get full iteration of steps' steps
40		*
41		* Gracefully handles null for steps.
42		*
43		* @param $steps
44		*
45		* @return StepsIterator
46		*/
47	1	public static function fullIter($steps)
48		{
49	1	if (null === $steps) {
50	1	return new StepsIterator(new \ArrayIterator(array()));
51		}
52
53	1	if (!$steps instanceof Steps) {
54	1	throw new \InvalidArgumentException('Invalid steps argument');
55		}
56
57	1	$iter = $steps->getIterator();
58	1	$iter->setNoManual(true);
59
60	1	return $iter;
61		}
62
63		/**
64		* Pipeline constructor.
65		*
66		* @param Pipeline $pipeline
67		* @param array $definition
68		*
69		* @throws ParseException
70		*/
71	7	public function __construct(Pipeline $pipeline, array $definition)
72		{
73		// quick validation
74	7	if (!isset($definition[0])) {
75	1	ParseException::__('Steps requires a tree of steps');
76		}
77
78	7	$this->pipeline = $pipeline;
79	7	$this->parseSteps($definition);
80	7	}
81
82		/**
83		* @return Pipeline
84		*/
85	1	public function getPipeline()
86		{
87	1	return $this->pipeline;
88		}
89
90		/**
91		* @return array\|Step[]
92		*/
93	4	public function getSteps()
94		{
95	4	return $this->steps;
96		}
97
98		/**
99		* @param $functor
100		*
101		* @see getIterator
102		*/
103	1	public function setGetIteratorFunctor($functor)
104		{
105	1	$this->getIteratorFunctor = $functor;
106	1	}
107
108		/**
109		* Specify data which should be serialized to JSON
110		*
111		* @return array
112		* @since 5.4.0
113		*/
114	1	public function jsonSerialize()
115		{
116	1	$steps = array();
117	1	foreach ($this->getSteps() as $step) {
118	1	$steps[] = $step->jsonSerialize();
119		}
120
121		return array(
122	1	'steps' => $steps,
123		);
124		}
125
126		/* @see \ArrayAccess */
127
128	1	public function offsetExists($offset)
129		{
130	1	return isset($this->steps[$offset]);
131		}
132
133		/**
134		* @param mixed $offset
135		*
136		* @return Step
137		*/
138	1	public function offsetGet($offset)
139		{
140	1	return $this->steps[$offset];
141		}
142
143	1	public function offsetSet($offset, $value)
144		{
145	1	throw new \BadMethodCallException('Steps offsets are read-only');
146		}
147
148	1	public function offsetUnset($offset)
149		{
150	1	throw new \BadMethodCallException('Steps offsets are read-only');
151		}
152
153		/* @see \Countable */
154
155	2	public function count()
156		{
157	2	return count($this->steps);
158		}
159
160		/* @see \IteratorAggregate */
161
162		/**
163		* @return Step[]\|StepsIterator
164		*/
165	2	public function getIterator()
166		{
167	2	if (is_callable($this->getIteratorFunctor)) {
168	1	return new StepsIterator(
169	1	call_user_func($this->getIteratorFunctor, $this)
170		);
171		}
172
173	2	return new StepsIterator(
174	2	new \ArrayIterator($this->steps)
175		);
176		}
177
178	7	private function parseSteps(array $definition)
179		{
180	7	$this->array = array();
181	7	$this->steps = array();
182
183	7	foreach ($definition as $node) {
184	7	if (!is_array($node)) {
185	1	ParseException::__(sprintf('Step expected, got %s', gettype($node)));
186		}
187	7	if (empty($node)) {
188	1	ParseException::__('Step expected, got empty array');
189		}
190
191	7	$keys = array_keys($node);
192	7	$name = $keys[0];
193	7	if (!in_array($name, array('step', 'parallel'), true)) {
194	1	ParseException::__(sprintf("Unexpected pipeline property '%s', expected 'step' or 'parallel'", $name));
195		}
196
197	7	$this->parseNode($node, $name);
198		}
199	7	}
200
201		/**
202		* @param int $index of step, from the zero based index in the list of steps
203		* @param array $step
204		* @param array $env [optional] environment variables in array notation for the new step
205		*
206		* @return Step
207		*/
208	7	private function parseStep($index, array $step, array $env = array())
209		{
210	7	if (0 === $index && isset($step['trigger']) && 'manual' === $step['trigger']) {
211	1	ParseException::__("The first step of a pipeline can't be manually triggered");
212		}
213
214	7	return new Step($this->pipeline, $index, $step, $env);
215		}
216
217		/**
218		* @param array $node
219		* @param $name
220		*/
221	7	private function parseNode(array $node, $name)
222		{
223	7	$this->array[] = $node;
224		switch ($name) {
225	7	case 'step':
226	7	$this->steps[] = $this->parseStep(count($this->steps), $node[$name]);
227
228	7	break;
229	3	case 'parallel':
230	3	$this->parallel($node[$name]);
231
232	2	break;
233		default:
234		// @codeCoverageIgnoreStart
235		throw new \BadMethodCallException(
236		sprintf('Unchecked name condition: "%s"', $name)
237		);
238		// @codeCoverageIgnoreEnd
239		}
240	7	}
241
242		/**
243		* @param $node
244		*/
245	3	private function parallel(array $node)
246		{
247	3	$group = array();
248	3	foreach ($node as $step) {
249	3	if (!(isset($step['step']) && is_array($step['step']))) {
250	1	ParseException::__('Parallel step must consist of steps only');
251		}
252	3	$group[] = $step['step'];
253		}
254
255	3	$total = count($group);
256	3	foreach ($group as $index => $step) {
257	3	$this->steps[] = $this->parseStep(
258	3	count($this->steps),
259	3	$step,
260		array(
261	3	'BITBUCKET_PARALLEL_STEP' => $index,
262	3	'BITBUCKET_PARALLEL_STEP_COUNT' => $total,
263		)
264		);
265		}
266	2	}
267		}
268

ktomk / pipelines

Push — steps ( cace08...74de34 )

Steps::node() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like