vendor/doctrine/orm/lib/Doctrine/ORM/Tools/Setup.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;
  21
  22 use Doctrine\Common\ClassLoader;
  23 use Doctrine\Common\Cache\Cache;
  24 use Doctrine\Common\Cache\CacheProvider;
  25 use Doctrine\Common\Cache\ArrayCache;
  26 use Doctrine\ORM\Configuration;
  27 use Doctrine\ORM\Mapping\Driver\XmlDriver;
  28 use Doctrine\ORM\Mapping\Driver\YamlDriver;
  29
  30 /**
  31  * Convenience class for setting up Doctrine from different installations and configurations.
  32  *
  33  * @author Benjamin Eberlei <kontakt@beberlei.de>
  34  */
  35 class Setup
  36 {
  37     /**
  38      * Use this method to register all autoloads for a downloaded Doctrine library.
  39      * Pick the directory the library was uncompressed into.
  40      *
  41      * @param string $directory
  42      *
  43      * @return void
  44      */
  45     public static function registerAutoloadDirectory($directory)
  46     {
  47         if (!class_exists('Doctrine\Common\ClassLoader', false)) {
  48             require_once $directory . "/Doctrine/Common/ClassLoader.php";
  49         }
  50
  51         $loader = new ClassLoader("Doctrine", $directory);
  52         $loader->register();
  53
  54         $loader = new ClassLoader("Symfony\Component", $directory . "/Doctrine");
  55         $loader->register();
  56     }
  57
  58     /**
  59      * Creates a configuration with an annotation metadata driver.
  60      *
  61      * @param array   $paths
  62      * @param boolean $isDevMode
  63      * @param string  $proxyDir
  64      * @param Cache   $cache
  65      * @param bool    $useSimpleAnnotationReader
  66      *
  67      * @return Configuration
  68      */
  69     public static function createAnnotationMetadataConfiguration(array $paths, $isDevMode = false, $proxyDir = null, Cache $cache = null, $useSimpleAnnotationReader = true)
  70     {
  71         $config = self::createConfiguration($isDevMode, $proxyDir, $cache);
  72         $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver($paths, $useSimpleAnnotationReader));
  73
  74         return $config;
  75     }
  76
  77     /**
  78      * Creates a configuration with a xml metadata driver.
  79      *
  80      * @param array   $paths
  81      * @param boolean $isDevMode
  82      * @param string  $proxyDir
  83      * @param Cache   $cache
  84      *
  85      * @return Configuration
  86      */
  87     public static function createXMLMetadataConfiguration(array $paths, $isDevMode = false, $proxyDir = null, Cache $cache = null)
  88     {
  89         $config = self::createConfiguration($isDevMode, $proxyDir, $cache);
  90         $config->setMetadataDriverImpl(new XmlDriver($paths));
  91
  92         return $config;
  93     }
  94
  95     /**
  96      * Creates a configuration with a yaml metadata driver.
  97      *
  98      * @param array   $paths
  99      * @param boolean $isDevMode
 100      * @param string  $proxyDir
 101      * @param Cache   $cache
 102      *
 103      * @return Configuration
 104      */
 105     public static function createYAMLMetadataConfiguration(array $paths, $isDevMode = false, $proxyDir = null, Cache $cache = null)
 106     {
 107         $config = self::createConfiguration($isDevMode, $proxyDir, $cache);
 108         $config->setMetadataDriverImpl(new YamlDriver($paths));
 109
 110         return $config;
 111     }
 112
 113     /**
 114      * Creates a configuration without a metadata driver.
 115      *
 116      * @param bool   $isDevMode
 117      * @param string $proxyDir
 118      * @param Cache  $cache
 119      *
 120      * @return Configuration
 121      */
 122     public static function createConfiguration($isDevMode = false, $proxyDir = null, Cache $cache = null)
 123     {
 124         $proxyDir = $proxyDir ?: sys_get_temp_dir();
 125         $cache    = self::createCacheConfiguration($isDevMode, $proxyDir, $cache);
 126
 127         $config = new Configuration();
 128         $config->setMetadataCacheImpl($cache);
 129         $config->setQueryCacheImpl($cache);
 130         $config->setResultCacheImpl($cache);
 131         $config->setProxyDir($proxyDir);
 132         $config->setProxyNamespace('DoctrineProxies');
 133         $config->setAutoGenerateProxyClasses($isDevMode);
 134
 135         return $config;
 136     }
 137
 138     /**
 139      * @param bool       $isDevMode
 140      * @param string     $proxyDir
 141      * @param Cache|null $cache
 142      *
 143      * @return Cache
 144      */
 145     private static function createCacheConfiguration($isDevMode, $proxyDir, Cache $cache = null)
 146     {
 147         $cache = self::createCacheInstance($isDevMode, $cache);
 148
 149         if ( ! $cache instanceof CacheProvider) {
 150             return $cache;
 151         }
 152
 153         $namespace = $cache->getNamespace();
 154
 155         if ($namespace !== '') {
 156             $namespace .= ':';
 157         }
 158
 159         $cache->setNamespace($namespace . 'dc2_' . md5($proxyDir) . '_'); // to avoid collisions
 160
 161         return $cache;
 162     }
 163
 164     /**
 165      * @param bool       $isDevMode
 166      * @param Cache|null $cache
 167      *
 168      * @return Cache
 169      */
 170     private static function createCacheInstance($isDevMode, Cache $cache = null)
 171     {
 172         if ($cache !== null) {
 173             return $cache;
 174         }
 175
 176         if ($isDevMode === true) {
 177             return new ArrayCache();
 178         }
 179
 180         if (extension_loaded('apc')) {
 181             return new \Doctrine\Common\Cache\ApcCache();
 182         }
 183
 184         if (extension_loaded('xcache')) {
 185             return new \Doctrine\Common\Cache\XcacheCache();
 186         }
 187
 188         if (extension_loaded('memcache')) {
 189             $memcache = new \Memcache();
 190             $memcache->connect('127.0.0.1');
 191
 192             $cache = new \Doctrine\Common\Cache\MemcacheCache();
 193             $cache->setMemcache($memcache);
 194
 195             return $cache;
 196         }
 197
 198         if (extension_loaded('redis')) {
 199             $redis = new \Redis();
 200             $redis->connect('127.0.0.1');
 201
 202             $cache = new \Doctrine\Common\Cache\RedisCache();
 203             $cache->setRedis($redis);
 204
 205             return $cache;
 206         }
 207
 208         return new ArrayCache();
 209     }
 210 }