League\Pipeline\Fork

Complexity

Total Complexity

9

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setForks()	0	4	1
A	pipeline()	0	4	1
A	join()	0	9	2
A	disjoin()	0	12	2
A	__invoke()	0	8	2

<?php

namespace League\Pipeline;


class Fork implements ForkInterface
{
    /**
     * @var Pipeline
     */
    private $parent;

    /**
     * @var array callable
     */
    protected $forks = [];

    /**
     * @var callable
     */
    protected $resolver;

    /**
     * Fork constructor.
     * @param callable|null $resolver
     * @param array $forks
     */
    public function __construct(callable $resolver = null, $forks = [])
    {
        $this->resolver = $resolver;
        $this->forks = $forks;
    }

    public function setForks($forks)
    {
        $this->forks = $forks;
    }

    public function pipeline(Pipeline $pipeline)
    {
        $this->parent = $pipeline;
    }

    /**
     * @inheritdoc
     */
    public function join(callable $resolver = null)
    {
        if($resolver != null)
        {
            $this->resolver = $resolver;
        }

        return $this->parent;
    }

    /**
     * @inheritdoc
     */
    public function disjoin(string $tag, callable $stage = null)
    {
        $pipeline = new DisjointAwarePipeline($this);

        if($stage != null)
        {
            $pipeline = $pipeline->pipe($stage);
        }

        $this->forks[$tag] = $pipeline;
        return $pipeline;
    }

    /**
     * Chooses a fork or short-circuits based on $resolver
     *
     * @param mixed $payload
     * @return mixed
     */
    public function __invoke($payload)
    {
        $flowTo = call_user_func($this->resolver, $payload);
        if($flowTo === false) return $payload;
        $result = $this->forks[$flowTo]->process($payload);

        return $result;
    }
}