DoctrineRepoHelper\Command\GenerateTypeScriptInterfaceCommand::execute()

Complexity

Conditions	12
Paths	68

Size

Total Lines	81
Code Lines	50

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $destination = $input->getOption('output');
        $namespace = $input->getOption('namespace');
        $overwrite = $input->hasOption('force');
        $metaDataEntries = $this->entityManager->getMetadataFactory()->getAllMetadata();

        if (!is_dir($destination)) {

It seems like $destination can also be of type string[]; however, parameter $filename of is_dir() does only seem to accept string, maybe add an additional type check?

            mkdir($destination, 0777, true);

It seems like $destination can also be of type string[]; however, parameter $pathname of mkdir() does only seem to accept string, maybe add an additional type check?

        }

        /** @var ClassMetadata $metaData */
        foreach ($metaDataEntries as $metaData) {
            if ($filter = $input->getOption('filter')) {
                if (strpos($metaData->getName(), $filter) === false) {
                    $output->writeln(
                        sprintf(
                            'Filtering out %s...',
                            $metaData->getName()
                        ),
                        OutputInterface::VERBOSITY_VERY_VERBOSE
                    );
                    continue;
                }
            }

            $fileName = $destination . '/' . $metaData->reflClass->getShortName() . 'Interface.ts';

Accessing reflClass on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

            // TODO handle duplicate names

            $indent = '';
            $fileContent = '';

            if ($namespace) {
                $fileContent = sprintf("%snamespace %s {", $indent, $namespace) . PHP_EOL;
                $indent = '    ';
            }

            $fileContent .= $indent . sprintf(
                "%sinterface %s {" . PHP_EOL,
                $namespace ? 'export ': '',
                $metaData->reflClass->getShortName()
            );
            $indent .= '    ';

            foreach ($metaData->fieldMappings as $fieldMapping) {

Accessing fieldMappings on the interface Doctrine\Common\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

                $fileContent .= sprintf(
                    '%s%s%s: %s;' . PHP_EOL,
                    $indent,
                    $fieldMapping['fieldName'],
                    $fieldMapping['nullable'] ? '?' : '',
                    $this->toTypeScript($fieldMapping['type'])
                );
            }

            $indent = substr($indent, 0, -4);
            $fileContent .= $indent . '}' . PHP_EOL;

            if ($namespace) {
                $indent = '';
                $fileContent .= sprintf("%s}", $indent) . PHP_EOL;
            }

            if (file_exists($fileName) && !$overwrite) {
                $output->writeln(
                    sprintf(
                        '%s already exists. Skipping...',
                        $fileName
                    ),
                    OutputInterface::VERBOSITY_VERBOSE
                );

                continue;
            }

            file_put_contents($fileName, $fileContent);
        }

        $output->writeln(
            sprintf(
                'TypeScript interfaces written to "%s"',
                $destination

It seems like $destination can also be of type string[]; however, parameter $args of sprintf() does only seem to accept string, maybe add an additional type check?

            )
}