Puli\Cli\Handler\TypeCommandHandler

Complexity

Total Complexity

50

Size/Duplication

Total Lines	331
Duplicated Lines	12.99 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

97.95%

Importance

Changes	18
Bugs	6	Features	4

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	handleUpdate()	0	30	3
A	handleDelete()	0	16	2
B	parseParams()	21	24	3
A	parseUnsetParams()	0	7	2
A	typesEqual()	0	7	4
A	parseParamDescriptions()	17	17	3
F	handleList()	5	61	16
A	handleDefine()	0	17	2
A	getBindingTypeStates()	0	14	4
C	printTypeTable()	0	38	7
A	printBindingTypeState()	0	15	3

<?php

/*
 * This file is part of the puli/cli package.
 *
 * (c) Bernhard Schussek <bschussek@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Puli\Cli\Handler;

use Puli\Cli\Style\PuliTableStyle;
use Puli\Cli\Util\ArgsUtil;
use Puli\Cli\Util\StringUtil;
use Puli\Discovery\Api\Type\BindingParameter;
use Puli\Discovery\Api\Type\BindingType;
use Puli\Manager\Api\Discovery\BindingTypeDescriptor;
use Puli\Manager\Api\Discovery\BindingTypeState;
use Puli\Manager\Api\Discovery\DiscoveryManager;
use Puli\Manager\Api\Module\ModuleList;
use RuntimeException;
use Webmozart\Console\Api\Args\Args;
use Webmozart\Console\Api\IO\IO;
use Webmozart\Console\UI\Component\Table;
use Webmozart\Expression\Expr;

/**
 * Handles the "puli type" command.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <bschussek@gmail.com>
 */
class TypeCommandHandler
{
    /**
     * @var DiscoveryManager
     */
    private $discoveryManager;

    /**
     * @var ModuleList
     */
    private $modules;

    /**
     * Creates the handler.
     *
     * @param DiscoveryManager $discoveryManager The discovery manager
     * @param ModuleList       $modules          The loaded modules
     */
    public function __construct(DiscoveryManager $discoveryManager, ModuleList $modules)
    {
        $this->discoveryManager = $discoveryManager;
        $this->modules = $modules;
    }

    /**
     * Handles the "puli type --list" command.
     *
     * @param Args $args The console arguments
     * @param IO   $io   The I/O
     *
     * @return int The status code
     */
    public function handleList(Args $args, IO $io)
    {
        $moduleNames = ArgsUtil::getModuleNames($args, $this->modules);
        $states = $this->getBindingTypeStates($args);

        $printStates = count($states) > 1;
        $printModuleName = count($moduleNames) > 1;
        $printHeaders = $printStates || $printModuleName;
        $printTypeAdvice = true;
        $printBindAdvice = false;
        $indentation = $printStates && $printModuleName ? 8
            : ($printStates || $printModuleName ? 4 : 0);

        foreach ($states as $state) {
            $statePrinted = !$printStates;

            foreach ($moduleNames as $moduleName) {
                $expr = Expr::method('getContainingModule', Expr::method('getName', Expr::same($moduleName)))
                    ->andMethod('getState', Expr::same($state));

                $bindingTypes = $this->discoveryManager->findTypeDescriptors($expr);

                if (!$bindingTypes) {

The expression $bindingTypes of type Puli\Manager\Api\Discovery\BindingTypeDescriptor[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

                    continue;
                }

                $printTypeAdvice = false;

                if (!$statePrinted) {
                    $this->printBindingTypeState($io, $state);
                    $statePrinted = true;

                    // Only print the advice if at least one type was printed
                    $printBindAdvice = true;
                }

                if ($printModuleName) {

This code seems to be duplicated across your project.

                    $prefix = $printStates ? '    ' : '';
                    $io->writeLine("{$prefix}Module: $moduleName");

As per coding-style, please use concatenation or sprintf for the variable $prefix instead of interpolation.

As per coding-style, please use concatenation or sprintf for the variable $moduleName instead of interpolation.

                    $io->writeLine('');
                }

                $styleTag = BindingTypeState::ENABLED === $state ? null : 'bad';

                $this->printTypeTable($io, $bindingTypes, $styleTag, $indentation);

                if ($printHeaders) {
                    $io->writeLine('');
                }
            }
        }

        if ($printTypeAdvice) {
            $io->writeLine('No types defined. Use "puli type --define <name>" to define a type.');
        }
        if ($printBindAdvice) {
            $io->writeLine('Use "puli bind <resource> <type>" to bind a resource to a type.');
        }

        return 0;
    }

    /**
     * Handles the "puli type --define" command.
     *
     * @param Args $args The console arguments
     *
     * @return int The status code
     */
    public function handleDefine(Args $args)
    {
        $flags = $args->isOptionSet('force') ? DiscoveryManager::OVERRIDE : 0;
        $bindingParams = array();
        $paramDescriptions = array();

        $this->parseParamDescriptions($args, $paramDescriptions);
        $this->parseParams($args, $bindingParams);

        $this->discoveryManager->addRootTypeDescriptor(new BindingTypeDescriptor(
            new BindingType($args->getArgument('name'), $bindingParams),
            $args->getOption('description'),
            $paramDescriptions
        ), $flags);

        return 0;
    }

    /**
     * Handles the "puli type --update" command.
     *
     * @param Args $args The console arguments
     *
     * @return int The status code
     */
    public function handleUpdate(Args $args)
    {
        $name = $args->getArgument('name');
        $descriptorToUpdate = $this->discoveryManager->getRootTypeDescriptor($name);
        $bindingParams = $descriptorToUpdate->getType()->getParameters();
        $description = $descriptorToUpdate->getDescription();
        $paramDescriptions = $descriptorToUpdate->getParameterDescriptions();

        $this->parseParamDescriptions($args, $paramDescriptions);
        $this->parseParams($args, $bindingParams);
        $this->parseUnsetParams($args, $bindingParams, $paramDescriptions);

        if ($args->isOptionSet('description')) {
            $description = $args->getOption('description');
        }

        $updatedDescriptor = new BindingTypeDescriptor(
            new BindingType($name, $bindingParams),
            $description,
            $paramDescriptions
        );

        if ($this->typesEqual($descriptorToUpdate, $updatedDescriptor)) {
            throw new RuntimeException('Nothing to update.');
        }

        $this->discoveryManager->addRootTypeDescriptor($updatedDescriptor, DiscoveryManager::OVERRIDE);

        return 0;
    }

    /**
     * Handles the "puli type --delete" command.
     *
     * @param Args $args The console arguments
     *
     * @return int The status code
     */
    public function handleDelete(Args $args)
    {
        $typeName = $args->getArgument('name');

        if (!$this->discoveryManager->hasRootTypeDescriptor($typeName)) {
            throw new RuntimeException(sprintf(
                'The type "%s" does not exist in the module "%s".',
                $typeName,
                $this->modules->getRootModuleName()
            ));
        }

        $this->discoveryManager->removeRootTypeDescriptor($typeName);

        return 0;
    }

    /**
     * Returns the binding type states selected in the console arguments.
     *
     * @param Args $args The console arguments
     *
     * @return int[] A list of {@link BindingTypeState} constants
     */
    private function getBindingTypeStates(Args $args)
    {
        $states = array();

        if ($args->isOptionSet('enabled')) {
            $states[] = BindingTypeState::ENABLED;
        }

        if ($args->isOptionSet('duplicate')) {
            $states[] = BindingTypeState::DUPLICATE;
        }

        return $states ?: BindingTypeState::all();
    }

    /**
     * Prints the binding types in a table.
     *
     * @param IO                      $io          The I/O
     * @param BindingTypeDescriptor[] $descriptors The type descriptors to print
     * @param string                  $styleTag    The tag used to style the output

Should the type for parameter $styleTag not be string|null?

     * @param int                     $indentation The number of spaces to indent
     */
    private function printTypeTable(IO $io, array $descriptors, $styleTag = null, $indentation = 0)
    {
        $table = new Table(PuliTableStyle::borderless());

        $table->setHeaderRow(array('Type', 'Description', 'Parameters'));

        $paramTag = $styleTag ?: 'c1';
        $typeTag = $styleTag ?: 'u';

        foreach ($descriptors as $descriptor) {
            $type = $descriptor->getType();
            $parameters = array();

            foreach ($type->getParameters() as $parameter) {
                $paramString = $parameter->isRequired()
                    ? $parameter->getName()
                    : $parameter->getName().'='.StringUtil::formatValue($parameter->getDefaultValue());

                $parameters[$parameter->getName()] = "<$paramTag>$paramString</$paramTag>";

As per coding-style, please use concatenation or sprintf for the variable $paramTag instead of interpolation.

As per coding-style, please use concatenation or sprintf for the variable $paramString instead of interpolation.

            }

            $description = $descriptor->getDescription();

            if ($styleTag) {

The expression $styleTag of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

                $description = "<$styleTag>$description</$styleTag>";

As per coding-style, please use concatenation or sprintf for the variable $styleTag instead of interpolation.

As per coding-style, please use concatenation or sprintf for the variable $description instead of interpolation.

            }

            ksort($parameters);

            $table->addRow(array(
                "<$typeTag>".$descriptor->getTypeName()."</$typeTag>",

As per coding-style, please use concatenation or sprintf for the variable $typeTag instead of interpolation.

                $description,
                implode("\n", $parameters),
            ));
        }

        $table->render($io, $indentation);
    }

    /**
     * Prints the heading for a binding type state.
     *
     * @param IO  $io        The I/O
     * @param int $typeState The {@link BindingTypeState} constant
     */
    private function printBindingTypeState(IO $io, $typeState)
    {
        switch ($typeState) {
            case BindingTypeState::ENABLED:
                $io->writeLine('The following binding types are currently enabled:');
                $io->writeLine('');

                return;
            case BindingTypeState::DUPLICATE:
                $io->writeLine('The following types have duplicate definitions and are disabled:');
                $io->writeLine('');

                return;
        }
    }

    private function parseParamDescriptions(Args $args, array &$paramDescriptions)

This method seems to be duplicated in your project.

    {
        foreach ($args->getOption('param-description') as $paramDescription) {
            $pos = strpos($paramDescription, '=');

            if (false === $pos) {
                throw new RuntimeException(sprintf(
                    'The "--param-description" option expects a parameter in '.
                    'the form "key=value". Got: "%s"',
                    $paramDescription
                ));
            }

            $key = substr($paramDescription, 0, $pos);
            $paramDescriptions[$key] = StringUtil::parseValue(substr($paramDescription, $pos + 1));
        }
    }

    private function parseParams(Args $args, array &$bindingParams)
    {
        foreach ($args->getOption('param') as $parameter) {

This code seems to be duplicated across your project.

            // Optional parameter with default value
            if (false !== ($pos = strpos($parameter, '='))) {
                $key = substr($parameter, 0, $pos);

                $bindingParams[$key] = new BindingParameter(
                    $key,
                    BindingParameter::OPTIONAL,
                    StringUtil::parseValue(substr($parameter, $pos + 1))
                );

                continue;
            }

            // Required parameter
            $bindingParams[$parameter] = new BindingParameter(
                $parameter,
                BindingParameter::REQUIRED,
                null
            );
        }
    }

    private function parseUnsetParams(Args $args, array &$bindingParams, array &$paramDescriptions)
    {
        foreach ($args->getOption('unset-param') as $parameterName) {
            unset($bindingParams[$parameterName]);
            unset($paramDescriptions[$parameterName]);
        }
    }

    private function typesEqual(BindingTypeDescriptor $descriptor1, BindingTypeDescriptor $descriptor2)
    {
        return $descriptor1->getTypeName() === $descriptor2->getTypeName() &&
            $descriptor1->getDescription() === $descriptor2->getDescription() &&
            $descriptor1->getParameterDescriptions() === $descriptor2->getParameterDescriptions() &&
            $descriptor1->getType()->getParameters() === $descriptor2->getType()->getParameters();
    }
}