NodalFlow::replace() - Code Metrics - Inspection of "welcome replace" - fab2s/NodalFlow - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c61f64...fb85af )

by Fabrice

created 2017-12-31 12:27 UTC

NodalFlow::replace() A

↳ Parent: NodalFlow

Complexity

Conditions	2
Paths	2

Size

Total Lines	15
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	15
c	0
b	0
f	0
rs	9.4285
cc	2
eloc	9
nc	2
nop	2

<?php

/*
 * This file is part of NodalFlow.
 *     (c) Fabrice de Stefanis / https://github.com/fab2s/NodalFlow
 * This source file is licensed under the MIT license which you will
 * find in the LICENSE file or at https://opensource.org/licenses/MIT
 */

namespace fab2s\NodalFlow;

use fab2s\NodalFlow\Flows\FlowAbstract;
use fab2s\NodalFlow\Flows\FlowInterface;
use fab2s\NodalFlow\Flows\FlowMap;
use fab2s\NodalFlow\Flows\FlowRegistry;
use fab2s\NodalFlow\Flows\FlowStatus;
use fab2s\NodalFlow\Nodes\BranchNodeInterface;
use fab2s\NodalFlow\Nodes\ExecNodeInterface;
use fab2s\NodalFlow\Nodes\NodeInterface;
use fab2s\NodalFlow\Nodes\TraversableNodeInterface;

/**
 * Class NodalFlow
 */
class NodalFlow extends FlowAbstract
{
    /**
     * Flow steps triggering callbacks
     */
    const FLOW_START    = 'start';
    const FLOW_PROGRESS = 'progress';
    const FLOW_SUCCESS  = 'success';
    const FLOW_FAIL     = 'fail';

    /**
     * @var array
     */
    protected $flowIncrements = [];

    /**
     * The current Node index
     *
     * @var int
     */
    protected $nodeIdx = 0;

    /**
     * The last index value
     *
     * @var int
     */
    protected $lastIdx = 0;

    /**
     * The number of Node in this Flow
     *
     * @var int
     */
    protected $nodeCount = 0;

    /**
     * Instantiate a Flow
     */
    public function __construct()
    {
        $this->flowMap  = new FlowMap($this, $this->flowIncrements);
        $this->registry = new FlowRegistry;
    }

    /**
     * Adds a Node to the flow
     *
     * @param NodeInterface $node
     *
     * @throws NodalFlowException
     *
     * @return $this
     */
    public function add(NodeInterface $node)
    {
        if ($node instanceof BranchNodeInterface) {
            // this node is a branch
            $childFlow = $node->getPayload();
            $this->branchFlowCheck($childFlow);
            $childFlow->setParent($this);
        }

        $node->setCarrier($this);

        $this->flowMap->register($node, $this->nodeIdx);
        $this->nodes[$this->nodeIdx] = $node;

        ++$this->nodeIdx;

        return $this;
    }

    /**
     * Adds a Payload Node to the Flow
     *
     * @param callable $payload
     * @param mixed    $isAReturningVal
     * @param mixed    $isATraversable
     *
     * @throws NodalFlowException
     *
     * @return $this
     */
    public function addPayload(callable $payload, $isAReturningVal, $isATraversable = false)
    {
        $node = PayloadNodeFactory::create($payload, $isAReturningVal, $isATraversable);

        $this->add($node);

        return $this;
    }

    /**
     * Replaces a node with another one
     *
     * @param int           $nodeIdx
     * @param NodeInterface $node
     *
     * @throws NodalFlowException
     *
     * @return $this
     */
    public function replace($nodeIdx, NodeInterface $node)
    {
        if (!isset($this->nodes[$nodeIdx])) {
            throw new NodalFlowException('Argument 1 should be a valid index in nodes', 1, null, [
                'nodeIdx' => $nodeIdx,
                'node'    => get_class($node),
            ]);
        }

        $node->setCarrier($this);
        $this->nodes[$nodeIdx] = $node;
        $this->flowMap->register($node, $nodeIdx);

        return $this;
    }

    /**
     * @param string|null $nodeId
     * @param mixed|null  $param
     *
     * @throws NodalFlowException
     *
     * @return mixed
     */
    public function sendTo($nodeId = null, $param = null)
    {
        $nodeIndex = 0;
        if ($nodeId !== null) {
            if (!($nodeIndex = $this->flowMap->getNodeIndex($nodeId))) {
                throw new NodalFlowException('Cannot sendTo without valid Node target', 1, null, [
                    'flowId' => $this->getId(),
                    'nodeId' => $nodeId,
                ]);
            }
        }

        return $this->rewind()->recurse($param, $nodeIndex);
    }

    /**
     * Execute the flow
     *
     * @param null|mixed $param The eventual init argument to the first node
     *                          or, in case of a branch, the last relevant
     *                          argument from upstream Flow
     *
     * @throws NodalFlowException
     *
     * @return mixed the last result of the
     *               last returning value node
     */
    public function exec($param = null)
    {
        try {
            $result = $this->rewind()
                    ->flowStart()
                    ->recurse($param);

            // set flowStatus to make sure that we have the proper
            // value in flowEnd even when overridden without (or when
            // improperly) calling parent
            if ($this->flowStatus->isRunning()) {
                $this->flowStatus = new FlowStatus(FlowStatus::FLOW_CLEAN);
            }

            $this->flowEnd();

            return $result;
        } catch (\Exception $e) {
            $this->flowStatus = new FlowStatus(FlowStatus::FLOW_EXCEPTION);
            $this->flowEnd();
            if ($e instanceof NodalFlowException) {
                throw $e;
            }

            throw new NodalFlowException('Flow execution failed', 0, $e, [
                'nodeMap' => $this->getNodeMap(),
            ]);
        }
    }

    /**
     * Rewinds the Flow
     *
     * @return $this
     */
    public function rewind()
    {
        $this->nodeCount       = count($this->nodes);
        $this->lastIdx         = $this->nodeCount - 1;
        $this->break           = false;
        $this->continue        = false;
        $this->interruptNodeId = null;

        return $this;
    }

    /**
     * @param FlowInterface $flow
     *
     * @throws NodalFlowException
     */
    protected function branchFlowCheck(FlowInterface $flow)
    {
        if (
            // this flow has parent already
            $flow->hasParent() ||
            // adding root flow in itself
            $this->getRootFlow($flow)->getId() === $this->getRootFlow($this)->getId()
        ) {
            throw new NodalFlowException('Cannot reuse Flow within Branches', 1, null, [
                'flowId'             => $this->getId(),
                'BranchFlowId'       => $flow->getId(),
                'BranchFlowParentId' => $flow->hasParent() ? $flow->getParent()->getId() : null,
            ]);
        }
    }

    /**
     * Triggered just before the flow starts
     *
     * @return $this
     */
    protected function flowStart()
    {
        $this->flowMap->incrementFlow('num_exec')->flowStart();
        $this->triggerCallback(static::FLOW_START);

        // flow is started
        $this->flowStatus = new FlowStatus(FlowStatus::FLOW_RUNNING);

        return $this;
    }

    /**
     * Triggered right after the flow stops
     *
     * @return $this
     */
    protected function flowEnd()
    {
        $this->flowMap->flowEnd();

        $this->triggerCallback($this->flowStatus->isException() ? static::FLOW_FAIL : static::FLOW_SUCCESS);

        return $this;
    }

    /**
     * Recurse over nodes which may as well be Flows and
     * Traversable ...
     * Welcome to the abysses of recursion or iter-recursion ^^
     *
     * `recurse` perform kind of an hybrid recursion as the
     * Flow is effectively iterating and recurring over its
     * Nodes, which may as well be seen as over itself
     *
     * Iterating tends to limit the amount of recursion levels:
     * recursion is only triggered when executing a Traversable
     * Node's downstream Nodes while every consecutive exec
     * Nodes are executed within a while loop.
     * And recursion keeps the size of the recursion context
     * to a minimum as pretty much everything is done by the
     * iterating instance
     *
     * @param mixed $param
     * @param int   $nodeIdx
     *
     * @return mixed the last value returned by the last
     *               returning value Node in the flow
     */
    protected function recurse($param = null, $nodeIdx = 0)
    {
        while ($nodeIdx <= $this->lastIdx) {
            $node      = $this->nodes[$nodeIdx];
            $nodeStats = &$this->flowMap->getNodeStat($node->getId());

            $returnVal = $node->isReturningVal();

            if ($node->isTraversable()) {
                /** @var TraversableNodeInterface $node */
                foreach ($node->getTraversable($param) as $value) {
                    if ($returnVal) {
                        // pass current $value as next param
                        $param = $value;
                    }

                    ++$nodeStats['num_iterate'];
                    if (!($nodeStats['num_iterate'] % $this->progressMod)) {
                        $this->triggerCallback(static::FLOW_PROGRESS, $node);
                    }

                    $param = $this->recurse($param, $nodeIdx + 1);
                    if ($this->continue) {
                        if ($this->continue = $this->interruptNode($node)) {
                            // since we want to bubble the continue upstream
                            // we break here waiting for next $param if any
                            ++$nodeStats['num_break'];
                            break;
                        }

                        // we drop one iteration
                        ++$nodeStats['num_continue'];
                        continue;
                    }

                    if ($this->break) {
                        // we drop all subsequent iterations
                        ++$nodeStats['num_break'];
                        $this->break = $this->interruptNode($node);
                        break;
                    }
                }

                // we reached the end of this Traversable and executed all its downstream Nodes
                ++$nodeStats['num_exec'];

                return $param;
            }

            /** @var ExecNodeInterface $node */
            $value = $node->exec($param);
            ++$nodeStats['num_exec'];

            if ($this->continue) {
                ++$nodeStats['num_continue'];
                // a continue does not need to bubble up unless
                // it specifically targets a node in this flow
                // or targets an upstream flow
                $this->continue = $this->interruptNode($node);

                return $param;
            }

            if ($this->break) {
                ++$nodeStats['num_break'];
                // a break always need to bubble up to the first upstream Traversable if any
                return $param;
            }

            if ($returnVal) {
                // pass current $value as next param
                $param = $value;
            }

            ++$nodeIdx;
        }

        // we reached the end of this recursion
        return $param;
    }
}


1			<?php
2
3			/*
4			* This file is part of NodalFlow.
5			* (c) Fabrice de Stefanis / https://github.com/fab2s/NodalFlow
6			* This source file is licensed under the MIT license which you will
7			* find in the LICENSE file or at https://opensource.org/licenses/MIT
8			*/
9
10			namespace fab2s\NodalFlow;
11
12			use fab2s\NodalFlow\Flows\FlowAbstract;
13			use fab2s\NodalFlow\Flows\FlowInterface;
14			use fab2s\NodalFlow\Flows\FlowMap;
15			use fab2s\NodalFlow\Flows\FlowRegistry;
16			use fab2s\NodalFlow\Flows\FlowStatus;
17			use fab2s\NodalFlow\Nodes\BranchNodeInterface;
18			use fab2s\NodalFlow\Nodes\ExecNodeInterface;
19			use fab2s\NodalFlow\Nodes\NodeInterface;
20			use fab2s\NodalFlow\Nodes\TraversableNodeInterface;
21
22			/**
23			* Class NodalFlow
24			*/
25			class NodalFlow extends FlowAbstract
26			{
27			/**
28			* Flow steps triggering callbacks
29			*/
30			const FLOW_START = 'start';
31			const FLOW_PROGRESS = 'progress';
32			const FLOW_SUCCESS = 'success';
33			const FLOW_FAIL = 'fail';
34
35			/**
36			* @var array
37			*/
38			protected $flowIncrements = [];
39
40			/**
41			* The current Node index
42			*
43			* @var int
44			*/
45			protected $nodeIdx = 0;
46
47			/**
48			* The last index value
49			*
50			* @var int
51			*/
52			protected $lastIdx = 0;
53
54			/**
55			* The number of Node in this Flow
56			*
57			* @var int
58			*/
59			protected $nodeCount = 0;
60
61			/**
62			* Instantiate a Flow
63			*/
64			public function __construct()
65			{
66			$this->flowMap = new FlowMap($this, $this->flowIncrements);
67			$this->registry = new FlowRegistry;
68			}
69
70			/**
71			* Adds a Node to the flow
72			*
73			* @param NodeInterface $node
74			*
75			* @throws NodalFlowException
76			*
77			* @return $this
78			*/
79			public function add(NodeInterface $node)
80			{
81			if ($node instanceof BranchNodeInterface) {
82			// this node is a branch
83			$childFlow = $node->getPayload();
84			$this->branchFlowCheck($childFlow);
85			$childFlow->setParent($this);
86			}
87
88			$node->setCarrier($this);
89
90			$this->flowMap->register($node, $this->nodeIdx);
91			$this->nodes[$this->nodeIdx] = $node;
92
93			++$this->nodeIdx;
94
95			return $this;
96			}
97
98			/**
99			* Adds a Payload Node to the Flow
100			*
101			* @param callable $payload
102			* @param mixed $isAReturningVal
103			* @param mixed $isATraversable
104			*
105			* @throws NodalFlowException
106			*
107			* @return $this
108			*/
109			public function addPayload(callable $payload, $isAReturningVal, $isATraversable = false)
110			{
111			$node = PayloadNodeFactory::create($payload, $isAReturningVal, $isATraversable);
112
113			$this->add($node);
114
115			return $this;
116			}
117
118			/**
119			* Replaces a node with another one
120			*
121			* @param int $nodeIdx
122			* @param NodeInterface $node
123			*
124			* @throws NodalFlowException
125			*
126			* @return $this
127			*/
128			public function replace($nodeIdx, NodeInterface $node)
129			{
130			if (!isset($this->nodes[$nodeIdx])) {
131			throw new NodalFlowException('Argument 1 should be a valid index in nodes', 1, null, [
132			'nodeIdx' => $nodeIdx,
133			'node' => get_class($node),
134			]);
135			}
136
137			$node->setCarrier($this);
138			$this->nodes[$nodeIdx] = $node;
139			$this->flowMap->register($node, $nodeIdx);
140
141			return $this;
142			}
143
144			/**
145			* @param string\|null $nodeId
146			* @param mixed\|null $param
147			*
148			* @throws NodalFlowException
149			*
150			* @return mixed
151			*/
152			public function sendTo($nodeId = null, $param = null)
153			{
154			$nodeIndex = 0;
155			if ($nodeId !== null) {
156			if (!($nodeIndex = $this->flowMap->getNodeIndex($nodeId))) {
157			throw new NodalFlowException('Cannot sendTo without valid Node target', 1, null, [
158			'flowId' => $this->getId(),
159			'nodeId' => $nodeId,
160			]);
161			}
162			}
163
164			return $this->rewind()->recurse($param, $nodeIndex);
165			}
166
167			/**
168			* Execute the flow
169			*
170			* @param null\|mixed $param The eventual init argument to the first node
171			* or, in case of a branch, the last relevant
172			* argument from upstream Flow
173			*
174			* @throws NodalFlowException
175			*
176			* @return mixed the last result of the
177			* last returning value node
178			*/
179			public function exec($param = null)
180			{
181			try {
182			$result = $this->rewind()
183			->flowStart()
184			->recurse($param);
185
186			// set flowStatus to make sure that we have the proper
187			// value in flowEnd even when overridden without (or when
188			// improperly) calling parent
189			if ($this->flowStatus->isRunning()) {
190			$this->flowStatus = new FlowStatus(FlowStatus::FLOW_CLEAN);
191			}
192
193			$this->flowEnd();
194
195			return $result;
196			} catch (\Exception $e) {
197			$this->flowStatus = new FlowStatus(FlowStatus::FLOW_EXCEPTION);
198			$this->flowEnd();
199			if ($e instanceof NodalFlowException) {
200			throw $e;
201			}
202
203			throw new NodalFlowException('Flow execution failed', 0, $e, [
204			'nodeMap' => $this->getNodeMap(),
205			]);
206			}
207			}
208
209			/**
210			* Rewinds the Flow
211			*
212			* @return $this
213			*/
214			public function rewind()
215			{
216			$this->nodeCount = count($this->nodes);
217			$this->lastIdx = $this->nodeCount - 1;
218			$this->break = false;
219			$this->continue = false;
220			$this->interruptNodeId = null;
221
222			return $this;
223			}
224
225			/**
226			* @param FlowInterface $flow
227			*
228			* @throws NodalFlowException
229			*/
230			protected function branchFlowCheck(FlowInterface $flow)
231			{
232			if (
233			// this flow has parent already
234			$flow->hasParent() \|\|
235			// adding root flow in itself
236			$this->getRootFlow($flow)->getId() === $this->getRootFlow($this)->getId()
237			) {
238			throw new NodalFlowException('Cannot reuse Flow within Branches', 1, null, [
239			'flowId' => $this->getId(),
240			'BranchFlowId' => $flow->getId(),
241			'BranchFlowParentId' => $flow->hasParent() ? $flow->getParent()->getId() : null,
242			]);
243			}
244			}
245
246			/**
247			* Triggered just before the flow starts
248			*
249			* @return $this
250			*/
251			protected function flowStart()
252			{
253			$this->flowMap->incrementFlow('num_exec')->flowStart();
254			$this->triggerCallback(static::FLOW_START);
255
256			// flow is started
257			$this->flowStatus = new FlowStatus(FlowStatus::FLOW_RUNNING);
258
259			return $this;
260			}
261
262			/**
263			* Triggered right after the flow stops
264			*
265			* @return $this
266			*/
267			protected function flowEnd()
268			{
269			$this->flowMap->flowEnd();
270
271			$this->triggerCallback($this->flowStatus->isException() ? static::FLOW_FAIL : static::FLOW_SUCCESS);
272
273			return $this;
274			}
275
276			/**
277			* Recurse over nodes which may as well be Flows and
278			* Traversable ...
279			* Welcome to the abysses of recursion or iter-recursion ^^
280			*
281			* `recurse` perform kind of an hybrid recursion as the
282			* Flow is effectively iterating and recurring over its
283			* Nodes, which may as well be seen as over itself
284			*
285			* Iterating tends to limit the amount of recursion levels:
286			* recursion is only triggered when executing a Traversable
287			* Node's downstream Nodes while every consecutive exec
288			* Nodes are executed within a while loop.
289			* And recursion keeps the size of the recursion context
290			* to a minimum as pretty much everything is done by the
291			* iterating instance
292			*
293			* @param mixed $param
294			* @param int $nodeIdx
295			*
296			* @return mixed the last value returned by the last
297			* returning value Node in the flow
298			*/
299			protected function recurse($param = null, $nodeIdx = 0)
300			{
301			while ($nodeIdx <= $this->lastIdx) {
302			$node = $this->nodes[$nodeIdx];
303			$nodeStats = &$this->flowMap->getNodeStat($node->getId());
304
305			$returnVal = $node->isReturningVal();
306
307			if ($node->isTraversable()) {
308			/** @var TraversableNodeInterface $node */
309			foreach ($node->getTraversable($param) as $value) {
310			if ($returnVal) {
311			// pass current $value as next param
312			$param = $value;
313			}
314
315			++$nodeStats['num_iterate'];
316			if (!($nodeStats['num_iterate'] % $this->progressMod)) {
317			$this->triggerCallback(static::FLOW_PROGRESS, $node);
318			}
319
320			$param = $this->recurse($param, $nodeIdx + 1);
321			if ($this->continue) {
322			if ($this->continue = $this->interruptNode($node)) {
323			// since we want to bubble the continue upstream
324			// we break here waiting for next $param if any
325			++$nodeStats['num_break'];
326			break;
327			}
328
329			// we drop one iteration
330			++$nodeStats['num_continue'];
331			continue;
332			}
333
334			if ($this->break) {
335			// we drop all subsequent iterations
336			++$nodeStats['num_break'];
337			$this->break = $this->interruptNode($node);
338			break;
339			}
340			}
341
342			// we reached the end of this Traversable and executed all its downstream Nodes
343			++$nodeStats['num_exec'];
344
345			return $param;
346			}
347
348			/** @var ExecNodeInterface $node */
349			$value = $node->exec($param);
350			++$nodeStats['num_exec'];
351
352			if ($this->continue) {
353			++$nodeStats['num_continue'];
354			// a continue does not need to bubble up unless
355			// it specifically targets a node in this flow
356			// or targets an upstream flow
357			$this->continue = $this->interruptNode($node);
358
359			return $param;
360			}
361
362			if ($this->break) {
363			++$nodeStats['num_break'];
364			// a break always need to bubble up to the first upstream Traversable if any
365			return $param;
366			}
367
368			if ($returnVal) {
369			// pass current $value as next param
370			$param = $value;
371			}
372
373			++$nodeIdx;
374			}
375
376			// we reached the end of this recursion
377			return $param;
378			}
379			}
380

fab2s / NodalFlow

Push — master ( c61f64...fb85af )

NodalFlow::replace() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like