fab2s\NodalFlow\Interrupter

Complexity

Total Complexity

20

Size/Duplication

Total Lines	155
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	4
A	getType()	0	4	1
A	setType()	0	10	2
B	propagate()	0	38	6
A	interruptNode()	0	4	2
B	isEdgeInterruptCase()	0	14	5

<?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\FlowInterface;
use fab2s\NodalFlow\Flows\InterrupterInterface;
use fab2s\NodalFlow\Nodes\NodeInterface;
use InvalidArgumentException;

/**
 * Class Interrupter
 */
class Interrupter implements InterrupterInterface
{
    /**
     * @var string
     */
    protected $flowTarget;

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

    /**
     * interrupt type
     *
     * @var string
     */
    protected $type;

    /**
     * @var array
     */
    protected $types = [
        InterrupterInterface::TYPE_CONTINUE => 1,
        InterrupterInterface::TYPE_BREAK    => 1,
    ];

    /**
     * Interrupter constructor.
     *
     * @param null|string|FlowInterface $flowTarget , target up to Targeted Flow id or InterrupterInterface::TARGET_TOP to interrupt every parent
     * @param null|string|NodeInterface $nodeTarget
     * @param null|string               $type
     */
    public function __construct($flowTarget = null, $nodeTarget = null, $type = null)
    {
        $this->flowTarget = $flowTarget instanceof FlowInterface ? $flowTarget->getId() : $flowTarget;
        $this->nodeTarget = $nodeTarget instanceof NodeInterface ? $nodeTarget->getId() : $nodeTarget;

        if ($type !== null) {
            $this->setType($type);
        }
    }

    /**
     * @return string
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * @param string $type
     *
     * @throws InvalidArgumentException
     *
     * @return $this
     */
    public function setType($type)
    {
        if (!isset($this->types[$type])) {
            throw new InvalidArgumentException('type must be one of:' . implode(', ', array_keys($this->types)));
        }

        $this->type = $type;

        return $this;
    }

    /**
     * Trigger the Interrupt of each ancestor Flows up to a specific one, the root one
     * or none if :
     * - No FlowInterrupt is set
     * - FlowInterrupt is set at InterrupterInterface::TARGET_SELF
     * - FlowInterrupt is set at this Flow's Id
     * - FlowInterrupt is set as InterrupterInterface::TARGET_TOP and this has no parent
     *
     * Throw an exception if we reach the top after bubbling and FlowInterrupt != InterrupterInterface::TARGET_TOP
     *
     * @param FlowInterface $flow
     *
     * @throws NodalFlowException
     *
     * @return FlowInterface
     */
    public function propagate(FlowInterface $flow)
    {
        // evacuate edge cases
        if ($this->isEdgeInterruptCase($flow)) {
            // if anything had to be done, it was done first hand already
            // just make sure we propagate the eventual nodeTarget
            return $flow->setInterruptNodeId($this->nodeTarget);
        }

        $InterrupterFlowId = $flow->getId();
        if (!$this->type) {
            throw new NodalFlowException('No interrupt type set', 1, null, [
                'InterrupterFlowId' => $InterrupterFlowId,
            ]);
        }

        do {
            $lastFlowId = $flow->getId();
            if ($this->flowTarget === $lastFlowId) {
                // interrupting $flow
                return $flow->setInterruptNodeId($this->nodeTarget)->interruptFlow($this->type);
            }

            // Set interruptNodeId to true in order to make sure
            // we do not match any nodes in this flow (as it is not the target)
            $flow->setInterruptNodeId(true)->interruptFlow($this->type);
        } while ($flow = $flow->getParent());

Consider using a different name than the parameter $flow. This often makes code more readable.

        if ($this->flowTarget !== InterrupterInterface::TARGET_TOP) {
            throw new NodalFlowException('Interruption target missed', 1, null, [
                'interruptAt'       => $this->flowTarget,
                'InterrupterFlowId' => $InterrupterFlowId,
                'lastFlowId'        => $lastFlowId,
            ]);
        }

        return $flow;
    }

    /**
     * @param NodeInterface|null $node
     *
     * @return bool
     */
    public function interruptNode(NodeInterface $node = null)
    {
        return $node ? $this->nodeTarget === $node->getId() : false;
    }

    /**
     * @param FlowInterface $flow
     *
     * @return bool
     */
    protected function isEdgeInterruptCase(FlowInterface $flow)
    {
        return !$this->flowTarget ||
            (
                // asked to stop right here
                $this->flowTarget === InterrupterInterface::TARGET_SELF ||
                $this->flowTarget === $flow->getId() ||
                (
                    // target root when this Flow is root already
                    $this->flowTarget === InterrupterInterface::TARGET_TOP &&
                    !$flow->hasParent()
                )
            );
    }
}