Doctrine\ORM\Tools\Export\Driver\XmlExporter::exportClassMetadata()

Complexity

Conditions	40
Paths	> 20000

Size

Total Lines	206
Code Lines	112

Duplication

Lines	25
Ratio	12.14 %

Code Coverage

Tests	66
CRAP Score	110.3193

Importance

Changes

0

<?php
    public function exportClassMetadata(ClassMetadata $metadata)
    {
        $xml = new SimpleXmlElement('<?xml version="1.0" encoding="utf-8"?><doctrine-mapping ' .
            'xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping" ' .
            'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' .
            'xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping http://doctrine-project.org/schemas/orm/doctrine-mapping.xsd" />');

        if ($metadata->isMappedSuperclass) {
            $root = $xml->addChild('mapped-superclass');
        } else {
            $root = $xml->addChild('entity');
        }

        if ($metadata->getCustomRepositoryClassName()) {

The expression $metadata->getCustomRepositoryClassName() of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $root->addAttribute('repository-class', $metadata->getCustomRepositoryClassName());
        }

        $root->addAttribute('name', $metadata->getClassName());

        if ($metadata->table->getName()) {

The expression $metadata->table->getName() of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $root->addAttribute('table', $metadata->table->getName());
        }

        if ($metadata->table->getSchema()) {

The expression $metadata->table->getSchema() of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $root->addAttribute('schema', $metadata->table->getSchema());
        }

        if ($metadata->inheritanceType && $metadata->inheritanceType !== InheritanceType::NONE) {
            $root->addAttribute('inheritance-type', $metadata->inheritanceType);
        }

        if ($metadata->table->getOptions()) {
            $optionsXml = $root->addChild('options');

            $this->exportTableOptions($optionsXml, $metadata->table->getOptions());
        }

        if ($metadata->discriminatorColumn) {
            $discrColumn            = $metadata->discriminatorColumn;
            $discriminatorColumnXml = $root->addChild('discriminator-column');

            $discriminatorColumnXml->addAttribute('name', $discrColumn->getColumnName());
            $discriminatorColumnXml->addAttribute('type', $discrColumn->getTypeName());

            if (is_int($discrColumn->getLength())) {
                $discriminatorColumnXml->addAttribute('length', (string) $discrColumn->getLength());
            }

            if (is_int($discrColumn->getScale())) {
                $discriminatorColumnXml->addAttribute('scale', (string) $discrColumn->getScale());
            }

            if (is_int($discrColumn->getPrecision())) {
                $discriminatorColumnXml->addAttribute('precision', (string) $discrColumn->getPrecision());
            }
        }

        if ($metadata->discriminatorMap) {

The expression $metadata->discriminatorMap of type array<string,string> is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $discriminatorMapXml = $root->addChild('discriminator-map');

            foreach ($metadata->discriminatorMap as $value => $className) {
                $discriminatorMappingXml = $discriminatorMapXml->addChild('discriminator-mapping');
                $discriminatorMappingXml->addAttribute('value', (string) $value);
                $discriminatorMappingXml->addAttribute('class', $className);
            }
        }

        if ($metadata->changeTrackingPolicy !== ChangeTrackingPolicy::DEFERRED_IMPLICIT) {
            $root->addChild('change-tracking-policy', $metadata->changeTrackingPolicy);
        }

        if ($metadata->table->getIndexes()) {
            $indexesXml = $root->addChild('indexes');

            foreach ($metadata->table->getIndexes() as $name => $index) {
                $indexXml = $indexesXml->addChild('index');

                $indexXml->addAttribute('name', $name);
                $indexXml->addAttribute('columns', implode(',', $index['columns']));

                if ($index['unique']) {
                    $indexXml->addAttribute('unique', 'true');
                }

                if ($index['flags']) {
                    $indexXml->addAttribute('flags', implode(',', $index['flags']));
                }

                if ($index['options']) {

This code seems to be duplicated across your project.

                    $optionsXml = $indexXml->addChild('options');

                    foreach ($index['options'] as $key => $value) {
                        $optionXml = $optionsXml->addChild('option', $value);

                        $optionXml->addAttribute('name', $key);
                    }
                }
            }
        }

        if ($metadata->table->getUniqueConstraints()) {
            $uniqueConstraintsXml = $root->addChild('unique-constraints');

            foreach ($metadata->table->getUniqueConstraints() as $name => $constraint) {
                $uniqueConstraintXml = $uniqueConstraintsXml->addChild('unique-constraint');

                $uniqueConstraintXml->addAttribute('name', $name);
                $uniqueConstraintXml->addAttribute('columns', implode(',', $constraint['columns']));

                if ($constraint['flags']) {
                    $uniqueConstraintXml->addAttribute('flags', implode(',', $constraint['flags']));
                }

                if ($constraint['options']) {

This code seems to be duplicated across your project.

                    $optionsXml = $uniqueConstraintXml->addChild('options');

                    foreach ($constraint['options'] as $key => $value) {
                        $optionXml = $optionsXml->addChild('option', $value);

                        $optionXml->addAttribute('name', $key);
                    }
                }
            }
        }

        $properties = iterator_to_array($metadata->getDeclaredPropertiesIterator());
        $id         = [];

        foreach ($properties as $name => $property) {
            if ($property->isPrimaryKey()) {
                $id[$name] = $property;

                unset($properties[$name]);
            }
        }

        if ($id) {
            foreach ($id as $property) {
                $idXml = $root->addChild('id');

                $idXml->addAttribute('name', $property->getName());

                if ($property instanceof AssociationMetadata) {
                    $idXml->addAttribute('association-key', 'true');

                    continue;
                }

                $idXml->addAttribute('type', $property->getTypeName());
                $idXml->addAttribute('column', $property->getColumnName());

                if (is_int($property->getLength())) {
                    $idXml->addAttribute('length', $property->getLength());
                }

                if ($property->hasValueGenerator()) {
                    $generatorXml = $idXml->addChild('generator');

                    $generatorXml->addAttribute('strategy', $property->getValueGenerator()->getType());

                    $this->exportSequenceInformation($idXml, $property);
                }
            }
        }

        $orderMap = [
            FieldMetadata::class,
            OneToOneAssociationMetadata::class,
            OneToManyAssociationMetadata::class,
            ManyToOneAssociationMetadata::class,
            ManyToManyAssociationMetadata::class,
        ];



        uasort($properties, function($m1, $m2) use (&$orderMap) {
            $a1 = array_search(get_class($m1), $orderMap);
            $a2 = array_search(get_class($m2), $orderMap);

            return strcmp((string) $a1, (string) $a2);
        });

        foreach ($properties as $property) {

This code seems to be duplicated across your project.

            if ($property instanceof FieldMetadata) {
                $this->exportFieldMetadata($root, $metadata, $property);
            } else if ($property instanceof AssociationMetadata) {
                $this->exportAssociationMetadata($root, $metadata, $property);
            }
        }

        if (isset($metadata->lifecycleCallbacks) && count($metadata->lifecycleCallbacks)>0) {
            $lifecycleCallbacksXml = $root->addChild('lifecycle-callbacks');

            foreach ($metadata->lifecycleCallbacks as $name => $methods) {
                foreach ($methods as $method) {
                    $lifecycleCallbackXml = $lifecycleCallbacksXml->addChild('lifecycle-callback');

                    $lifecycleCallbackXml->addAttribute('type', $name);
                    $lifecycleCallbackXml->addAttribute('method', $method);
                }
            }
        }

        $this->processEntityListeners($metadata, $root);

        return $this->asXml($xml);
    }