MappingDescribeCommand - Code Metrics - Inspection of "More optimizations and preparation for ClassMetada..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — develop ( 082d66...6f26e1 )

by Guilherme

created 2017-08-05 18:41 UTC

MappingDescribeCommand B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	393
Duplicated Lines	1.53 %

Coupling/Cohesion

Components	2
Dependencies	11

Test Coverage

Coverage

95.28%

Importance

Changes

Metric	Value
wmc	46
lcom	2
cbo	11
dl	6
loc	393
ccs	121
cts	127
cp	0.9528
rs	8.3999
c	0
b	0
f	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	configure()	0	17	1
A	execute()	0	9	1
A	displayEntity()	0	54	3
A	getMappedEntities()	0	16	2
B	getClassMetadata()	0	30	4
C	formatParentClasses()	0	37	8
C	formatValue()	0	36	11
A	formatField()	0	8	2
A	formatAssociationMappings()	3	14	3
B	formatPropertyMappings()	3	20	5
B	formatColumn()	0	26	3
A	formatEntityListeners()	0	12	1
A	formatTable()	0	18	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like MappingDescribeCommand often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use MappingDescribeCommand, and based on these observations, apply Extract Interface, too.

<?php

declare(strict_types=1);

namespace Doctrine\ORM\Tools\Console\Command;

use Doctrine\Common\Persistence\Mapping\MappingException;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\AssociationMetadata;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\ColumnMetadata;
use Doctrine\ORM\Mapping\ComponentMetadata;
use Doctrine\ORM\Mapping\FieldMetadata;
use Doctrine\ORM\Mapping\TableMetadata;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Show information about mapped entities.
 *
 * @link    www.doctrine-project.org
 * @since   2.4
 * @author  Daniel Leech <[email protected]>
 */
final class MappingDescribeCommand extends Command
{
    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this
            ->setName('orm:mapping:describe')
            ->addArgument('entityName', InputArgument::REQUIRED, 'Full or partial name of entity')
            ->setDescription('Display information about mapped objects')
            ->setHelp(<<<EOT
The %command.full_name% command describes the metadata for the given full or partial entity class name.

    <info>%command.full_name%</info> My\Namespace\Entity\MyEntity

Or:

    <info>%command.full_name%</info> MyEntity
EOT
            );
    }

    /**
     * {@inheritdoc}
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        /* @var $entityManager \Doctrine\ORM\EntityManagerInterface */
        $entityManager = $this->getHelper('em')->getEntityManager();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

        $this->displayEntity($input->getArgument('entityName'), $entityManager, $output);

        return 0;
    }

    /**
     * Display all the mapping information for a single Entity.
     *
     * @param string                 $entityName    Full or partial entity class name
     * @param EntityManagerInterface $entityManager
     * @param OutputInterface        $output
     */
    private function displayEntity($entityName, EntityManagerInterface $entityManager, OutputInterface $output)
    {
        $table = new Table($output);

        $table->setHeaders(['Field', 'Value']);

        $metadata    = $this->getClassMetadata($entityName, $entityManager);
        $parentValue = $metadata->getParent() === null ? '<comment>None</comment>' : '';


        array_map(
            [$table, 'addRow'],
            array_merge(
                [
                    $this->formatField('Name', $metadata->getClassName()),

                    $this->formatField('Root entity name', $metadata->getRootClassName()),

                    $this->formatField('Custom repository class', $metadata->getCustomRepositoryClassName()),

                    $this->formatField('Mapped super class?', $metadata->isMappedSuperclass),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $this->formatField('Embedded class?', $metadata->isEmbeddedClass),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $this->formatField('Parent classes', $parentValue),
                ],
                $this->formatParentClasses($metadata),
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                [
                    $this->formatField('Sub classes', $metadata->getSubClasses()),

                    $this->formatField('Embedded classes', $metadata->getSubClasses()),

                    $this->formatField('Named queries', $metadata->getNamedQueries()),

                    $this->formatField('Named native queries', $metadata->getNamedNativeQueries()),

                    $this->formatField('SQL result set mappings', $metadata->getSqlResultSetMappings()),

                    $this->formatField('Identifier', $metadata->getIdentifier()),
                    $this->formatField('Inheritance type', $metadata->inheritanceType),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $this->formatField('Discriminator column', ''),
                ],
                $this->formatColumn($metadata->discriminatorColumn),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                [
                    $this->formatField('Discriminator value', $metadata->discriminatorValue),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $this->formatField('Discriminator map', $metadata->discriminatorMap),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $this->formatField('Table', ''),
                ],
                $this->formatTable($metadata->table),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                [
                    $this->formatField('Composite identifier?', $metadata->isIdentifierComposite()),

                    $this->formatField('Change tracking policy', $metadata->changeTrackingPolicy),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $this->formatField('Versioned?', $metadata->isVersioned()),

                    $this->formatField('Version field', ($metadata->isVersioned() ? $metadata->versionProperty->getName() : '')),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                    $this->formatField('Read only?', $metadata->isReadOnly()),


                    $this->formatEntityListeners($metadata->entityListeners),
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                ],
                [$this->formatField('Property mappings:', '')],
                $this->formatPropertyMappings($metadata->getDeclaredPropertiesIterator())

            )
        );

        $table->render();
    }

    /**
     * Return all mapped entity class names
     *
     * @param EntityManagerInterface $entityManager
     *
     * @return string[]
     */
    private function getMappedEntities(EntityManagerInterface $entityManager)
    {
        $entityClassNames = $entityManager
            ->getConfiguration()
            ->getMetadataDriverImpl()
            ->getAllClassNames();

        if ( ! $entityClassNames) {
            throw new \InvalidArgumentException(
                'You do not have any mapped Doctrine ORM entities according to the current configuration. '.
                'If you have entities or mapping files you should check your mapping configuration for errors.'
            );
        }

        return $entityClassNames;
    }

    /**
     * Return the class metadata for the given entity
     * name
     *
     * @param string                 $entityName    Full or partial entity name
     * @param EntityManagerInterface $entityManager
     *
     * @return \Doctrine\ORM\Mapping\ClassMetadata
     */
    private function getClassMetadata($entityName, EntityManagerInterface $entityManager)
    {
        try {
            return $entityManager->getClassMetadata($entityName);
        } catch (MappingException $e) {

        }

        $matches = array_filter(
            $this->getMappedEntities($entityManager),
            function ($mappedEntity) use ($entityName) {
                return preg_match('{' . preg_quote($entityName) . '}', $mappedEntity);
            }
        );

        if ( ! $matches) {

            throw new \InvalidArgumentException(sprintf(
                'Could not find any mapped Entity classes matching "%s"',
                $entityName
            ));
        }

        if (count($matches) > 1) {
            throw new \InvalidArgumentException(sprintf(
                'Entity name "%s" is ambiguous, possible matches: "%s"',
                $entityName, implode(', ', $matches)
            ));
        }

        return $entityManager->getClassMetadata(current($matches));
    }

    /**
     * @param ComponentMetadata $metadata
     *
     * @return array
     */
    private function formatParentClasses(ComponentMetadata $metadata)
    {
        $output      = [];
        $parentClass = $metadata;

        while (($parentClass = $parentClass->getParent()) !== null) {
            /** @var ClassMetadata $parentClass */
            $attributes = [];

            if ($parentClass->isEmbeddedClass) {
                $attributes[] = 'Embedded';
            }

            if ($parentClass->isMappedSuperclass) {
                $attributes[] = 'Mapped superclass';
            }

            if ($parentClass->inheritanceType) {
                $attributes[] = ucfirst(strtolower($parentClass->inheritanceType));
            }

            if ($parentClass->isReadOnly()) {
                $attributes[] = 'Read-only';
            }

            if ($parentClass->isVersioned()) {
                $attributes[] = 'Versioned';
            }

            $output[] = $this->formatField(
                sprintf('  %s', $parentClass->getParent()),
                ($parentClass->isRootEntity() ? '(Root) ' : '') . $this->formatValue($attributes)
            );
        }

        return $output;
    }

    /**
     * Format the given value for console output
     *
     * @param mixed $value
     *
     * @return string
     */
    private function formatValue($value)
    {
        if ('' === $value) {
            return '';
        }

        if (null === $value) {
            return '<comment>Null</comment>';
        }

        if (is_bool($value)) {
            return '<comment>' . ($value ? 'True' : 'False') . '</comment>';
        }

        if (empty($value)) {
            return '<comment>Empty</comment>';
        }

        if (is_array($value)) {
            if (defined('JSON_UNESCAPED_UNICODE') && defined('JSON_UNESCAPED_SLASHES')) {
                return json_encode($value, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
            }

            return json_encode($value);
        }

        if (is_object($value)) {
            return sprintf('<%s>', get_class($value));
        }

        if (is_scalar($value)) {
            return $value;

        }

        throw new \InvalidArgumentException(sprintf('Do not know how to format value "%s"', print_r($value, true)));
    }

    /**
     * Add the given label and value to the two column table output
     *
     * @param string $label Label for the value
     * @param mixed  $value A Value to show
     *
     * @return array
     */
    private function formatField($label, $value)
    {
        if (null === $value) {
            $value = '<comment>None</comment>';
        }

        return [sprintf('<info>%s</info>', $label), $this->formatValue($value)];
    }

    /**
     * Format the association mappings
     *
     * @param array $propertyMappings
     *
     * @return array
     */
    private function formatAssociationMappings(array $propertyMappings)
    {
        $output = [];

        foreach ($propertyMappings as $propertyName => $mapping) {
            $output[] = $this->formatField(sprintf('  %s', $propertyName), '');

            foreach ($mapping as $field => $value) {

                $output[] = $this->formatField(sprintf('    %s', $field), $this->formatValue($value));
            }
        }

        return $output;
    }


    /**
     * Format the property mappings
     *
     * @param iterable $propertyMappings
     *
     * @return array
     */
    private function formatPropertyMappings(iterable $propertyMappings)
    {
        $output = [];

        foreach ($propertyMappings as $propertyName => $property) {
            $output[] = $this->formatField(sprintf('  %s', $propertyName), '');

            if ($property instanceof FieldMetadata) {
                $output = array_merge($output, $this->formatColumn($property));
            }  else if ($property instanceof AssociationMetadata) {
                // @todo guilhermeblanco Fix me! We are trying to iterate through an AssociationMetadata instance
                foreach ($property as $field => $value) {

                    $output[] = $this->formatField(sprintf('    %s', $field), $this->formatValue($value));
                }

            }
        }

        return $output;
    }

    /**
     * @param ColumnMetadata|null $columnMetadata
     *
     * @return array|string
     */
    private function formatColumn(ColumnMetadata $columnMetadata = null)
    {
        $output = [];

        if (null === $columnMetadata) {
            $output[] = '<comment>Null</comment>';

            return $output;
        }

        $output[] = $this->formatField('    type', $this->formatValue($columnMetadata->getTypeName()));
        $output[] = $this->formatField('    tableName', $this->formatValue($columnMetadata->getTableName()));
        $output[] = $this->formatField('    columnName', $this->formatValue($columnMetadata->getColumnName()));
        $output[] = $this->formatField('    columnDefinition', $this->formatValue($columnMetadata->getColumnDefinition()));
        $output[] = $this->formatField('    isPrimaryKey', $this->formatValue($columnMetadata->isPrimaryKey()));
        $output[] = $this->formatField('    isNullable', $this->formatValue($columnMetadata->isNullable()));
        $output[] = $this->formatField('    isUnique', $this->formatValue($columnMetadata->isUnique()));
        $output[] = $this->formatField('    options', $this->formatValue($columnMetadata->getOptions()));

        if ($columnMetadata instanceof FieldMetadata) {
            $output[] = $this->formatField('    Generator type', $this->formatValue($columnMetadata->getValueGenerator()->getType()));
            $output[] = $this->formatField('    Generator definition', $this->formatValue($columnMetadata->getValueGenerator()->getDefinition()));
        }

        return $output;
    }

    /**
     * Format the entity listeners
     *
     * @param array $entityListeners
     *
     * @return array
     */
    private function formatEntityListeners(array $entityListeners)
    {
        return $this->formatField(
            'Entity listeners',
            array_map(
                function ($entityListener) {
                    return get_class($entityListener);
                },
                $entityListeners
            )
        );
    }

    /**
     * @param TableMetadata|null $tableMetadata
     *
     * @return array|string
     */
    private function formatTable(TableMetadata $tableMetadata = null)
    {
        $output = [];

        if (null === $tableMetadata) {
            $output[] = '<comment>Null</comment>';

            return $output;
        }

        $output[] = $this->formatField('    schema', $this->formatValue($tableMetadata->getSchema()));
        $output[] = $this->formatField('    name', $this->formatValue($tableMetadata->getName()));
        $output[] = $this->formatField('    indexes', $this->formatValue($tableMetadata->getIndexes()));
        $output[] = $this->formatField('    uniqueConstaints', $this->formatValue($tableMetadata->getUniqueConstraints()));
        $output[] = $this->formatField('    options', $this->formatValue($tableMetadata->getOptions()));

        return $output;
    }
}


Push — develop ( 082d66...6f26e1 )

MappingDescribeCommand B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

13 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

doctrine / orm

Push — develop ( 082d66...6f26e1 )

MappingDescribeCommand B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

13 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like