Interceptor::__construct() - Code Metrics - modulate-php/artisan-interceptor - Measure and Improve Code Quality continuously with Scrutinizer

Interceptor::__construct() A
last analyzed 2023-09-18 09:47 UTC

↳ Parent: Interceptor
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	3
c	1
b	0
f	0
nc	1
nop	3
dl	0
loc	5
ccs	4
cts	4
cp	1
crap	1
rs	10
<?php
declare(strict_types=1);
namespace Modulate\Artisan\Interceptor;

use Modulate\Artisan\Interceptor\Contracts\ArtisanHandler;
use Modulate\Artisan\Interceptor\Contracts\Interceptor as InterceptorContract;
use Modulate\Artisan\Interceptor\Contracts\HandlerStack as HandlerStackContract;
use Modulate\Artisan\Interceptor\Contracts\Handler as HandlerContract;
use Modulate\Artisan\Interceptor\Contracts\OptionHandler as OptionHandlerContract;
use Modulate\Artisan\Interceptor\Enums\StackType;
use Modulate\Artisan\Interceptor\Handlers\CallbackHandler;
use Modulate\Artisan\Interceptor\Handlers\CallbackOptionHandler;
use Symfony\Component\Console\Application;

use Illuminate\Support\Arr;
use Modulate\Artisan\Interceptor\Handlers\ArtisanCallbackHandler;
use Symfony\Component\Console\Input\InputOption;
use Illuminate\Support\Traits\Macroable;

/**
 * The interceptor implements the core logic of the package and is responsible for interacting with
 * both the registered callbacks and the artisan instance
 */
class Interceptor implements InterceptorContract
{
    use Macroable;


    /**
     * @var InputOption[]
     */
    protected array $options = [];

    /**
     * @var HandlerStackContract
     */
    protected HandlerStackContract $start;

    /**
     * @var HandlerStackContract
     */
    protected HandlerStackContract $before;

    /**
     * @var HandlerStackContract
     */
    protected HandlerStackContract $after;

    /**
     * @var Application
     */
    protected $app;

    /**
     * @var bool
     */
    protected bool $started = false;


    /**
     * @param HandlerStackContract $start
     * @param HandlerStackContract $before
     * @param HandlerStackContract $after
     */
    public function __construct(HandlerStackContract $start, HandlerStackContract $before, HandlerStackContract $after)
    {
        $this->start  = $start;
        $this->before = $before;
        $this->after  = $after;
    }

    /**
     * Add a handler to the interceptor
     *
     * @param HandlerContract $handler
     * @param string|null $option
     * @return InterceptorContract
     */
    public function addHandler(HandlerContract|ArtisanHandler $handler, StackType $stack = StackType::before, string $option = null): InterceptorContract
    {
        if ($handler instanceof OptionHandlerContract) {
            $handler->setOption($option);
            $handler->setOption(/** @scrutinizer ignore-type */ $option);
        }
        if ($stack) {

            $this->{$stack->value}->push($handler);
        }

        return $this;
    }

    /**
     * Add a handler or callable to run on artisan start
     *
     * @param callable|ArtisanHandler $callable
     * @return InterceptorContract
     */
    public function start(callable|ArtisanHandler $callable): InterceptorContract
    {
        $handler = $callable;
        if (is_callable($callable)) {
            $handler = new ArtisanCallbackHandler($callable);
            $handler = new ArtisanCallbackHandler(/** @scrutinizer ignore-type */ $callable);
        }

        $this->addHandler($handler, StackType::start);
        $this->addHandler(/** @scrutinizer ignore-type */ $handler, StackType::start);

        return $this;
    }

    /**
     * Add a handler or callable to run on before command starts
     *
     * @param callable|HandlerContract $callable
     * @param string|null $option
     * @return InterceptorContract
     */
    public function before(callable|HandlerContract $callable, string $option = null): InterceptorContract
    {
        $handler = $callable;
        if (is_callable($callable)) {
            if ($option) {
                $handler = new CallbackOptionHandler(
                    $option,
                    $callable
                    /** @scrutinizer ignore-type */ $callable
                );
            } else {
                $handler = new CallbackHandler($callable);
                $handler = new CallbackHandler(/** @scrutinizer ignore-type */ $callable);
            }
        }

        $this->addHandler($handler, StackType::before, $option);
        $this->addHandler(/** @scrutinizer ignore-type */ $handler, StackType::before, $option);

        return $this;
    }

    /**
     * Add a handler or callable to run on after command finishes
     *
     * @param callable|HandlerContract $callable
     * @param string $option
     * @return InterceptorContract
     */
    public function after(callable|HandlerContract $callable, string $option = null): InterceptorContract
    {
        $handler = $callable;
        if (is_callable($callable)) {
            if ($option) {
                $handler = new CallbackOptionHandler(
                    $option,
                    $callable
                    /** @scrutinizer ignore-type */ $callable
                );
            } else {
                $handler = new CallbackHandler($callable);
                $handler = new CallbackHandler(/** @scrutinizer ignore-type */ $callable);
            }
        }

        $this->addHandler($handler, StackType::after, $option);
        $this->addHandler(/** @scrutinizer ignore-type */ $handler, StackType::after, $option);

        return $this;
    }

    /**
     * Adds an option to the application
     * @param InputOption $option The input option to add
     *
     * @return Interceptor
     */
    public function addOption(InputOption $option): Interceptor
    {
        // If the app has not yet started store a reference to the option to
        // add to the options array for adding after artisan has started,
        // otherwise add it directly to the app
        if ($this->started === false) {
            $this->options[] = $option;
        } else {
            $this->app->getDefinition()->addOption($option);
        }

        return $this;
    }

    /**
     * Add options to the interceptor
     *
     * @param InputOption[] $options
     * @return Interceptor
     */
    public function addOptions(...$options): Interceptor
    {
        // Ensure we always have a single array of options
        // regardless of if an array or list of options
        // was passed through the method
        $options = Arr::wrap($options[0]);

        foreach ($options as $option) {
            $this->addOption($option);
        }

        return $this;
    }

    /**
     * @internal
     * Called during the artisan boot process to inject the application into the handler
     * @param Application $app The symfony console application
     *
     * @return Interceptor
     */
    public function starting(Application $app): Interceptor
    {
        $this->app = $app;
        foreach ($this->options as $option) {

            $this->app->getDefinition()->addOption($option);
        }

        $this->options = [];

        $this->started = true;

        $this->handleStart($app);

        return $this;
    }

    /**
     * Check to see if artisan has been started
     */
    public function isStarted(): bool
    {
        return $this->started;
    }

    /**
     * @internal This method is only exposed for use in unit tests. Do not rely on it for your application and instead register a start handler
     *
     * @return Application
     */
    public function getArtisan(): Application
    {
        if (!$this->isStarted()) {
            throw new \RuntimeException('Artisan cannot be returned before the interceptor has started');
        }

        return $this->app;
    }

    /**
     * Handle a stack
     *
     * @param InterceptedCommand|Application $intercepted
     * @param StackType $stackType
     * @return void
     */
    protected function handle(
        InterceptedCommand|Application $intercepted,
        StackType $stackType,
    ): void {
        $stack = $stackType->value;
        // Move the stack pointer back to the start
        $this->$stack->reset();

        if (method_exists($intercepted, 'setArtisan')) {
            $intercepted->setArtisan($this->app);
        }


        if (!$this->$stack->empty()) {
            do {
                $current = $this->$stack->current();
                // Skip over any handlers where the check returns false
                if (!$current->check($intercepted)) {
                    continue;
                }
                $current->handle($intercepted);
            } while ($this->$stack->next());
        }
    }

    /**
     * Handles artisan starting stack
     *
     * @param Application $artisan
     * @return void
     */
    public function handleStart(Application $artisan): void
    {
        $this->handle($artisan, StackType::start);
    }

    /**
     * The handleBefore method is called once the CommandStarting event
     *
     * @param InterceptedCommand $intercepted
     * @return void
     */
    public function handleBefore(InterceptedCommand $intercepted): void
    {
        $this->handle($intercepted, StackType::before);
    }

    /**
     * The handleAfter method is called once the CommandFinished event
     *
     * @param InterceptedCommand $intercepted
     * @return void
     */
    public function handleAfter(InterceptedCommand $intercepted): void
    {
        $this->handle($intercepted, StackType::after);
    }
}

modulate-php / artisan-interceptor

Interceptor::__construct() A last analyzed 2023-09-18 09:47 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Interceptor::__construct() A
last analyzed 2023-09-18 09:47 UTC
