PHPinnacle\Ensign\Kernel

Complexity

Total Complexity

17

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Test Coverage

Coverage

94.87%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	recoil()	0	19	3
A	execute()	0	10	1
A	__construct()	0	3	2
A	intercept()	0	15	6
A	adapt()	0	3	2
A	throw()	0	6	2
A	interrupt()	0	3	1

<?php
/**
 * This file is part of PHPinnacle/Ensign.
 *
 * (c) PHPinnacle Team <dev@phpinnacle.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace PHPinnacle\Ensign;

use Amp\Coroutine;
use Amp\LazyPromise;
use PHPinnacle\Ensign\Exception\BadActionCall;
use PHPinnacle\Identity\UUID;

final class Kernel
{
    /**
     * @var Processor
     */
    private $processor;

    /**
     * @var callable[]
     */
    private $interruptions = [];

    /**
     * @param Processor $processor
     */
    public function __construct(Processor $processor = null)
    {
        $this->processor = $processor ?: new Processor\SimpleProcessor();
    }

    /**
     * @param string   $interrupt
     * @param callable $handler
     *
     * @return void
     */
    public function interrupt(string $interrupt, callable $handler): void
    {
        $this->interruptions[$interrupt] = $handler;
    }

    /**
     * @param callable $handler
     * @param array    $arguments
     *
     * @return Action
     */
    public function execute(callable $handler, array $arguments): Action
    {
        $id = UUID::random();

        $token   = new Token($id);
        $promise = new LazyPromise(function () use ($handler, $arguments, $token) {
            return $this->adapt($this->processor->execute($handler, $arguments), $token);
        });

        return new Action($id, $promise, $token);
    }

    /**
     * @param mixed $value
     * @param Token $token
     *
     * @return mixed
     */
    private function adapt($value, Token $token)
    {
        return $value instanceof \Generator ? new Coroutine($this->recoil($value, $token)) : $value;

It seems like $this->recoil($value, $token) can also be of type null and Amp\Coroutine; however, parameter $generator of Amp\Coroutine::__construct() does only seem to accept Generator, maybe add an additional type check?

    }

    /**
     * @param \Generator $generator
     * @param Token      $token
     *
     * @return mixed
     */
    private function recoil(\Generator $generator, Token $token)
    {
        $step = 1;

        while ($generator->valid()) {
            $token->guard();

            try {
                $value = $this->intercept($generator->key(), $generator->current());

                $generator->send(yield $this->adapt($value, $token));
            } catch (\Exception $error) {
                $this->throw($generator, $error, $step);
            } finally {
                $step++;
            }
        }

        return $this->adapt($generator->getReturn(), $token);
    }

    /**
     * @param \Generator $generator
     * @param \Exception $error
     * @param int        $step
     */
    private function throw(\Generator $generator, \Exception $error, int $step)
    {
        try {
            $generator->throw($error);

The method throw() does not exist on Generator.

        } catch (\Throwable $error) {
            throw new BadActionCall($step, $error);
        }
    }

    /**
     * @param int|string $key
     * @param mixed      $value
     *
     * @return mixed
     */
    private function intercept($key, $value)
    {
        $interrupt = \is_string($key) ? $key : $value;

        if (\is_object($interrupt)) {
            $interrupt = \get_class($interrupt);
        }

        if (!\is_string($interrupt) || !isset($this->interruptions[$interrupt])) {
            return $value;
        }

        $value = \is_array($value) ? $value : [$value];

        return $this->processor->execute($this->interruptions[$interrupt], $value);
    }
}