MappingDescribeCommand::formatParentClasses() - 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::formatParentClasses() C

↳ Parent: MappingDescribeCommand

Complexity

Conditions	8
Paths	33

Size

Total Lines	37
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	8.0231

Importance

Changes

Metric	Value
dl	0
loc	37
ccs	13
cts	14
cp	0.9286
rs	5.3846
c	0
b	0
f	0
cc	8
eloc	19
nc	33
nop	1
crap	8.0231

<?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::formatParentClasses() C

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\ORM\Tools\Console\Command;
6
7			use Doctrine\Common\Persistence\Mapping\MappingException;
8			use Doctrine\ORM\EntityManagerInterface;
9			use Doctrine\ORM\Mapping\AssociationMetadata;
10			use Doctrine\ORM\Mapping\ClassMetadata;
11			use Doctrine\ORM\Mapping\ColumnMetadata;
12			use Doctrine\ORM\Mapping\ComponentMetadata;
13			use Doctrine\ORM\Mapping\FieldMetadata;
14			use Doctrine\ORM\Mapping\TableMetadata;
15			use Symfony\Component\Console\Command\Command;
16			use Symfony\Component\Console\Helper\Table;
17			use Symfony\Component\Console\Input\InputArgument;
18			use Symfony\Component\Console\Input\InputInterface;
19			use Symfony\Component\Console\Output\OutputInterface;
20
21			/**
22			* Show information about mapped entities.
23			*
24			* @link www.doctrine-project.org
25			* @since 2.4
26			* @author Daniel Leech <[email protected]>
27			*/
28			final class MappingDescribeCommand extends Command
29			{
30			/**
31			* {@inheritdoc}
32			*/
33			protected function configure()
34			{
35			$this
36			->setName('orm:mapping:describe')
37			->addArgument('entityName', InputArgument::REQUIRED, 'Full or partial name of entity')
38			->setDescription('Display information about mapped objects')
39			->setHelp(<<<EOT
40			The %command.full_name% command describes the metadata for the given full or partial entity class name.

doctrine / orm

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

MappingDescribeCommand::formatParentClasses() C

Complexity

Size

Duplication

Code Coverage

Importance

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