App\Maker\MakeGrid

Complexity

Total Complexity

21

Size/Duplication

Total Lines	205
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	getCommandName()	0	4	1
A	configureCommand()	0	11	1
A	interact()	0	34	4
A	configureDependencies()	0	3	1
A	generate()	0	23	3
A	askForNextField()	0	38	5
A	generateGridConfigFile()	0	30	1
A	getGridConfigDir()	0	7	1
A	formatFields()	0	23	3

<?php

/*
 * This file is part of monofony.
 *
 * (c) Mobizel
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace App\Maker;

use App\Maker\Helper\GridHelper;
use App\Maker\Helper\ResourceHelper;
use Symfony\Bundle\MakerBundle\ConsoleStyle;
use Symfony\Bundle\MakerBundle\DependencyBuilder;
use Symfony\Bundle\MakerBundle\Generator;
use Symfony\Bundle\MakerBundle\InputConfiguration;
use Symfony\Bundle\MakerBundle\Maker\AbstractMaker;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Question\ChoiceQuestion;
use Symfony\Component\Filesystem\Filesystem;
use Webmozart\Assert\Assert;

final class MakeGrid extends AbstractMaker
{
    /** @var string */
    private $projectDir;

    /** @var ResourceHelper */
    private $resourceHelper;

    /** @var GridHelper */
    private $gridHelper;

    /** @var Filesystem */
    private $fileSystem;

    public function __construct(string $projectDir, ResourceHelper $resourceHelper, GridHelper $gridHelper)
    {
        $this->projectDir = $projectDir;
        $this->resourceHelper = $resourceHelper;
        $this->gridHelper = $gridHelper;

        $this->fileSystem = new Filesystem();
    }

    public static function getCommandName(): string
    {
        return 'make:sylius-grid';
    }

    public function configureCommand(Command $command, InputConfiguration $inputConfig)
    {
        $command
            ->setDescription('Creates a new grid')
            ->addArgument('section', InputArgument::REQUIRED, 'Section of the grid (backend or frontend)')
            ->addArgument('resource', InputArgument::REQUIRED, 'Resource alias of the grid')
        ;

        $inputConfig->setArgumentAsNonInteractive('resource');
        $inputConfig->setArgumentAsNonInteractive('section');
    }

    public function interact(InputInterface $input, ConsoleStyle $io, Command $command)
    {
        if (!$input->getArgument('section')) {
            $question = new ChoiceQuestion(
                'Please select a section for your grid',
                ['backend', 'frontend'],
                0
            );

            $section = $io->askQuestion($question);

            $input->setArgument('section', $section);
        }

        if (!$input->getArgument('resource')) {
            $question = new ChoiceQuestion(
                'Please select a resource for your grid',
                $this->resourceHelper->getResourcesAliases(),
                0
            );

            $resourceAlias = $io->askQuestion($question);

            $input->setArgument('resource', $resourceAlias);
        }

        if ($resourceAlias = $input->getArgument('resource')) {
            Assert::true($this->resourceHelper->isResourceAliasExist($resourceAlias), sprintf(

It seems like $resourceAlias defined by $input->getArgument('resource') on line 96 can also be of type array<integer,string>; however, App\Maker\Helper\ResourceHelper::isResourceAliasExist() does only seem to accept string, maybe add an additional type check?

                    'Resource with alias %s not found',
                    $resourceAlias
                )
            );
        }
    }

    public function configureDependencies(DependencyBuilder $dependencies)
    {
    }

    public function generate(InputInterface $input, ConsoleStyle $io, Generator $generator)
    {
        $resourceAlias = $input->getArgument('resource');

        $fields = [];
        $isFirstField = true;
        while (true) {
            $newField = $this->askForNextField(
                $io,
                $this->resourceHelper->getResourceModelFromAlias($resourceAlias),

It seems like $resourceAlias defined by $input->getArgument('resource') on line 111 can also be of type array<integer,string> or null; however, App\Maker\Helper\ResourceHelper::getResourceModelFromAlias() does only seem to accept string, maybe add an additional type check?

                $isFirstField
            );
            $isFirstField = false;

            if (null === $newField) {
                break;
            }

            $fields[] = $newField;
        }

        $this->generateGridConfigFile($input, $io, $generator, $fields);
    }

    private function askForNextField(ConsoleStyle $io, string $entityClass, bool $isFirstField)

The parameter $entityClass is not used and could be removed.

    {
        $io->writeln('');

        if ($isFirstField) {
            $questionText = 'New field id (press <return> to stop adding fields)';
        } else {
            $questionText = 'Add another field? Enter the field id (or press <return> to stop adding fields)';
        }

        $fieldId = $io->ask($questionText, null, function ($name) {
            // allow it to be empty
            if (!$name) {
                return $name;
            }

            return $name;
        });

        if (!$fieldId) {
            return null;
        }

        $fieldType = $io->choice('Enter the field type', $this->gridHelper->getFilterIds(), 'string');
        $fieldLabel = $io->ask('Enter the field label', '~');
        $isSortable = $io->confirm('Is the field sortable?', true);

        if ($isSortable) {
            $fieldSortable = $io->ask('Enter the sortable path', '~');
        }

        return [
            $fieldId,
            $fieldType,
            $fieldLabel,
            $fieldSortable ?? null,
        ];
    }

    private function generateGridConfigFile(
        InputInterface $input,
        ConsoleStyle $io,

The parameter $io is not used and could be removed.

        Generator $generator,

The parameter $generator is not used and could be removed.

        array $fields
    ): void {
        $section = $input->getArgument('section');
        $resourceAlias = $input->getArgument('resource');
        [$appName, $resourceName] = $this->resourceHelper->splitResourceAlias($resourceAlias);

It seems like $resourceAlias defined by $input->getArgument('resource') on line 179 can also be of type array<integer,string> or null; however, App\Maker\Helper\ResourceHelper::splitResourceAlias() does only seem to accept string, maybe add an additional type check?

        $gridId = sprintf('%s_%s_%s', $appName, $section, $resourceName);

        $gridConfigDir = $this->getGridConfigDir($resourceAlias, $section);

It seems like $resourceAlias defined by $input->getArgument('resource') on line 179 can also be of type array<integer,string> or null; however, App\Maker\MakeGrid::getGridConfigDir() does only seem to accept string, maybe add an additional type check?

It seems like $section defined by $input->getArgument('section') on line 178 can also be of type array<integer,string> or null; however, App\Maker\MakeGrid::getGridConfigDir() does only seem to accept string, maybe add an additional type check?

        $modelClass = $this->resourceHelper->getResourceModelFromAlias($resourceAlias);

It seems like $resourceAlias defined by $input->getArgument('resource') on line 179 can also be of type array<integer,string> or null; however, App\Maker\Helper\ResourceHelper::getResourceModelFromAlias() does only seem to accept string, maybe add an additional type check?

        $formattedFields = $this->formatFields($fields);

        $this->fileSystem->dumpFile($gridConfigDir, <<<EOM
sylius_grid:
    grids:
        $gridId:
            driver:
                name: doctrine/orm
                options:
                    class: "%$modelClass%"
            fields:
                $formattedFields

EOM
);
    }

    private function getGridConfigDir(string $resourceAlias, string $section)
    {
        $resource = $this->resourceHelper->getResourceNameFromAlias($resourceAlias);
        $filename = $resource.'.yaml';

        return sprintf('%s/%s/%s', $this->projectDir.'/config/packages/grids', $section, $filename);
    }

    private function formatFields(array $fields): string
    {
        $data = '';

        foreach ($fields as $field) {
            [$id, $type, $label, $sortable] = $field;

            $data .= <<<EOM
$id:
                    type: $type
                    label: $label
EOM;

            if (null !== $sortable) {
                $data .= <<<EOM

                    sortable: $sortable
EOM;
            }
        }

        return $data;
    }
}