Spatie\SlashCommand\Handlers\SignatureHandler::parseSignature()

Complexity

Conditions	4
Paths	8

Size

Total Lines	24
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	SignatureHandler::getOption()	0	4	1
A	SignatureHandler::getArguments()	0	4	1
A	SignatureHandler::getOptions()	0	4	1

<?php

namespace Spatie\SlashCommand\Handlers;

use Illuminate\Console\Parser;
use Spatie\SlashCommand\Exceptions\InvalidHandler;
use Spatie\SlashCommand\Request;
use Symfony\Component\Console\Exception\RuntimeException;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Input\StringInput;

abstract class SignatureHandler extends BaseHandler
{
    /** @var string */
    protected $name;

    /** @var \Symfony\Component\Console\Input\StringInput */
    protected $input;

    public function __construct(Request $request)
    {
        parent::__construct($request);

        if (empty($this->signature)) {

The property signature does not exist. Did you maybe forget to declare it?

            throw InvalidHandler::signatureIsRequired(static::class);
        }
    }



    public function getArgument($foo)
    {
        return $this->input->getArgument($foo);
    }

    public function getOption($foo)
    {
        return $this->input->getOption($foo);
    }

    public function getArguments(): array
    {
        return $this->input->getArguments();
    }

    public function getOptions(): array
    {
        return $this->input->getOptions();
    }

    public function canHandle(Request $request): bool
    {
        $signatureParts = new SignatureParts($this->signature);

        if (! $this->bind($signatureParts->getSignatureWithoutCommandName())) {
            return false;
        };

        if ($request->command != $signatureParts->getSlashCommandName()) {
            return false;
        }

        if (explode(' ', $request->text)[0] = $signatureParts->getHandlerName()) {
            return false;
        }

        return true;
    }

    protected function bind(string $signature)
    {
        list($name, $arguments, $options) = Parser::parse($signature);

        $this->name = $name;

        $inputDefinition = new InputDefinition();

        foreach ($arguments as $argument) {
            $inputDefinition->addArgument($argument);
        }

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

        $this->input = new StringInput($this->request->text);

        try {
            $this->input->bind($inputDefinition);

        } catch (RuntimeException $exception) {

            throw $exception;
            return false;

return false; does not seem to be reachable.

        }

        return true;
    }
}