vendor/doctrine/orm/lib/Doctrine/ORM/Tools/Export/Driver/AbstractExporter.php

   1 <?php
   2 /*
   3  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   4  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   5  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   6  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   7  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   8  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   9  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14  *
  15  * This software consists of voluntary contributions made by many individuals
  16  * and is licensed under the MIT license. For more information, see
  17  * <http://www.doctrine-project.org>.
  18  */
  19
  20 namespace Doctrine\ORM\Tools\Export\Driver;
  21
  22 use Doctrine\ORM\Mapping\ClassMetadataInfo;
  23 use Doctrine\ORM\Tools\Export\ExportException;
  24
  25 /**
  26  * Abstract base class which is to be used for the Exporter drivers
  27  * which can be found in \Doctrine\ORM\Tools\Export\Driver
  28  *
  29  *
  30  * @link    www.doctrine-project.org
  31  * @since   2.0
  32  * @author  Jonathan Wage <jonwage@gmail.com>
  33  */
  34 abstract class AbstractExporter
  35 {
  36     protected $_metadata = array();
  37     protected $_outputDir;
  38     protected $_extension;
  39     protected $_overwriteExistingFiles = false;
  40
  41     public function __construct($dir = null)
  42     {
  43         $this->_outputDir = $dir;
  44     }
  45
  46     public function setOverwriteExistingFiles($overwrite)
  47     {
  48         $this->_overwriteExistingFiles = $overwrite;
  49     }
  50
  51     /**
  52      * Converts a single ClassMetadata instance to the exported format
  53      * and returns it
  54      *
  55      * @param ClassMetadataInfo $metadata
  56      * @return mixed $exported
  57      */
  58     abstract public function exportClassMetadata(ClassMetadataInfo $metadata);
  59
  60     /**
  61      * Set the array of ClassMetadataInfo instances to export
  62      *
  63      * @param array $metadata
  64      * @return void
  65      */
  66     public function setMetadata(array $metadata)
  67     {
  68         $this->_metadata = $metadata;
  69     }
  70
  71     /**
  72      * Get the extension used to generated the path to a class
  73      *
  74      * @return string $extension
  75      */
  76     public function getExtension()
  77     {
  78         return $this->_extension;
  79     }
  80
  81     /**
  82      * Set the directory to output the mapping files to
  83      *
  84      *     [php]
  85      *     $exporter = new YamlExporter($metadata);
  86      *     $exporter->setOutputDir(__DIR__ . '/yaml');
  87      *     $exporter->export();
  88      *
  89      * @param string $dir
  90      * @return void
  91      */
  92     public function setOutputDir($dir)
  93     {
  94         $this->_outputDir = $dir;
  95     }
  96
  97     /**
  98      * Export each ClassMetadata instance to a single Doctrine Mapping file
  99      * named after the entity
 100      *
 101      * @return void
 102      */
 103     public function export()
 104     {
 105         if ( ! is_dir($this->_outputDir)) {
 106             mkdir($this->_outputDir, 0777, true);
 107         }
 108
 109         foreach ($this->_metadata as $metadata) {
 110             //In case output is returned, write it to a file, skip otherwise
 111             if($output = $this->exportClassMetadata($metadata)){
 112                 $path = $this->_generateOutputPath($metadata);
 113                 $dir = dirname($path);
 114                 if ( ! is_dir($dir)) {
 115                     mkdir($dir, 0777, true);
 116                 }
 117                 if (file_exists($path) && !$this->_overwriteExistingFiles) {
 118                     throw ExportException::attemptOverwriteExistingFile($path);
 119                 }
 120                 file_put_contents($path, $output);
 121             }
 122         }
 123     }
 124
 125     /**
 126      * Generate the path to write the class for the given ClassMetadataInfo instance
 127      *
 128      * @param ClassMetadataInfo $metadata
 129      * @return string $path
 130      */
 131     protected function _generateOutputPath(ClassMetadataInfo $metadata)
 132     {
 133         return $this->_outputDir . '/' . str_replace('\\', '.', $metadata->name) . $this->_extension;
 134     }
 135
 136     /**
 137      * Set the directory to output the mapping files to
 138      *
 139      *     [php]
 140      *     $exporter = new YamlExporter($metadata, __DIR__ . '/yaml');
 141      *     $exporter->setExtension('.yml');
 142      *     $exporter->export();
 143      *
 144      * @param string $extension
 145      * @return void
 146      */
 147     public function setExtension($extension)
 148     {
 149         $this->_extension = $extension;
 150     }
 151
 152     protected function _getInheritanceTypeString($type)
 153     {
 154         switch ($type)
 155         {
 156             case ClassMetadataInfo::INHERITANCE_TYPE_NONE:
 157                 return 'NONE';
 158             break;
 159
 160             case ClassMetadataInfo::INHERITANCE_TYPE_JOINED:
 161                 return 'JOINED';
 162             break;
 163
 164             case ClassMetadataInfo::INHERITANCE_TYPE_SINGLE_TABLE:
 165                 return 'SINGLE_TABLE';
 166             break;
 167
 168             case ClassMetadataInfo::INHERITANCE_TYPE_TABLE_PER_CLASS:
 169                 return 'PER_CLASS';
 170             break;
 171         }
 172     }
 173
 174     protected function _getChangeTrackingPolicyString($policy)
 175     {
 176         switch ($policy)
 177         {
 178             case ClassMetadataInfo::CHANGETRACKING_DEFERRED_IMPLICIT:
 179                 return 'DEFERRED_IMPLICIT';
 180             break;
 181
 182             case ClassMetadataInfo::CHANGETRACKING_DEFERRED_EXPLICIT:
 183                 return 'DEFERRED_EXPLICIT';
 184             break;
 185
 186             case ClassMetadataInfo::CHANGETRACKING_NOTIFY:
 187                 return 'NOTIFY';
 188             break;
 189         }
 190     }
 191
 192     protected function _getIdGeneratorTypeString($type)
 193     {
 194         switch ($type)
 195         {
 196             case ClassMetadataInfo::GENERATOR_TYPE_AUTO:
 197                 return 'AUTO';
 198             break;
 199
 200             case ClassMetadataInfo::GENERATOR_TYPE_SEQUENCE:
 201                 return 'SEQUENCE';
 202             break;
 203
 204             case ClassMetadataInfo::GENERATOR_TYPE_TABLE:
 205                 return 'TABLE';
 206             break;
 207
 208             case ClassMetadataInfo::GENERATOR_TYPE_IDENTITY:
 209                 return 'IDENTITY';
 210             break;
 211         }
 212     }
 213 }