Addiks\SymfonyGenerics\Commands\ServiceInvokeCommand

Complexity

Total Complexity

6

Size/Duplication

Total Lines	94
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	29	1
A	configure()	0	8	2
A	execute()	0	17	1
A	service()	0	8	2

<?php
/**
 * Copyright (C) 2019 Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 *
 * @license GPL-3.0
 *
 * @author Gerrit Addiks <gerrit@addiks.de>
 */

namespace Addiks\SymfonyGenerics\Commands;

use Addiks\SymfonyGenerics\Services\ArgumentCompilerInterface;
use Psr\Container\ContainerInterface;
use Webmozart\Assert\Assert;
use Symfony\Component\Console\Command\Command;
use ReflectionMethod;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

final class ServiceInvokeCommand extends Command
{

    /** @var ContainerInterface */
    private $container;

    /** @var ArgumentCompilerInterface */
    private $argumentCompiler;

    /** @var string */
    private $serviceId;

    /** @var object|null */
    private $service;

    /** @var string */
    private $method;

    /** @var array */
    private $arguments;

    /** @var string */
    private $name;

Consider using a different property name as you override a private property of the parent class.

    /** @var string */
    private $description;

Consider using a different property name as you override a private property of the parent class.

    public function __construct(
        ContainerInterface $container,
        ArgumentCompilerInterface $argumentCompiler,
        array $options
    ) {
        Assert::keyExists($options, 'service');
        Assert::keyExists($options, 'name');

        /** @var array<string, mixed> $defaults */
        $defaults = array(
            'arguments' => [],
            'method' => '__invoke',
            'description' => '',
        );

        $options = array_merge($defaults, $options);

        Assert::isArray($options['arguments']);

        $this->container = $container;
        $this->argumentCompiler = $argumentCompiler;
        $this->serviceId = $options['service'];
        $this->method = $options['method'];
        $this->arguments = $options['arguments'];
        $this->name = $options['name'];
        $this->description = $options['description'];

        parent::__construct();
    }

    protected function configure(): void
    {
        $this->setName($this->name);

        if (!empty($this->description)) {
            $this->setDescription($this->description);
        }
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        /** @var object $service */
        $service = $this->service();

        $methodReflection = new ReflectionMethod($service, $this->method);

        /** @var array $arguments */
        $arguments = $this->argumentCompiler->buildCallArguments(
            $methodReflection,
            $this->arguments
        );

        $methodReflection->invoke($service, $arguments);

        return 0;
    }

    private function service(): object
    {
        if (is_null($this->service)) {
            $this->service = $this->container->get($this->serviceId);
        }

        return $this->service;
    }

}