Thelia\Command\LoopInfoCommand::getOneLoopInfo()

Complexity

Conditions	12
Paths	648

Size

Total Lines	98
Code Lines	54

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

<?php
    protected function getOneLoopInfo(OutputInterface $output, string $loopName): void
    {
        // Get the list of all loop in the project
        $loops = $this->theliaLoop->getLoopList();

        // Search for the loop name given in parameter to get the loop class file path
        foreach ($loops as $name => $class) {
            if ($loopName === $name) {
                $loopClass = $class;
                break;
            }
        }

        // If the loop doesn't exist in the project
        if (!isset($loopClass)) {
            trigger_error("The loop name '".$loopName."' doesn't correspond to any loop in the project.\n".
                "'php Thelia loop:list' can help you find the loop name you're looking for.", \E_USER_ERROR);
        }

        $dynamicDefinitionWarning = '';
        $arguments = $this->getLoopArgs($loopClass, $dynamicDefinitionWarning);

The variable $loopClass does not seem to be defined for all execution paths leading up to this point.

        // Output display
        echo "\033[1m\033[32m".$loopName." loop\033[0m\n\n";
        echo "\033[1m\033[4mArguments\033[0m\n";
        echo $dynamicDefinitionWarning."\n" ?? '';

        // An array to save all arguments and associated details
        $tableToSort = [];

        // An array to save the enum possible values
        $additionalArrays = [];
        // Another one to save the arguments relative to the previous enum possible values
        $additionalTitle = [];
        $positionInAdditionalArrays = 0;

        foreach ($arguments as $argument) {
            if ($argument->mandatory) {
                $mandatory = 'yes';
            } else {
                $mandatory = '';
            }

            // To access the protected attribute of the argument types
            $reflectionClass = new \ReflectionClass($argument->type);
            $property = $reflectionClass->getProperty('types');
            $property->setAccessible(true);
            $types = $property->getValue($argument->type);
            // To get the types list in string format
            $formatedTypes = '';
            $nbTypes = 0;
            $argumentExample = '';
            $nbEnumExample = 0;

            // There are one or many type foreach argument
            foreach ($types as $type) {
                $this->parseType($nbTypes, $formatedTypes, $type, $nbEnumExample, $argumentExample, $argument->name, $additionalArrays, $additionalTitle, $positionInAdditionalArrays);
            }

            if ($argument->default === false) {
                // If the default argument value is a Boolean false, no value is displayed
                // Conversion in string format
                $default = 'false';
            } else {
                $default = $argument->default;
            }

            $tableToSort[] = [$argument->name, $formatedTypes, $default, $mandatory, $argumentExample];
        }

        sort($tableToSort);

        // To get a table display of the arguments
        $table = new Table($output);
        foreach ($tableToSort as $line) {
            $table->addRow([$line[0], $line[1], $line[2], $line[3], $line[4]]);
        }
        $table
            ->setHeaders(['Name', 'Type', 'Default', 'Mandatory', 'Examples'])
            ->render()
        ;

        if ($additionalArrays != []) {
            echo "\n\033[1m\033[4mEnum possible values\033[0m\n";
        }

        $additionalTitleIterator = 0;
        // To get a table display of all the enum possible values
        // There may be several enumerable arguments for the loop
        foreach ($additionalArrays as $additionalArray) {
            $newTable = new Table($output);
            $newTable->setHeaders([$additionalTitle[$additionalTitleIterator]]);
            // There may also be several possible value foreach enumerable argument
            foreach ($additionalArray as $enumPossibility) {
                $newTable->addRow($enumPossibility);
            }
            ++$additionalTitleIterator;
            $newTable->render();
        }