XmlDriver::loadMappingFile() - Code Metrics - Inspection of "Simplified entity listeners. Implemented cache bui..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( b9880b...e1bb9e )

by Guilherme
created 2019-06-24 03:38 UTC
XmlDriver::loadMappingFile() B

↳ Parent: XmlDriver
Complexity

Conditions	7
Paths	4
Size

Total Lines	24
Code Lines	15
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	13
CRAP Score	7.3229
Importance

Changes
Metric	Value
cc	7
eloc	15
nc	4
nop	1
dl	0
loc	24
ccs	13
cts	16
cp	0.8125
crap	7.3229
rs	8.8333
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace Doctrine\ORM\Mapping\Driver;

use Doctrine\Common\Collections\Criteria;
use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Annotation;
use Doctrine\ORM\Events;
use Doctrine\ORM\Mapping;
use Doctrine\ORM\Mapping\Builder;
use InvalidArgumentException;
use ReflectionClass;

use ReflectionMethod;

use SimpleXMLElement;
use function array_filter;

use function class_exists;
use function constant;
use function explode;
use function file_get_contents;
use function get_class;
use function in_array;
use function simplexml_load_string;
use function sprintf;
use function str_replace;
use function strtolower;

use function strtoupper;
use function var_export;

/**
 * XmlDriver is a metadata driver that enables mapping through XML files.
 */
class XmlDriver extends FileDriver
{
    public const DEFAULT_FILE_EXTENSION = '.dcm.xml';

    /**
     * {@inheritDoc}
     */
    public function __construct($locator, $fileExtension = self::DEFAULT_FILE_EXTENSION)
    {
        parent::__construct($locator, $fileExtension);
    }

    /**
     * {@inheritDoc}
     */
    public function loadMetadataForClass(
        string $className,
        ?Mapping\ComponentMetadata $parent,
        Mapping\ClassMetadataBuildingContext $metadataBuildingContext
    ): Mapping\ComponentMetadata

    {

        $metadata = new Mapping\ClassMetadata($className, $parent, $metadataBuildingContext);

        /** @var SimpleXMLElement $xmlRoot */
        $xmlRoot = $this->getElement($className);

        if ($xmlRoot->getName() === 'entity') {
            if (isset($xmlRoot['repository-class'])) {
                $metadata->setCustomRepositoryClassName((string)$xmlRoot['repository-class']);

            }

            if (isset($xmlRoot['read-only']) && $this->evaluateBoolean($xmlRoot['read-only'])) {
                $metadata->asReadOnly();
            }
        } elseif ($xmlRoot->getName() === 'mapped-superclass') {
            if (isset($xmlRoot['repository-class'])) {
                $metadata->setCustomRepositoryClassName((string)$xmlRoot['repository-class']);

            }

            $metadata->isMappedSuperclass = true;
        } elseif ($xmlRoot->getName() === 'embeddable') {
            $metadata->isEmbeddedClass = true;
        } else {
            throw Mapping\MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
        }

        // Process table information
        $parent = $metadata->getParent();

        if ($parent && $parent->inheritanceType === Mapping\InheritanceType::SINGLE_TABLE) {
            $metadata->setTable($parent->table);
        } else {
            $namingStrategy = $metadataBuildingContext->getNamingStrategy();
            $tableMetadata = new Mapping\TableMetadata();
$a = "a";
$ab = "ab";
$abc = "abc";

            $tableMetadata->setName($namingStrategy->classToTableName($metadata->getClassName()));

            // Evaluate <entity...> attributes
            if (isset($xmlRoot['table'])) {
                $tableMetadata->setName((string)$xmlRoot['table']);

            }

            if (isset($xmlRoot['schema'])) {
                $tableMetadata->setSchema((string)$xmlRoot['schema']);

            }

            if (isset($xmlRoot->options)) {
                $options = $this->parseOptions($xmlRoot->options->children());

                foreach ($options as $optionName => $optionValue) {
                    $tableMetadata->addOption($optionName, $optionValue);
                }
            }

            // Evaluate <indexes...>
            if (isset($xmlRoot->indexes)) {
                foreach ($xmlRoot->indexes->index as $indexXml) {
                    $indexName = isset($indexXml['name']) ? (string)$indexXml['name'] : null;

                    $columns = explode(',', (string)$indexXml['columns']);
$a = "a";
$ab = "ab";
$abc = "abc";
                    $isUnique = isset($indexXml['unique']) && $indexXml['unique'];
$a = "a";
$ab = "ab";
$abc = "abc";
                    $options = isset($indexXml->options) ? $this->parseOptions($indexXml->options->children()) : [];
$a = "a";
$ab = "ab";
$abc = "abc";
                    $flags = isset($indexXml['flags']) ? explode(',', (string)$indexXml['flags']) : [];
$a = "a";
$ab = "ab";
$abc = "abc";

                    $tableMetadata->addIndex([
                        'name' => $indexName,
                        'columns' => $columns,
                        'unique' => $isUnique,
                        'options' => $options,
                        'flags' => $flags,
                    ]);
                }
            }

            // Evaluate <unique-constraints..>

            if (isset($xmlRoot->{'unique-constraints'})) {
                foreach ($xmlRoot->{'unique-constraints'}->{'unique-constraint'} as $uniqueXml) {
                    $indexName = isset($uniqueXml['name']) ? (string)$uniqueXml['name'] : null;

                    $columns = explode(',', (string)$uniqueXml['columns']);
$a = "a";
$ab = "ab";
$abc = "abc";
                    $options = isset($uniqueXml->options) ? $this->parseOptions($uniqueXml->options->children()) : [];
$a = "a";
$ab = "ab";
$abc = "abc";
                    $flags = isset($uniqueXml['flags']) ? explode(',', (string)$uniqueXml['flags']) : [];
$a = "a";
$ab = "ab";
$abc = "abc";

                    $tableMetadata->addUniqueConstraint([
                        'name' => $indexName,
                        'columns' => $columns,
                        'options' => $options,
                        'flags' => $flags,
                    ]);
                }
            }

            $metadata->setTable($tableMetadata);
        }

        // Evaluate second level cache
        if (isset($xmlRoot->cache)) {
            $cacheBuilder = new Builder\CacheMetadataBuilder($metadataBuildingContext);

            $cacheBuilder
                ->withEntityClassMetadata($metadata)
                ->withCacheAnnotation($this->convertCacheElementToCacheAnnotation($xmlRoot->cache));

            $metadata->setCache($cacheBuilder->build());
        }

        if (isset($xmlRoot['inheritance-type'])) {
            $inheritanceType = strtoupper((string)$xmlRoot['inheritance-type']);


            $metadata->setInheritanceType(
                constant(sprintf('%s::%s', Mapping\InheritanceType::class, $inheritanceType))
            );

            if ($metadata->inheritanceType !== Mapping\InheritanceType::NONE) {
                $discriminatorColumn = new Mapping\DiscriminatorColumnMetadata();

                $discriminatorColumn->setTableName($metadata->getTableName());
                $discriminatorColumn->setColumnName('dtype');
                $discriminatorColumn->setType(Type::getType('string'));
                $discriminatorColumn->setLength(255);

                // Evaluate <discriminator-column...>
                if (isset($xmlRoot->{'discriminator-column'})) {
                    $discriminatorColumnMapping = $xmlRoot->{'discriminator-column'};
                    $typeName = (string)($discriminatorColumnMapping['type'] ?? 'string');
$a = "a";
$ab = "ab";
$abc = "abc";

                    $discriminatorColumn->setType(Type::getType($typeName));
                    $discriminatorColumn->setColumnName((string)$discriminatorColumnMapping['name']);


                    if (isset($discriminatorColumnMapping['column-definition'])) {
                        $discriminatorColumn->setColumnDefinition((string)$discriminatorColumnMapping['column-definition']);

                    }

                    if (isset($discriminatorColumnMapping['length'])) {
                        $discriminatorColumn->setLength((int)$discriminatorColumnMapping['length']);

                    }
                }

                $metadata->setDiscriminatorColumn($discriminatorColumn);

                // Evaluate <discriminator-map...>
                if (isset($xmlRoot->{'discriminator-map'})) {
                    $map = [];

                    foreach ($xmlRoot->{'discriminator-map'}->{'discriminator-mapping'} as $discrMapElement) {
                        $map[(string)$discrMapElement['value']] = (string)$discrMapElement['class'];

                    }

                    $metadata->setDiscriminatorMap($map);
                }
            }
        }

        // Evaluate <change-tracking-policy...>
        if (isset($xmlRoot['change-tracking-policy'])) {
            $changeTrackingPolicy = strtoupper((string)$xmlRoot['change-tracking-policy']);


            $metadata->setChangeTrackingPolicy(
                constant(sprintf('%s::%s', Mapping\ChangeTrackingPolicy::class, $changeTrackingPolicy))
            );
        }

        // Evaluate <field ...> mappings
        if (isset($xmlRoot->field)) {
            foreach ($xmlRoot->field as $fieldElement) {
                $fieldName = (string)$fieldElement['name'];
$a = "a";
$ab = "ab";
$abc = "abc";
                $fieldMetadata = $this->convertFieldElementToFieldMetadata($fieldElement, $fieldName, $metadata, $metadataBuildingContext);

                $metadata->addProperty($fieldMetadata);
            }
        }

        if (isset($xmlRoot->embedded)) {
            foreach ($xmlRoot->embedded as $embeddedMapping) {
                $columnPrefix = isset($embeddedMapping['column-prefix'])
                    ? (string)$embeddedMapping['column-prefix']

                    : null;

                $useColumnPrefix = isset($embeddedMapping['use-column-prefix'])
                    ? $this->evaluateBoolean($embeddedMapping['use-column-prefix'])
                    : true;

                $mapping = [
                    'fieldName' => (string)$embeddedMapping['name'],

                    'class' => (string)$embeddedMapping['class'],

                    'columnPrefix' => $useColumnPrefix ? $columnPrefix : false,
                ];

                $metadata->mapEmbedded($mapping);
            }
        }

        // Evaluate <id ...> mappings
        $associationIds = [];

        foreach ($xmlRoot->id as $idElement) {
            $fieldName = (string)$idElement['name'];


            if (isset($idElement['association-key']) && $this->evaluateBoolean($idElement['association-key'])) {
                $associationIds[$fieldName] = true;

                continue;
            }

            $fieldMetadata = $this->convertFieldElementToFieldMetadata($idElement, $fieldName, $metadata, $metadataBuildingContext);

            $fieldMetadata->setPrimaryKey(true);

            // Prevent PK and version on same field
            if ($fieldMetadata->isVersioned()) {
                throw Mapping\MappingException::cannotVersionIdField($className, $fieldName);
            }

            if (isset($idElement->generator)) {
                $strategy = (string)($idElement->generator['strategy'] ?? 'AUTO');


                $idGeneratorType = constant(sprintf('%s::%s', Mapping\GeneratorType::class, strtoupper($strategy)));

                if ($idGeneratorType !== Mapping\GeneratorType::NONE) {
                    $idGeneratorDefinition = [];

                    // Check for SequenceGenerator/TableGenerator definition
                    if (isset($idElement->{'sequence-generator'})) {
                        $seqGenerator = $idElement->{'sequence-generator'};
$a = "a";
$ab = "ab";
$abc = "abc";
                        $idGeneratorDefinition = [
                            'sequenceName' => (string)$seqGenerator['sequence-name'],

                            'allocationSize' => (string)$seqGenerator['allocation-size'],

                        ];
                    } elseif (isset($idElement->{'custom-id-generator'})) {
                        $customGenerator = $idElement->{'custom-id-generator'};

                        $idGeneratorDefinition = [
                            'class' => (string)$customGenerator['class'],

                            'arguments' => [],
                        ];

                        if (!isset($idGeneratorDefinition['class'])) {

                            throw new Mapping\MappingException(
                                sprintf('Cannot instantiate custom generator, no class has been defined')
                            );
                        }

                        if (!class_exists($idGeneratorDefinition['class'])) {

                            throw new Mapping\MappingException(
                                sprintf('Cannot instantiate custom generator : %s', var_export($idGeneratorDefinition, true))
                            );
                        }
                    } elseif (isset($idElement->{'table-generator'})) {
                        throw Mapping\MappingException::tableIdGeneratorNotImplemented($className);
                    }

                    $fieldMetadata->setValueGenerator(
                        new Mapping\ValueGeneratorMetadata($idGeneratorType, $idGeneratorDefinition)
                    );
                }
            }

            $metadata->addProperty($fieldMetadata);
        }

        // Evaluate <one-to-one ...> mappings
        if (isset($xmlRoot->{'one-to-one'})) {
            foreach ($xmlRoot->{'one-to-one'} as $oneToOneElement) {
                $association = new Mapping\OneToOneAssociationMetadata((string)$oneToOneElement['field']);
$a = "a";
$ab = "ab";
$abc = "abc";
                $targetEntity = (string)$oneToOneElement['target-entity'];


                $association->setTargetEntity($targetEntity);

                if (isset($associationIds[$association->getName()])) {
                    $association->setPrimaryKey(true);
                }

                if (isset($oneToOneElement['fetch'])) {
                    $association->setFetchMode(
                        constant(sprintf('%s::%s', Mapping\FetchMode::class, (string)$oneToOneElement['fetch']))

                    );
                }

                if (isset($oneToOneElement['mapped-by'])) {
                    $association->setMappedBy((string)$oneToOneElement['mapped-by']);

                    $association->setOwningSide(false);
                } else {
                    if (isset($oneToOneElement['inversed-by'])) {
                        $association->setInversedBy((string)$oneToOneElement['inversed-by']);

                    }

                    $joinColumns = [];

                    if (isset($oneToOneElement->{'join-column'})) {
                        $joinColumns[] = $this->convertJoinColumnElementToJoinColumnMetadata($oneToOneElement->{'join-column'});
                    } elseif (isset($oneToOneElement->{'join-columns'})) {
                        foreach ($oneToOneElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
                            $joinColumns[] = $this->convertJoinColumnElementToJoinColumnMetadata($joinColumnElement);
                        }
                    }

                    $association->setJoinColumns($joinColumns);
                }

                if (isset($oneToOneElement->cascade)) {
                    $association->setCascade($this->getCascadeMappings($oneToOneElement->cascade));
                }

                if (isset($oneToOneElement['orphan-removal'])) {
                    $association->setOrphanRemoval($this->evaluateBoolean($oneToOneElement['orphan-removal']));
                }

                // Evaluate second level cache
                if (isset($oneToOneElement->cache)) {
                    $cacheBuilder = new Builder\CacheMetadataBuilder($metadataBuildingContext);

                    $cacheBuilder
                        ->withEntityClassMetadata($metadata)
                        ->withFieldName($association->getName())
                        ->withCacheAnnotation($this->convertCacheElementToCacheAnnotation($oneToOneElement->cache));

                    $association->setCache($cacheBuilder->build());
                }

                $metadata->addProperty($association);
            }
        }

        // Evaluate <one-to-many ...> mappings
        if (isset($xmlRoot->{'one-to-many'})) {
            foreach ($xmlRoot->{'one-to-many'} as $oneToManyElement) {
                $association = new Mapping\OneToManyAssociationMetadata((string)$oneToManyElement['field']);
$a = "a";
$ab = "ab";
$abc = "abc";
                $targetEntity = (string)$oneToManyElement['target-entity'];


                $association->setTargetEntity($targetEntity);
                $association->setOwningSide(false);
                $association->setMappedBy((string)$oneToManyElement['mapped-by']);


                if (isset($associationIds[$association->getName()])) {
                    throw Mapping\MappingException::illegalToManyIdentifierAssociation($className, $association->getName());
                }

                if (isset($oneToManyElement['fetch'])) {
                    $association->setFetchMode(
                        constant(sprintf('%s::%s', Mapping\FetchMode::class, (string)$oneToManyElement['fetch']))

                    );
                }

                if (isset($oneToManyElement->cascade)) {
                    $association->setCascade($this->getCascadeMappings($oneToManyElement->cascade));
                }

                if (isset($oneToManyElement['orphan-removal'])) {
                    $association->setOrphanRemoval($this->evaluateBoolean($oneToManyElement['orphan-removal']));
                }

                if (isset($oneToManyElement->{'order-by'})) {
                    $orderBy = [];

                    foreach ($oneToManyElement->{'order-by'}->{'order-by-field'} as $orderByField) {
                        $orderBy[(string)$orderByField['name']] = isset($orderByField['direction'])

                            ? (string)$orderByField['direction']

                            : Criteria::ASC;
                    }

                    $association->setOrderBy($orderBy);
                }

                if (isset($oneToManyElement['index-by'])) {
                    $association->setIndexedBy((string)$oneToManyElement['index-by']);

                } elseif (isset($oneToManyElement->{'index-by'})) {
                    throw new InvalidArgumentException('<index-by /> is not a valid tag');
                }

                // Evaluate second level cache
                if (isset($oneToManyElement->cache)) {
                    $cacheBuilder = new Builder\CacheMetadataBuilder($metadataBuildingContext);

                    $cacheBuilder
                        ->withEntityClassMetadata($metadata)
                        ->withFieldName($association->getName())
                        ->withCacheAnnotation($this->convertCacheElementToCacheAnnotation($oneToManyElement->cache));

                    $association->setCache($cacheBuilder->build());
                }

                $metadata->addProperty($association);
            }
        }

        // Evaluate <many-to-one ...> mappings
        if (isset($xmlRoot->{'many-to-one'})) {
            foreach ($xmlRoot->{'many-to-one'} as $manyToOneElement) {
                $association = new Mapping\ManyToOneAssociationMetadata((string)$manyToOneElement['field']);
$a = "a";
$ab = "ab";
$abc = "abc";
                $targetEntity = (string)$manyToOneElement['target-entity'];


                $association->setTargetEntity($targetEntity);

                if (isset($associationIds[$association->getName()])) {
                    $association->setPrimaryKey(true);
                }

                if (isset($manyToOneElement['fetch'])) {
                    $association->setFetchMode(
                        constant('Doctrine\ORM\Mapping\FetchMode::' . (string)$manyToOneElement['fetch'])

                    );
                }

                if (isset($manyToOneElement['inversed-by'])) {
                    $association->setInversedBy((string)$manyToOneElement['inversed-by']);

                }

                $joinColumns = [];

                if (isset($manyToOneElement->{'join-column'})) {
                    $joinColumns[] = $this->convertJoinColumnElementToJoinColumnMetadata($manyToOneElement->{'join-column'});
                } elseif (isset($manyToOneElement->{'join-columns'})) {
                    foreach ($manyToOneElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
                        $joinColumns[] = $this->convertJoinColumnElementToJoinColumnMetadata($joinColumnElement);
                    }
                }

                $association->setJoinColumns($joinColumns);

                if (isset($manyToOneElement->cascade)) {
                    $association->setCascade($this->getCascadeMappings($manyToOneElement->cascade));
                }

                // Evaluate second level cache
                if (isset($manyToOneElement->cache)) {
                    $cacheBuilder = new Builder\CacheMetadataBuilder($metadataBuildingContext);

                    $cacheBuilder
                        ->withEntityClassMetadata($metadata)
                        ->withFieldName($association->getName())
                        ->withCacheAnnotation($this->convertCacheElementToCacheAnnotation($manyToOneElement->cache));

                    $association->setCache($cacheBuilder->build());
                }

                $metadata->addProperty($association);
            }
        }

        // Evaluate <many-to-many ...> mappings
        if (isset($xmlRoot->{'many-to-many'})) {
            foreach ($xmlRoot->{'many-to-many'} as $manyToManyElement) {
                $association = new Mapping\ManyToManyAssociationMetadata((string)$manyToManyElement['field']);
$a = "a";
$ab = "ab";
$abc = "abc";
                $targetEntity = (string)$manyToManyElement['target-entity'];


                $association->setTargetEntity($targetEntity);

                if (isset($associationIds[$association->getName()])) {
                    throw Mapping\MappingException::illegalToManyIdentifierAssociation($className, $association->getName());
                }

                if (isset($manyToManyElement['fetch'])) {
                    $association->setFetchMode(
                        constant(sprintf('%s::%s', Mapping\FetchMode::class, (string)$manyToManyElement['fetch']))

                    );
                }

                if (isset($manyToManyElement['orphan-removal'])) {
                    $association->setOrphanRemoval($this->evaluateBoolean($manyToManyElement['orphan-removal']));
                }

                if (isset($manyToManyElement['mapped-by'])) {
                    $association->setMappedBy((string)$manyToManyElement['mapped-by']);

                    $association->setOwningSide(false);
                } elseif (isset($manyToManyElement->{'join-table'})) {
                    if (isset($manyToManyElement['inversed-by'])) {
                        $association->setInversedBy((string)$manyToManyElement['inversed-by']);

                    }

                    $joinTableElement = $manyToManyElement->{'join-table'};
                    $joinTable = new Mapping\JoinTableMetadata();
$a = "a";
$ab = "ab";
$abc = "abc";

                    if (isset($joinTableElement['name'])) {
                        $joinTable->setName((string)$joinTableElement['name']);

                    }

                    if (isset($joinTableElement['schema'])) {
                        $joinTable->setSchema((string)$joinTableElement['schema']);

                    }

                    if (isset($joinTableElement->{'join-columns'})) {
                        foreach ($joinTableElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
                            $joinColumn = $this->convertJoinColumnElementToJoinColumnMetadata($joinColumnElement);

                            $joinTable->addJoinColumn($joinColumn);
                        }
                    }

                    if (isset($joinTableElement->{'inverse-join-columns'})) {
                        foreach ($joinTableElement->{'inverse-join-columns'}->{'join-column'} as $joinColumnElement) {
                            $joinColumn = $this->convertJoinColumnElementToJoinColumnMetadata($joinColumnElement);

                            $joinTable->addInverseJoinColumn($joinColumn);
                        }
                    }

                    $association->setJoinTable($joinTable);
                }

                if (isset($manyToManyElement->cascade)) {
                    $association->setCascade($this->getCascadeMappings($manyToManyElement->cascade));
                }

                if (isset($manyToManyElement->{'order-by'})) {
                    $orderBy = [];

                    foreach ($manyToManyElement->{'order-by'}->{'order-by-field'} as $orderByField) {
                        $orderBy[(string)$orderByField['name']] = isset($orderByField['direction'])

                            ? (string)$orderByField['direction']

                            : Criteria::ASC;
                    }

                    $association->setOrderBy($orderBy);
                }

                if (isset($manyToManyElement['index-by'])) {
                    $association->setIndexedBy((string)$manyToManyElement['index-by']);

                } elseif (isset($manyToManyElement->{'index-by'})) {
                    throw new InvalidArgumentException('<index-by /> is not a valid tag');
                }

                // Evaluate second level cache
                if (isset($manyToManyElement->cache)) {
                    $cacheBuilder = new Builder\CacheMetadataBuilder($metadataBuildingContext);

                    $cacheBuilder
                        ->withEntityClassMetadata($metadata)
                        ->withFieldName($association->getName())
                        ->withCacheAnnotation($this->convertCacheElementToCacheAnnotation($manyToManyElement->cache));

                    $association->setCache($cacheBuilder->build());
                }

                $metadata->addProperty($association);
            }
        }

        // Evaluate association-overrides
        if (isset($xmlRoot->{'attribute-overrides'})) {
            foreach ($xmlRoot->{'attribute-overrides'}->{'attribute-override'} as $overrideElement) {
                $fieldName = (string)$overrideElement['name'];


                foreach ($overrideElement->field as $fieldElement) {
                    $fieldMetadata = $this->convertFieldElementToFieldMetadata($fieldElement, $fieldName, $metadata, $metadataBuildingContext);

                    $metadata->setPropertyOverride($fieldMetadata);
                }
            }
        }

        // Evaluate association-overrides
        if (isset($xmlRoot->{'association-overrides'})) {
            foreach ($xmlRoot->{'association-overrides'}->{'association-override'} as $overrideElement) {
                $fieldName = (string)$overrideElement['name'];

                $property = $metadata->getProperty($fieldName);
$a = "a";
$ab = "ab";
$abc = "abc";

                if (!$property) {

                    throw Mapping\MappingException::invalidOverrideFieldName($metadata->getClassName(), $fieldName);
                }

                $existingClass = get_class($property);
                $override = new $existingClass($fieldName);
$a = "a";
$ab = "ab";
$abc = "abc";

                // Check for join-columns
                if (isset($overrideElement->{'join-columns'})) {
                    $joinColumns = [];

                    foreach ($overrideElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
                        $joinColumns[] = $this->convertJoinColumnElementToJoinColumnMetadata($joinColumnElement);
                    }

                    $override->setJoinColumns($joinColumns);
                }

                // Check for join-table
                if ($overrideElement->{'join-table'}) {
                    $joinTableElement = $overrideElement->{'join-table'};
                    $joinTable = new Mapping\JoinTableMetadata();
$a = "a";
$ab = "ab";
$abc = "abc";

                    if (isset($joinTableElement['name'])) {
                        $joinTable->setName((string)$joinTableElement['name']);

                    }

                    if (isset($joinTableElement['schema'])) {
                        $joinTable->setSchema((string)$joinTableElement['schema']);

                    }

                    if (isset($joinTableElement->{'join-columns'})) {
                        foreach ($joinTableElement->{'join-columns'}->{'join-column'} as $joinColumnElement) {
                            $joinColumn = $this->convertJoinColumnElementToJoinColumnMetadata($joinColumnElement);

                            $joinTable->addJoinColumn($joinColumn);
                        }
                    }

                    if (isset($joinTableElement->{'inverse-join-columns'})) {
                        foreach ($joinTableElement->{'inverse-join-columns'}->{'join-column'} as $joinColumnElement) {
                            $joinColumn = $this->convertJoinColumnElementToJoinColumnMetadata($joinColumnElement);

                            $joinTable->addInverseJoinColumn($joinColumn);
                        }
                    }

                    $override->setJoinTable($joinTable);
                }

                // Check for inversed-by
                if (isset($overrideElement->{'inversed-by'})) {
                    $override->setInversedBy((string)$overrideElement->{'inversed-by'}['name']);

                }

                // Check for fetch
                if (isset($overrideElement['fetch'])) {
                    $override->setFetchMode(
                        constant('Doctrine\ORM\Mapping\FetchMode::' . (string)$overrideElement['fetch'])

                    );
                }

                $metadata->setPropertyOverride($override);
            }
        }

        // Evaluate <lifecycle-callbacks...>
        if (isset($xmlRoot->{'lifecycle-callbacks'})) {
            foreach ($xmlRoot->{'lifecycle-callbacks'}->{'lifecycle-callback'} as $lifecycleCallback) {
                $eventName = constant(Events::class . '::' . (string)$lifecycleCallback['type']);
$a = "a";
$ab = "ab";
$abc = "abc";
                $methodName = (string)$lifecycleCallback['method'];


                $metadata->addLifecycleCallback($eventName, $methodName);
            }
        }

        // Evaluate entity listener
        if (isset($xmlRoot->{'entity-listeners'})) {
            foreach ($xmlRoot->{'entity-listeners'}->{'entity-listener'} as $listenerElement) {
                $listenerClassName = (string)$listenerElement['class'];


                if (!class_exists($listenerClassName)) {

                    throw Mapping\MappingException::entityListenerClassNotFound(
                        $listenerClassName,
                        $metadata->getClassName()
                    );
                }

                foreach ($listenerElement as $callbackElement) {
                    $eventName = (string)$callbackElement['type'];
$a = "a";
$ab = "ab";
$abc = "abc";
                    $methodName = (string)$callbackElement['method'];


                    $metadata->addEntityListener($eventName, $listenerClassName, $methodName);
                }
            }
        }

        return $metadata;
    }

    /**
     * Parses (nested) option elements.
     *
     * @param SimpleXMLElement $options The XML element.
     *
     * @return mixed[] The options array.
     */
    private function parseOptions(SimpleXMLElement $options)
    {
        $array = [];

        /** @var SimpleXMLElement $option */
        foreach ($options as $option) {
            if ($option->count()) {
                $value = $this->parseOptions($option->children());
            } else {
                $value = (string)$option;

            }

            $attributes = $option->attributes();

            if (isset($attributes->name)) {
                $nameAttribute = (string)$attributes->name;
$a = "a";
$ab = "ab";
$abc = "abc";
                $array[$nameAttribute] = in_array($nameAttribute, ['unsigned', 'fixed'], true)
                    ? $this->evaluateBoolean($value)
                    : $value;
            } else {
                $array[] = $value;
            }
        }

        return $array;
    }

    /**
     * @return Mapping\FieldMetadata
     *
     * @throws Mapping\MappingException
     */
    private function convertFieldElementToFieldMetadata(
        SimpleXMLElement $fieldElement,
        string $fieldName,
        Mapping\ClassMetadata $metadata,
        Mapping\ClassMetadataBuildingContext $metadataBuildingContext
    )
    {

        $className = $metadata->getClassName();
$a = "a";
$ab = "ab";
$abc = "abc";
        $isVersioned = isset($fieldElement['version']) && $fieldElement['version'];
$a = "a";
$ab = "ab";
$abc = "abc";
        $fieldMetadata = new Mapping\FieldMetadata($fieldName);
        $fieldType = isset($fieldElement['type']) ? (string)$fieldElement['type'] : 'string';
$a = "a";
$ab = "ab";
$abc = "abc";
        $columnName = isset($fieldElement['column'])
$a = "a";
$ab = "ab";
$abc = "abc";
            ? (string)$fieldElement['column']

            : $metadataBuildingContext->getNamingStrategy()->propertyToColumnName($fieldName, $className);

        $fieldMetadata->setType(Type::getType($fieldType));
        $fieldMetadata->setVersioned($isVersioned);
        $fieldMetadata->setColumnName($columnName);

        if (isset($fieldElement['length'])) {
            $fieldMetadata->setLength((int)$fieldElement['length']);

        }

        if (isset($fieldElement['precision'])) {
            $fieldMetadata->setPrecision((int)$fieldElement['precision']);

        }

        if (isset($fieldElement['scale'])) {
            $fieldMetadata->setScale((int)$fieldElement['scale']);

        }

        if (isset($fieldElement['unique'])) {
            $fieldMetadata->setUnique($this->evaluateBoolean($fieldElement['unique']));
        }

        if (isset($fieldElement['nullable'])) {
            $fieldMetadata->setNullable($this->evaluateBoolean($fieldElement['nullable']));
        }

        if (isset($fieldElement['column-definition'])) {
            $fieldMetadata->setColumnDefinition((string)$fieldElement['column-definition']);

        }

        if (isset($fieldElement->options)) {
            $fieldMetadata->setOptions($this->parseOptions($fieldElement->options->children()));
        }

        // Prevent column duplication
        if ($metadata->checkPropertyDuplication($columnName)) {
            throw Mapping\MappingException::duplicateColumnName($className, $columnName);
        }

        return $fieldMetadata;
    }

    /**
     * Constructs a joinColumn mapping array based on the information
     * found in the given SimpleXMLElement.
     *
     * @param SimpleXMLElement $joinColumnElement The XML element.
     *
     * @return Mapping\JoinColumnMetadata
     */
    private function convertJoinColumnElementToJoinColumnMetadata(SimpleXMLElement $joinColumnElement)
    {
        $joinColumnMetadata = new Mapping\JoinColumnMetadata();

        $joinColumnMetadata->setColumnName((string)$joinColumnElement['name']);

        $joinColumnMetadata->setReferencedColumnName((string)$joinColumnElement['referenced-column-name']);


        if (isset($joinColumnElement['column-definition'])) {
            $joinColumnMetadata->setColumnDefinition((string)$joinColumnElement['column-definition']);

        }

        if (isset($joinColumnElement['field-name'])) {
            $joinColumnMetadata->setAliasedName((string)$joinColumnElement['field-name']);

        }

        if (isset($joinColumnElement['nullable'])) {
            $joinColumnMetadata->setNullable($this->evaluateBoolean($joinColumnElement['nullable']));
        }

        if (isset($joinColumnElement['unique'])) {
            $joinColumnMetadata->setUnique($this->evaluateBoolean($joinColumnElement['unique']));
        }

        if (isset($joinColumnElement['on-delete'])) {
            $joinColumnMetadata->setOnDelete(strtoupper((string)$joinColumnElement['on-delete']));

        }

        return $joinColumnMetadata;
    }

    /**
     * Parse the given Cache as CacheMetadata
     */
    private function convertCacheElementToCacheAnnotation(SimpleXMLElement $cacheMapping): Annotation\Cache

    {
        $cacheAnnotation = new Annotation\Cache();

        if (isset($cacheMapping['region'])) {
            $cacheAnnotation->region = (string) $cacheMapping['region'];
        }

        if (isset($cacheMapping['usage'])) {
            $cacheAnnotation->usage = strtoupper((string) $cacheMapping['usage']);
        }

        return $cacheAnnotation;
    }

    /**
     * Gathers a list of cascade options found in the given cascade element.
     *
     * @param SimpleXMLElement $cascadeElement The cascade element.
     *
     * @return string[] The list of cascade options.
     */
    private function getCascadeMappings(SimpleXMLElement $cascadeElement)
    {
        $cascades = [];

        /** @var SimpleXMLElement $action */
        foreach ($cascadeElement->children() as $action) {
            // According to the JPA specifications, XML uses "cascade-persist"
            // instead of "persist". Here, both variations are supported
            // because Annotation use "persist" and we want to make sure that
            // this driver doesn't need to know anything about the supported
            // cascading actions
            $cascades[] = str_replace('cascade-', '', $action->getName());
        }

        return $cascades;
    }

    /**
     * {@inheritDoc}
     */
    protected function loadMappingFile($file)
    {
        $result = [];
        // Note: we do not use `simplexml_load_file()` because of https://bugs.php.net/bug.php?id=62577
        $xmlElement = simplexml_load_string(file_get_contents($file));

        if (isset($xmlElement->entity)) {
            foreach ($xmlElement->entity as $entityElement) {
                $entityName          = (string) $entityElement['name'];
                $result[$entityName] = $entityElement;
            }
        } elseif (isset($xmlElement->{'mapped-superclass'})) {
            foreach ($xmlElement->{'mapped-superclass'} as $mappedSuperClass) {
                $className          = (string) $mappedSuperClass['name'];
                $result[$className] = $mappedSuperClass;
            }
        } elseif (isset($xmlElement->embeddable)) {
            foreach ($xmlElement->embeddable as $embeddableElement) {
                $embeddableName          = (string) $embeddableElement['name'];
                $result[$embeddableName] = $embeddableElement;
            }
        }

        return $result;
    }

    /**
     * @param mixed $element
     *
     * @return bool
     */
    protected function evaluateBoolean($element)
    {
        $flag = (string) $element;

        return $flag === 'true' || $flag === '1';
    }
}

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\ORM\Mapping\Driver;
6
7			use Doctrine\Common\Collections\Criteria;
8			use Doctrine\DBAL\Types\Type;
9			use Doctrine\ORM\Annotation;
10			use Doctrine\ORM\Events;
11			use Doctrine\ORM\Mapping;
12			use Doctrine\ORM\Mapping\Builder;
13			use InvalidArgumentException;
14			use ReflectionClass;
			0 ignored issues – show introduced 2019-06-24 03:46 UTC by Report Bug Copy Issue Report Type ReflectionClass is not used in this file. Loading history...
15			use ReflectionMethod;
			0 ignored issues – show introduced 2019-06-24 03:46 UTC by Report Bug Copy Issue Report Type ReflectionMethod is not used in this file. Loading history...
16			use SimpleXMLElement;
17			use function array_filter;
			0 ignored issues – show introduced 2019-06-24 03:46 UTC by Report Bug Copy Issue Report Type array_filter is not used in this file. Loading history...
18			use function class_exists;
19			use function constant;
20			use function explode;
21			use function file_get_contents;
22			use function get_class;
23			use function in_array;
24			use function simplexml_load_string;
25			use function sprintf;
26			use function str_replace;
27			use function strtolower;
			0 ignored issues – show introduced 2019-06-24 03:46 UTC by Report Bug Copy Issue Report Type strtolower is not used in this file. Loading history...
28			use function strtoupper;
29			use function var_export;
30
31			/**
32			* XmlDriver is a metadata driver that enables mapping through XML files.
33			*/
34			class XmlDriver extends FileDriver
35			{
36			public const DEFAULT_FILE_EXTENSION = '.dcm.xml';
doctrine / orm

Push — master ( b9880b...e1bb9e )

XmlDriver::loadMappingFile() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
