DoctrinevizCommand::configure() - Code Metrics - Inspection of "Bump symfony/phpunit-bridge from 3.4.0 to 3.4.26" - janalis/doctrineviz - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#13)

unknown
created 2021-02-24 09:27 UTC
DoctrinevizCommand::configure() A

↳ Parent: DoctrinevizCommand
Complexity

Conditions	1
Paths	1
Size

Total Lines	9
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	7
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	9
rs	10
<?php

/*
 * This file is part of the doctrineviz package
 *
 * Copyright (c) 2017 Pierre Hennequart
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * Feel free to edit as you please, and have fun.
 *
 * @author Pierre Hennequart <[email protected]>
 */

declare(strict_types=1);

namespace Janalis\Doctrineviz\Command;

use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Mapping\ClassMetadataInfo;
use Janalis\Doctrineviz\Graphviz\Graph;
use Janalis\Doctrineviz\Graphviz\Graphviz;
use Janalis\Doctrineviz\Graphviz\Record;
use Janalis\Doctrineviz\Graphviz\Vertex;
use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * doctrineviz command.
 */
class DoctrinevizCommand extends ContainerAwareCommand
{
    const NAME = 'doctrine:generate:viz';

    /**
     * Configure.
     */
    protected function configure()
    {
        $this
            ->setName(static::NAME)
            ->setHelp('Generates database mapping')
            ->addOption('pattern', 'p', InputOption::VALUE_OPTIONAL, 'Filter entities that match that PCRE pattern', '.*')
            ->addOption('binary', 'b', InputOption::VALUE_OPTIONAL, 'Path to graphviz dot binary')
            ->addOption('format', 'f', InputOption::VALUE_OPTIONAL, 'Output format', 'png')
            ->addOption('output-path', 'o', InputOption::VALUE_OPTIONAL, 'Output path');
    }

    /**
     * Execute.
     *
     * @param InputInterface  $input
     * @param OutputInterface $output
     *
     * @return int Status code
     */
    public function execute(InputInterface $input, OutputInterface $output): int
    {
        $pattern = '/'.$input->getOption('pattern').'/';
        /** @var EntityManager $em */
        $em = $this->getContainer()->get('doctrine')->getManager();
        $entities = array_filter($em->getConfiguration()->getMetadataDriverImpl()->getAllClassNames(), function ($entity) use ($pattern) {
            return preg_match($pattern, $entity);
        });
        $graph = new Graph();
        $graph->createAttribute('rankdir', 'LR');
        $graph->createAttribute('ranksep', '3');
        /** @var Vertex[] $tables */
        $tables = [];
        foreach ($entities as $entity) {
            $metadata = $em->getClassMetadata($entity);
            if ($metadata->getFieldNames()) {
                $table = $graph->createVertex($metadata->getTableName());
                $table->createAttribute('shape', 'record');
                $table->createAttribute('width', '4');
                foreach ($metadata->getFieldNames() as $fieldName) {
                    $fieldMapping = $metadata->getFieldMapping($fieldName);
                    $table->addRecord(new Record($this->getFieldMappingDisplayName($fieldMapping)));
                }
                $tables[$entity] = $table;
            }
        }
        foreach ($entities as $entity) {
            $metadata = $em->getClassMetadata($entity);
            foreach ($metadata->getAssociationMappings() as $associationMapping) {
                if (array_key_exists('joinTable', $associationMapping) && $associationMapping['joinTable']) {
                    $joinTable = $associationMapping['joinTable'];
                    $table = $graph->createVertex($joinTable['name']);
                    $table->createAttribute('shape', 'record');
                    $table->createAttribute('width', '4');
                    if (array_key_exists('joinColumns', $joinTable)) {
                        $sourceEntity = $associationMapping['sourceEntity'];
                        $joinColumns = $joinTable['joinColumns'];
                        foreach ($joinColumns as $joinColumn) {
                            $record = new Record($this->getFieldMappingDisplayName($joinColumn, 'name'));
                            $table->addRecord($record);
                            $nullable = false;
                            if (array_key_exists($sourceEntity, $tables)) {
                                $name = $this->getFieldMappingDisplayName($joinColumn, 'referencedColumnName');
                                $nullable = $joinColumn['nullable'];
                                $tables[$sourceEntity]->addRecord($to = $graph->getVertex($tables[$sourceEntity]->getId())->getRecord($name) ?: new Record($name));
                            }
                            $edge = $record->addEdgeTo($to);

                            $edge->createAttribute('headlabel', $nullable ? '0..1' : '1');
                                   createAttribute('headlabel', $nullable ? '0..1' : '1');
                            $edge->createAttribute('taillabel', '*');
                        }
                    }
                    if (array_key_exists('inverseJoinColumns', $joinTable)) {
                        $targetEntity = $associationMapping['targetEntity'];
                        $inverseJoinColumns = $joinTable['inverseJoinColumns'];
                        foreach ($inverseJoinColumns as $inverseJoinColumn) {
                            $record = new Record($this->getFieldMappingDisplayName($inverseJoinColumn, 'name'));
                            $table->addRecord($record);
                            $nullable = false;
                            if (array_key_exists($targetEntity, $tables)) {
                                $name = $this->getFieldMappingDisplayName($inverseJoinColumn, 'referencedColumnName');
                                $nullable = $inverseJoinColumn['nullable'];
                                $tables[$targetEntity]->addRecord($to = $graph->getVertex($tables[$targetEntity]->getId())->getRecord($name) ?: new Record($name));
                            }
                            $edge = $record->addEdgeTo($to);
                            $edge->createAttribute('headlabel', $nullable ? '0..1' : '1');
                            $edge->createAttribute('taillabel', '*');
                        }
                    }
                    $tables[$table->getId()] = $table;
                } else {
                    $targetEntity = $associationMapping['targetEntity'];
                    if (!array_key_exists($targetEntity, $tables) || !array_key_exists('sourceToTargetKeyColumns', $associationMapping)) {
                        continue;
                    }
                    $columns = $associationMapping['sourceToTargetKeyColumns'];
                    $to = $graph->getVertex($tables[$targetEntity]->getId())->getRecord(array_values($columns)[0]);
                    if (!$to) {
                        $to = new Record($this->getFieldMappingDisplayName([
                            'columnName' => array_values($columns)[0],
                        ]));
                        $tables[$targetEntity]->addRecord($to);
                    }
                    $from = $graph->getVertex($tables[$entity]->getId())->getRecord(array_keys($columns)[0]);
                    if (!$from) {
                        $from = new Record($this->getFieldMappingDisplayName([
                            'columnName' => array_keys($columns)[0],
                        ]));
                        $tables[$entity]->addRecord($from);
                    }
                    $joinColumn = $associationMapping['joinColumns'][0];
                    $nullable = !array_key_exists('nullable', $joinColumn) || $joinColumn['nullable'];
                    $edge = $from->addEdgeTo($to);
                    $edge = $from->addEdgeTo($to);
                    $edge->createAttribute('headlabel', $nullable ? '0..1' : '1');
                    if (array_key_exists('type', $associationMapping)) {
                        $edge->createAttribute('taillabel', ClassMetadataInfo::ONE_TO_ONE === $associationMapping['type'] ? '1' : '*');
                    }
                }
            }
        }
        ksort($tables);
        $format = $input->getOption('format', 'png');
        $format = $input->getOption('format', 'png');
        $binary = $input->getOption('binary', null);
        $path = $input->getOption('output-path', null);
        $graphviz = new Graphviz($format, $binary);
        if ($path) {
            return (int) !file_put_contents($path, $graphviz->createImageData($graph));
        }
        if ('dot' === $format) {
            $output->writeln((string) $graph);

            return 0;
        }
        // @codeCoverageIgnoreStart
        $graphviz->display($graph);

        return 0;
        // @codeCoverageIgnoreEnd
    }

    /**
     * Get field mapping display name.
     *
     * @param array  $fieldMapping
     * @param string $nameKey
     *
     * @return string
     */
    protected function getFieldMappingDisplayName(array $fieldMapping, string $nameKey = 'columnName'): string
    {
        $name = $fieldMapping[$nameKey];
        $type = array_key_exists('type', $fieldMapping) ? $fieldMapping['type'] : 'integer';

        return sprintf('%s : %s', $name, $type);
    }
}

janalis / doctrineviz

Pull Request — master (#13)

DoctrinevizCommand::configure() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
