Fix issue where xml mapping cannot find file on certain configurations

.travis.yml

@@ -2,7 +2,6 @@ sudo: false
 language: php
 
 php:
- - 5.6
  - 7.0
  - 7.1
  - nightly
@@ -14,7 +13,6 @@ env:
 
 before_script:
  - if [[ $TRAVIS_PHP_VERSION = '7.0' && $DB = 'sqlite' ]]; then PHPUNIT_FLAGS="--coverage-clover ./build/logs/clover.xml"; else PHPUNIT_FLAGS=""; fi
- - if [[ $TRAVIS_PHP_VERSION -lt '7.0' && $TRAVIS_PHP_VERSION != 'hhv*' ]]; then phpenv config-rm xdebug.ini; fi
  - composer self-update
  - composer install --prefer-source
 
@@ -29,10 +27,6 @@ after_script:
 matrix:
  fast_finish: true
  include:
- - php: 5.6
- env: DB=mariadb
- addons:
- mariadb: 10.1
  - php: 7.0
  env: DB=mariadb
  addons:

UPGRADE.md

@@ -1,3 +1,97 @@
+# Upgrade to 3.0
+
+## BC Break: Removed ``YAML`` mapping drivers.
+
+If your code relies on ``YamlDriver`` or ``SimpleYamlDriver``, you **MUST** change to
+annotation or XML drivers instead.
+
+## BC Break: Changed methods in ``ClassMetadata``
+
+* ``ClassMetadata::addInheritedProperty``
+* ``ClassMetadata::setDiscriminatorColumn``
+
+## BC Break: Removed methods in ``ClassMetadata``
+
+* ``ClassMetadata::getTypeOfField`` (to be removed, part of Common API)
+
+## BC Break: Removed methods in ``ClassMetadata``
+
+* ``ClassMetadata::setTableName`` => Use ``ClassMetadata::setPrimaryTable(['name' => ...])``
+* ``ClassMetadata::getFieldMapping`` => Use ``ClassMetadata::getProperty()`` and its methods
+* ``ClassMetadata::getQuotedColumnName`` => Use ``ClassMetadata::getProperty()::getQuotedColumnName()``
+* ``ClassMetadata::getQuotedTableName``
+* ``ClassMetadata::getQuotedJoinTableName``
+* ``ClassMetadata::getQuotedIdentifierColumnNames``
+* ``ClassMetadata::getIdentifierColumnNames`` => Use ``ClassMetadata::getIdentifierColumns($entityManager)``
+* ``ClassMetadata::setVersionMetadata`` => Use ``ClassMetadata::setVersionProperty``
+* ``ClassMetadata::setVersioned``
+* ``ClassMetadata::invokeLifecycleCallbacks``
+* ``ClassMetadata::isInheritedField`` => Use ``ClassMetadata::getProperty()::isInherited()``
+* ``ClassMetadata::isUniqueField`` => Use ``ClassMetadata::getProperty()::isUnique()``
+* ``ClassMetadata::isNullable`` => Use ``ClassMetadata::getProperty()::isNullable()``
+* ``ClassMetadata::getTypeOfColumn()`` => Use ``PersisterHelper::getTypeOfColumn()``
+
+## BC Break: Removed ``quoted`` index from table, field and sequence mappings
+
+Quoting is now always called. Implement your own ``Doctrine\ORM\Mapping\NamingStrategy`` to manipulate
+your schema, tables and column names to your custom desired naming convention.
+
+## BC Break: Removed ``ClassMetadata::$fieldMappings[$fieldName]['requireSQLConversion']``
+
+ORM Type SQL conversion is now always being applied, minimizing the risks of error prone code in ORM internals
+
+## BC Break: Removed ``ClassMetadata::$columnNames``
+
+If your code relies on this property, you should search/replace from this:
+
+ $metadata->columnNames[$fieldName]
+
+To this:
+
+ $metadata->getProperty($fieldName)->getColumnName()
+
+## BC Break: Renamed ``ClassMetadata::setIdentifierValues()`` to ``ClassMetadata::assignIdentifier()``
+
+Provides a more meaningful name to method.
+
+## BC Break: Removed ``ClassMetadata::$namespace``
+
+The namespace property in ClassMetadata was only used when using association 
+classes in the same namespace and it was used to speedup ClassMetadata 
+creation purposes. Namespace could be easily inferred by asking ``\ReflectionClass``
+which was already stored internally.
+
+### BC Break: Removed ``ClassMetadata::$isVersioned``
+
+Switched to a method alternative: ``ClassMetadata::isVersioned()``
+
+## BC Break: Removed ``Doctrine\ORM\Mapping\ClassMetadataInfo``
+
+There was no reason to keep a blank class. All references are now pointing
+to ``Doctrine\ORM\Mapping\ClassMetadata``. 
+
+## BC Break: Annotations classes namespace change
+
+All Annotations classes got moved from ``Doctrine\ORM\Mapping`` into a more 
+pertinent namespace ``Doctrine\ORM\Annotation``. This change was done to add
+room for Metadata namespace refactoring.
+
+## Minor BC break: Mappings now store DBAL\Type instances instead of strings
+
+This lead to manual ``ResultSetMapping`` building instances to also hold Types in meta results.
+Example:
+
+ $rsm->addMetaResult('e ', 'e_discr', 'discr', false, Type::getType('string'));
+
+## Enhancement: Mappings now store their declaring ClassMetadata
+
+Every field, association or embedded now contains a pointer to its declaring ClassMetadata.
+
+## Enhancement: Mappings now store their corresponding table name
+
+Every field, association join column or inline embedded field/association holds a reference to its owning table name.
+
+
 # Upgrade to 2.5
 
 ## Minor BC BREAK: query cache key time is now a float
@@ -148,6 +242,7 @@ From now on, the resultset will look like this:
 
 Added way to access the underlying QueryBuilder#from() method's 'indexBy' parameter when using EntityRepository#createQueryBuilder()
 
+
 # Upgrade to 2.4
 
 ## BC BREAK: Compatibility Bugfix in PersistentCollection#matching()
@@ -192,6 +287,7 @@ Now parenthesis are considered, the previous DQL will generate:
 
  SELECT 100 / (2 * 2) FROM my_entity
 
+
 # Upgrade to 2.3
 
 ## Auto Discriminator Map breaks userland implementations with Listener
@@ -261,6 +357,7 @@ Also, following mapping drivers have been deprecated, please use their replaceme
  * `Doctrine\ORM\Mapping\Driver\PHPDriver` => `Doctrine\Common\Persistence\Mapping\Driver\PHPDriver`
  * `Doctrine\ORM\Mapping\Driver\StaticPHPDriver` => `Doctrine\Common\Persistence\Mapping\Driver\StaticPHPDriver`
 
+
 # Upgrade to 2.2
 
 ## ResultCache implementation rewritten
@@ -344,6 +441,7 @@ Also, Doctrine 2.2 now is around 10-15% faster than 2.1.
 
 Previously EntityManager#find(null) returned null. It now throws an exception.
 
+
 # Upgrade to 2.1
 
 ## Interface for EntityRepository
@@ -368,6 +466,7 @@ The annotation reader was heavily refactored between 2.0 and 2.1-RC1. In theory
 
 This is already done inside the ``$config->newDefaultAnnotationDriver``, so everything should automatically work if you are using this method. You can verify if everything still works by executing a console command such as schema-validate that loads all metadata into memory.
 
+
 # Update from 2.0-BETA3 to 2.0-BETA4
 
 ## XML Driver <change-tracking-policy /> element demoted to attribute
@@ -376,6 +475,7 @@ We changed how the XML Driver allows to define the change-tracking-policy. The w
 
  <entity change-tracking-policy="DEFERRED_IMPLICT" />
 
+
 # Update from 2.0-BETA2 to 2.0-BETA3
 
 ## Serialization of Uninitialized Proxies
@@ -438,10 +538,12 @@ don't loose anything through this.
 The default allocation size for sequences has been changed from 10 to 1. This step was made
 to not cause confusion with users and also because it is partly some kind of premature optimization.
 
+
 # Update from 2.0-BETA1 to 2.0-BETA2
 
 There are no backwards incompatible changes in this release.
 
+
 # Upgrade from 2.0-ALPHA4 to 2.0-BETA1
 
 ## EntityRepository deprecates access to protected variables
@@ -512,7 +614,6 @@ access all entities.
 
 Xml and Yaml Drivers work as before!
 
-
 ## New inversedBy attribute
 
 It is now *mandatory* that the owning side of a bidirectional association specifies the
@@ -576,7 +677,7 @@ you need to use the following, explicit syntax:
 ## XML Mapping Driver
 
 The 'inheritance-type' attribute changed to take last bit of ClassMetadata constant names, i.e.
-NONE, SINGLE_TABLE, INHERITANCE_TYPE_JOINED
+NONE, SINGLE_TABLE, JOINED
 
 ## YAML Mapping Driver
 
@@ -608,6 +709,7 @@ The Collection interface in the Common package has been updated with some missin
 that were present only on the default implementation, ArrayCollection. Custom collection
 implementations need to be updated to adhere to the updated interface.
 
+
 # Upgrade from 2.0-ALPHA3 to 2.0-ALPHA4
 
 ## CLI Controller changes
@@ -644,6 +746,8 @@ With new required method AbstractTask::buildDocumentation, its implementation de
  database schema without deleting any unused tables, sequences or foreign keys.
  * Use "doctrine schema-tool --complete-update" to do a full incremental update of
  your schema.
+
+
 # Upgrade from 2.0-ALPHA2 to 2.0-ALPHA3
 
 This section details the changes made to Doctrine 2.0-ALPHA3 to make it easier for you

composer.json

@@ -14,27 +14,27 @@
  ],
  "minimum-stability": "dev",
  "require": {
- "php": "^5.6 || ^7.0",
+ "php": "^7.0",
  "ext-pdo": "*",
  "doctrine/collections": "~1.2",
- "doctrine/dbal": ">=2.5-dev,<2.7-dev",
+ "doctrine/dbal": "dev-develop as 3.x-dev",
  "doctrine/instantiator": "~1.0.1",
  "doctrine/common": "^2.7.1",
  "doctrine/cache": "~1.4",
  "symfony/console": "~2.5|~3.0"
  },
  "require-dev": {
- "symfony/yaml": "~2.3|~3.0",
- "phpunit/phpunit": "^5.4"
- },
- "suggest": {
- "symfony/yaml": "If you want to use YAML Metadata Mapping Driver"
+ "phpunit/phpunit": "^5.4",
+ "phpbench/phpbench": "^0.11.2"
  },
  "autoload": {
  "psr-4": { "Doctrine\\ORM\\": "lib/Doctrine/ORM" }
  },
  "autoload-dev": {
- "psr-4": { "Doctrine\\Tests\\": "tests/Doctrine/Tests" }
+ "psr-4": {
+ "Doctrine\\Tests\\": "tests/Doctrine/Tests",
+ "Doctrine\\Performance\\": "tests/Doctrine/Performance"
+ }
  },
  "bin": ["bin/doctrine"],
  "extra": {

docs/en/cookbook/sql-table-prefixes.rst

@@ -25,7 +25,9 @@ appropriate autoloaders.
  <?php
 
  namespace DoctrineExtensions;
- use \Doctrine\ORM\Event\LoadClassMetadataEventArgs;
+
+ use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
+ use Doctrine\ORM\Mapping;
 
  class TablePrefix
  {
@@ -40,12 +42,13 @@ appropriate autoloaders.
  {
  $classMetadata = $eventArgs->getClassMetadata();
 
- if (!$classMetadata->isInheritanceTypeSingleTable() || $classMetadata->getName() === $classMetadata->rootEntityName) {
+ if ($classMetadata->inheritanceType !== Mapping\InheritanceType::SINGLE_TABLE ||
+ $classMetadata->getName() === $classMetadata->rootEntityName) {
  $classMetadata->setTableName($this->prefix . $classMetadata->getTableName());
  }
 
  foreach ($classMetadata->getAssociationMappings() as $fieldName => $mapping) {
- if ($mapping['type'] == \Doctrine\ORM\Mapping\ClassMetadataInfo::MANY_TO_MANY && $mapping['isOwningSide']) {
+ if ($mapping['type'] == Mapping\ClassMetadata::MANY_TO_MANY && $mapping['isOwningSide']) {
  $mappedTableName = $mapping['joinTable']['name'];
  $classMetadata->associationMappings[$fieldName]['joinTable']['name'] = $this->prefix . $mappedTableName;
  }

docs/en/reference/dql-doctrine-query-language.rst

@@ -1369,7 +1369,7 @@ can mark a many-to-one or one-to-one association as fetched temporarily to batch
 
  <?php
  $query = $em->createQuery("SELECT u FROM MyProject\User u");
- $query->setFetchMode("MyProject\User", "address", \Doctrine\ORM\Mapping\ClassMetadata::FETCH_EAGER);
+ $query->setFetchMode("MyProject\User", "address", \Doctrine\ORM\Mapping\FetchMode::EAGER);
  $query->execute();
 
 Given that there are 10 users and corresponding addresses in the database the executed queries will look something like:

docs/en/reference/events.rst

@@ -957,7 +957,7 @@ Load ClassMetadata Event
 ------------------------
 
 When the mapping information for an entity is read, it is populated
-in to a ``ClassMetadataInfo`` instance. You can hook in to this
+in to a ``ClassMetadata`` instance. You can hook in to this
 process and manipulate the instance.
 
 .. code-block:: php

docs/en/reference/metadata-drivers.rst

@@ -60,17 +60,17 @@ implements the ``Driver`` interface:
  <?php
  namespace Doctrine\ORM\Mapping\Driver;
 
- use Doctrine\ORM\Mapping\ClassMetadataInfo;
+ use Doctrine\ORM\Mapping\ClassMetadata;
 
  interface Driver
  {
  /**
  * Loads the metadata for the specified class into the provided container.
  * 
  * @param string $className
- * @param ClassMetadataInfo $metadata
+ * @param ClassMetadata $metadata
  */
- function loadMetadataForClass($className, ClassMetadataInfo $metadata);
+ function loadMetadataForClass($className, ClassMetadata $metadata);
 
  /**
  * Gets the names of all mapped classes known to this driver.
@@ -107,11 +107,11 @@ the ``AbstractFileDriver`` implementation for you to extend from:
  /**
  * {@inheritdoc}
  */
- public function loadMetadataForClass($className, ClassMetadataInfo $metadata)
+ public function loadMetadataForClass($className, ClassMetadata $metadata)
  {
  $data = $this->_loadMappingFile($file);
 
- // populate ClassMetadataInfo instance from $data
+ // populate ClassMetadata instance from $data
  }
 
  /**
@@ -154,14 +154,11 @@ entity when needed.
 
 You have all the methods you need to manually specify the mapping
 information instead of using some mapping file to populate it from.
-The base ``ClassMetadataInfo`` class is responsible for only data
-storage and is not meant for runtime use. It does not require that
-the class actually exists yet so it is useful for describing some
+The ``ClassMetadata`` class is responsible for only data storage
+and is not meant for runtime use. It does not require that the
+class actually exists yet so it is useful for describing some
 entity before it exists and using that information to generate for
-example the entities themselves. The class ``ClassMetadata``
-extends ``ClassMetadataInfo`` and adds some functionality required
-for runtime usage and requires that the PHP class is present and
-can be autoloaded.
+example the entities themselves.
 
 You can read more about the API of the ``ClassMetadata`` classes in
 the PHP Mapping chapter.