Remove code generation tools & commands

Author: Majkl578

UPGRADE.md

@@ -1,5 +1,20 @@
 # Upgrade to 3.0
 
+## BC Break: Removed code generators and related console commands
+ 
+These console commands have been removed:
+
+ * `orm:convert-mapping`
+ * `orm:generate:entities`
+ * `orm:generate-repositories`
+
+These classes have been removed:
+
+ * `Doctrine\ORM\Tools\EntityGenerator`
+ * `Doctrine\ORM\Tools\EntityRepositoryGenerator`
+
+Whole Doctrine\ORM\Tools\Export namespace with all its members has been removed as well.
+
 ## BC Break: proxies no longer implement `Doctrine\ORM\Proxy\Proxy`
 
 Proxy objects no longer implement `Doctrine\ORM\Proxy\Proxy` nor

docs/en/reference/faq.rst

@@ -143,23 +143,6 @@ If you set a many-to-one or one-to-one association target-entity to any parent c
 an inheritance hierarchy Doctrine does not know what PHP class the foreign is actually of.
 To find this out it has to execute a SQL query to look this information up in the database.
 
-EntityGenerator
----------------
-
-Why does the EntityGenerator not do X?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The EntityGenerator is not a full fledged code-generator that solves all tasks. Code-Generation
-is not a first-class priority in Doctrine 2 anymore (compared to Doctrine 1). The EntityGenerator
-is supposed to kick-start you, but not towards 100%.
-
-Why does the EntityGenerator not generate inheritance correctly?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Just from the details of the discriminator map the EntityGenerator cannot guess the inheritance hierarchy.
-This is why the generation of inherited entities does not fully work. You have to adjust some additional
-code to get this one working correctly.
-
 Performance
 -----------
 

docs/en/reference/tools.rst

@@ -109,16 +109,10 @@ The following Commands are currently available:
    cache drivers.
 -  ``orm:convert-d1-schema`` Converts Doctrine 1.X schema into a
    Doctrine 2.X schema.
--  ``orm:convert-mapping`` Convert mapping information between
-   supported formats.
 -  ``orm:ensure-production-settings`` Verify that Doctrine is
    properly configured for a production environment.
--  ``orm:generate-entities`` Generate entity classes and method
-   stubs from your mapping information.
 -  ``orm:generate-proxies`` Generates proxy classes for entity
    classes.
--  ``orm:generate-repositories`` Generate repository classes from
-   your mapping information.
 -  ``orm:run-dql`` Executes arbitrary DQL directly from the command
    line.
 -  ``orm:schema-tool:create`` Processes the schema and either
@@ -135,10 +129,7 @@ For these commands are also available aliases:
 
 
 -  ``orm:convert:d1-schema`` is alias for ``orm:convert-d1-schema``.
--  ``orm:convert:mapping`` is alias for ``orm:convert-mapping``.
--  ``orm:generate:entities`` is alias for ``orm:generate-entities``.
 -  ``orm:generate:proxies`` is alias for ``orm:generate-proxies``.
--  ``orm:generate:repositories`` is alias for ``orm:generate-repositories``.
 
 .. note::
 
@@ -261,162 +252,6 @@ your cli-config.php properly.
     (or mapping files), i.e.
     ``new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em, $mappingPaths);``
 
-Entity Generation
------------------
-
-Generate entity classes and method stubs from your mapping information.
-
-.. code-block:: php
-
-    $ php doctrine orm:generate-entities
-    $ php doctrine orm:generate-entities --update-entities
-    $ php doctrine orm:generate-entities --regenerate-entities
-
-This command is not suited for constant usage. It is a little helper and does
-not support all the mapping edge cases very well. You still have to put work
-in your entities after using this command.
-
-It is possible to use the EntityGenerator on code that you have already written. It will
-not be lost. The EntityGenerator will only append new code to your
-file and will not delete the old code. However this approach may still be prone
-to error and we suggest you use code repositories such as GIT or SVN to make
-backups of your code.
-
-It makes sense to generate the entity code if you are using entities as Data
-Access Objects only and don't put much additional logic on them. If you are
-however putting much more logic on the entities you should refrain from using
-the entity-generator and code your entities manually.
-
-.. note::
-
-    Even if you specified Inheritance options in your
-    XML or YAML Mapping files the generator cannot generate the base and
-    child classes for you correctly, because it doesn't know which
-    class is supposed to extend which. You have to adjust the entity
-    code manually for inheritance to work!
-
-
-Convert Mapping Information
----------------------------
-
-Convert mapping information between supported formats.
-
-This is an **execute one-time** command. It should not be necessary for
-you to call this method multiple times, especially when using the ``--from-database``
-flag.
-
-Converting an existing database schema into mapping files only solves about 70-80%
-of the necessary mapping information. Additionally the detection from an existing
-database cannot detect inverse associations, inheritance types,
-entities with foreign keys as primary keys and many of the
-semantical operations on associations such as cascade.
-
-.. note::
-
-    There is no need to convert YAML or XML mapping files to annotations
-    every time you make changes. All mapping drivers are first class citizens
-    in Doctrine 2 and can be used as runtime mapping for the ORM. See the
-    docs on XML and YAML Mapping for an example how to register this metadata
-    drivers as primary mapping source.
-
-To convert some mapping information between the various supported
-formats you can use the ``ClassMetadataExporter`` to get exporter
-instances for the different formats:
-
-.. code-block:: php
-
-    <?php
-    $cme = new \Doctrine\ORM\Tools\Export\ClassMetadataExporter();
-
-Once you have a instance you can use it to get an exporter. For
-example, the yml exporter:
-
-.. code-block:: php
-
-    <?php
-    $exporter = $cme->getExporter('yml', '/path/to/export/yml');
-
-Now you can export some ``ClassMetadata`` instances:
-
-.. code-block:: php
-
-    <?php
-    $classes = array(
-      $em->getClassMetadata('Entities\User'),
-      $em->getClassMetadata('Entities\Profile')
-    );
-    $exporter->setMetadata($classes);
-    $exporter->export();
-
-This functionality is also available from the command line to
-convert your loaded mapping information to another format. The
-``orm:convert-mapping`` command accepts two arguments, the type to
-convert to and the path to generate it:
-
-.. code-block:: php
-
-    $ php doctrine orm:convert-mapping xml /path/to/mapping-path-converted-to-xml
-
-Reverse Engineering
--------------------
-
-You can use the ``DatabaseDriver`` to reverse engineer a database
-to an array of ``ClassMetadata`` instances and generate YAML, XML, etc. from them.
-
-.. note::
-
-    Reverse Engineering is a **one-time** process that can get you started with a project.
-    Converting an existing database schema into mapping files only detects about 70-80%
-    of the necessary mapping information. Additionally the detection from an existing
-    database cannot detect inverse associations, inheritance types,
-    entities with foreign keys as primary keys and many of the
-    semantical operations on associations such as cascade.
-
-First you need to retrieve the metadata instances with the
-``DatabaseDriver``:
-
-.. code-block:: php
-
-    <?php
-    $em->getConfiguration()->setMetadataDriverImpl(
-        new \Doctrine\ORM\Mapping\Driver\DatabaseDriver(
-            $em->getConnection()->getSchemaManager()
-        )
-    );
-
-    $cmf = new \Doctrine\ORM\Tools\DisconnectedClassMetadataFactory();
-    $cmf->setEntityManager($em);
-    $metadata = $cmf->getAllMetadata();
-
-Now you can get an exporter instance and export the loaded metadata
-to yml:
-
-.. code-block:: php
-
-    <?php
-    $cme = new \Doctrine\ORM\Tools\Export\ClassMetadataExporter();
-    $exporter = $cme->getExporter('yml', '/path/to/export/yml');
-    $exporter->setMetadata($metadata);
-    $exporter->export();
-
-You can also reverse engineer a database using the
-``orm:convert-mapping`` command:
-
-.. code-block:: php
-
-    $ php doctrine orm:convert-mapping --from-database yml /path/to/mapping-path-converted-to-yml
-
-.. note::
-
-    Reverse Engineering is not always working perfectly
-    depending on special cases. It will only detect Many-To-One
-    relations (even if they are One-To-One) and will try to create
-    entities from Many-To-Many tables. It also has problems with naming
-    of foreign keys that have multiple column names. Any Reverse
-    Engineered Database-Schema needs considerable manual work to become
-    a useful domain model.
-
-
 Runtime vs Development Mapping Validation
 -----------------------------------------