/**
* @covers \Weasel\JsonMarshaller\Config\DoctrineAnnotations\JsonAnySetter
*/
public function testBasicClassAnnotations()
{
AnnotationRegistry::registerFile(__DIR__ . '/../../../../../lib/Weasel/JsonMarshaller/Config/DoctrineAnnotations/JsonAnySetter.php');
$annotationReader = new AnnotationReader();
$got = $annotationReader->getMethodAnnotations(new \ReflectionMethod(__NAMESPACE__ . '\\JsonAnySetterTestVictim', 'basic'));
$this->assertEquals(array(new JsonAnySetter()), $got);
}
public function register(Application $app)
{
$app['orm.em.paths'] = $app->share(function () {
return array();
});
$app['orm.event_manager'] = $app->share(function () use($app) {
return new EventManager();
});
$app['orm.config'] = $app->share(function () use($app) {
return Setup::createConfiguration($app['debug']);
});
$app['orm.anotation_reader'] = $app->share(function () use($app) {
$annotationReader = new AnnotationReader();
$cache = $app['orm.config']->getMetadataCacheImpl();
return new CachedReader($annotationReader, $cache);
});
$app['orm.default_anotation_driver'] = $app->share(function () use($app) {
AnnotationRegistry::registerFile($app['vendor_dir'] . '/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
return new AnnotationDriver($app['orm.anotation_reader'], $app['orm.em.paths']);
});
$app['orm.em'] = $app->share(function () use($app) {
$annotationReader = $app['orm.anotation_reader'];
$eventManager = $app['orm.event_manager'];
$driverChain = new MappingDriverChain();
$driverChain->setDefaultDriver($app['orm.default_anotation_driver']);
DoctrineExtensions::registerMappingIntoDriverChainORM($driverChain, $annotationReader);
$loggableListener = new LoggableListener();
$loggableListener->setAnnotationReader($annotationReader);
$loggableListener->setUsername('admin');
$eventManager->addEventSubscriber($loggableListener);
$config = $app['orm.config'];
$config->setMetadataDriverImpl($driverChain);
return EntityManager::create($app['db.default_options'], $config, $eventManager);
});
}
public function getFakedApiResponse($class)
{
AnnotationRegistry::registerLoader('class_exists');
$serializer = SerializerBuilder::create()->build();
$response = new $class();
return $serializer->serialize($response, 'json');
}
/**
*
* @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator
* @return object
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$manifest = $serviceLocator->get('manifest');
$config = new Configuration();
$config->setProxyDir(__DIR__ . '/../../../../Proxies');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir(__DIR__ . '/../../../../Hydrators');
$config->setHydratorNamespace('Hydrators');
$config->setDefaultDB(self::DEFAULT_DB);
$config->setMetadataCacheImpl(new ArrayCache());
//create driver chain
$chain = new MappingDriverChain();
foreach ($manifest['documents'] as $namespace => $path) {
$driver = new AnnotationDriver(new AnnotationReader(), $path);
$chain->addDriver($driver, $namespace);
}
$config->setMetadataDriverImpl($chain);
//register filters
foreach ($manifest['filters'] as $name => $class) {
$config->addFilter($name, $class);
}
//create event manager
$eventManager = new EventManager();
foreach ($manifest['subscribers'] as $subscriber) {
$eventManager->addEventSubscriber($serviceLocator->get($subscriber));
}
//register annotations
AnnotationRegistry::registerLoader(function ($className) {
return class_exists($className);
});
$conn = new Connection(null, array(), $config);
return DocumentManager::create($conn, $config, $eventManager);
}
public function setUp()
{
AnnotationRegistry::registerAutoloadNamespace('Matmar10\\Bundle\\RestApiBundle\\Annotation', __DIR__ . '/../../../../../src');
$container = $this->getKernel()->getContainer();
$annotationReader = $container->get('annotation_reader');
$this->controllerAnnotationReader = new ControllerAnnotationReader($annotationReader);
}
public function __invoke(ContainerInterface $container)
{
if (!$container->has(Configuration::class) || !$container->has(EventManager::class) || !$container->has(Connection::class)) {
throw new ContainerNotRegisteredException('Doctrine\\Common\\EventManager::class,
Doctrine\\ORM\\Configuration::class and Doctrine\\DBAL\\Connection::class
must be registered in the container');
}
$config = $container->has('config') ? $container->get('config') : [];
$underscoreNamingStrategy = isset($config['doctrine']['orm']['underscore_naming_strategy']) ? $config['doctrine']['orm']['underscore_naming_strategy'] : false;
/** @var Configuration $configuration */
$configuration = $container->get(Configuration::class);
$configuration->setProxyDir(isset($config['doctrine']['orm']['proxy_dir']) ? $config['doctrine']['orm']['proxy_dir'] : 'data/cache/EntityProxy');
$configuration->setProxyNamespace(isset($config['doctrine']['orm']['proxy_namespace']) ? $config['doctrine']['orm']['proxy_namespace'] : 'EntityProxy');
$configuration->setAutoGenerateProxyClasses(isset($config['doctrine']['orm']['auto_generate_proxy_classes']) ? $config['doctrine']['orm']['auto_generate_proxy_classes'] : false);
// ORM mapping by Annotation
AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
$driver = new AnnotationDriver(new AnnotationReader(), ['data/cache/doctrine']);
$configuration->setMetadataDriverImpl($driver);
// Cache
$cache = $container->get(Cache::class);
$configuration->setQueryCacheImpl($cache);
$configuration->setResultCacheImpl($cache);
$configuration->setMetadataCacheImpl($cache);
return EntityManager::create($container->get(Connection::class), $configuration, $container->get(EventManager::class));
}
/**
* @param string $userId
* @param string $userPassword
* @param int $partnerId
* @param string $partnerPassword
* @param string $errorLanguage
*/
public function __construct($userId, $userPassword, $partnerId, $partnerPassword, $errorLanguage)
{
AnnotationRegistry::registerLoader('class_exists');
$this->afterbuyGlobal = new AfterbuyGlobal($userId, $userPassword, $partnerId, $partnerPassword, $errorLanguage);
$this->client = new \GuzzleHttp\Client(['base_uri' => 'https://api.afterbuy.de/afterbuy/ABInterface.aspx']);
$this->serializer = Client::getDefaultSerializer();
}
public function setUp()
{
$loader = (require __DIR__ . '/../vendor/autoload.php');
AnnotationRegistry::registerLoader(array($loader, 'loadClass'));
$reader = new AnnotationReader();
$this->annotClassLoader = new RouteAnnotationClassLoader($reader);
}
/**
* @param array $settings
* @param bool $debug
* @return EntityManager
* @throws \Doctrine\ORM\ORMException
*/
public static function factory($settings, $debug = true)
{
if ($debug || !function_exists('apc_fetch')) {
$cache = new ArrayCache();
} else {
$cache = new ApcCache();
}
$dbSettings = $settings['doctrine'];
$config = new Configuration();
$config->setMetadataCacheImpl($cache);
// Do not use default Annotation driver
$driverImpl = new AnnotationDriver(new AnnotationReader(), $dbSettings['entities']);
// Allow all annotations
AnnotationRegistry::registerLoader('class_exists');
$config->setMetadataDriverImpl($driverImpl);
$config->setQueryCacheImpl($cache);
$config->setProxyDir($dbSettings['proxy_path']);
$config->setProxyNamespace('Zaralab\\Doctrine\\Proxies');
if ($debug) {
$config->setAutoGenerateProxyClasses(true);
} else {
$config->setAutoGenerateProxyClasses(false);
}
$connectionOptions = $dbSettings['dbal'];
return EntityManager::create($connectionOptions, $config);
}
/**
* {@inheritdoc}
*/
protected function configure()
{
AnnotationRegistry::registerFile(__DIR__ . '/DoctrineAnnotations.php');
$this->bind()->annotatedWith('Ray\\CakeDbModule\\Annotation\\CakeDbConfig')->toInstance($this->config);
$this->bind('Cake\\Database\\Connection')->toProvider('Ray\\CakeDbModule\\ConnectionProvider')->in(Scope::SINGLETON);
$this->install(new TransactionalModule());
}
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
$app = $this->app;
//Make and share the singleton with the application
$app['lrezek.arachnid4laravel.arachnid'] = $app->share(function ($app) {
//Register annotations with doctrine
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(app_path() . '/../vendor/lrezek/arachnid/src/LRezek/Arachnid/Annotation/Auto.php');
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(app_path() . '/../vendor/lrezek/arachnid/src/LRezek/Arachnid/Annotation/End.php');
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(app_path() . '/../vendor/lrezek/arachnid/src/LRezek/Arachnid/Annotation/Index.php');
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(app_path() . '/../vendor/lrezek/arachnid/src/LRezek/Arachnid/Annotation/Start.php');
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(app_path() . '/../vendor/lrezek/arachnid/src/LRezek/Arachnid/Annotation/Node.php');
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(app_path() . '/../vendor/lrezek/arachnid/src/LRezek/Arachnid/Annotation/Relation.php');
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(app_path() . '/../vendor/lrezek/arachnid/src/LRezek/Arachnid/Annotation/Property.php');
//Get config parameters
$default = $app['config']->get('database.default');
$settings = $app['config']->get('database.connections');
$config = !empty($default) && $default == 'neo4j' ? $settings[$default] : $settings;
//If you have a meta cache but not a annotation reader, make a annotation reader out of the meta cache
if (empty($config['annotation_reader']) && !empty($config['meta_data_cache'])) {
//Get the associated doctrine class
$metaCache = new $this->cacheMap[$config['meta_data_cache']]();
//Set the namespace to the cache_prefix, or make it neo4j if it's not there
$metaCache->setNamespace(empty($config['cache_prefix']) ? 'neo4j' : $config['cache_prefix']);
//Create the reader
$config['annotation_reader'] = new CachedReader(new AnnotationReader(), $metaCache, false);
}
//Return the new instance (the share method insures it's a singleton)
return new Arachnid(new Configuration($config));
});
}
public function __construct($cacheDirectory = null)
{
$cacheDir = $cacheDirectory ?: sys_get_temp_dir();
AnnotationRegistry::registerFile(__DIR__ . '/Neo4jOGMAnnotations.php');
$reader = new AnnotationReader();
$this->reader = new FileCacheReader($reader, $cacheDir, $debug = true);
}
public function __construct()
{
// load database configuration from CodeIgniter
require_once APPPATH . 'config/database.php';
$doctrineClassLoader = new ClassLoader('Doctrine', APPPATH . 'libraries');
$doctrineClassLoader->register();
$entitiesClassLoader = new ClassLoader('models', rtrim(APPPATH, "/"));
$entitiesClassLoader->register();
$proxiesClassLoader = new ClassLoader('Proxies', APPPATH . 'models/proxies');
$proxiesClassLoader->register();
// Set up caches
$config = new Configuration();
$cache = new ArrayCache();
$config->setMetadataCacheImpl($cache);
$reader = new AnnotationReader();
$driverImpl = new AnnotationDriver($reader, array(APPPATH . "models/Entities"));
$config->setMetadataDriverImpl($driverImpl);
$config->setQueryCacheImpl($cache);
// Proxy configuration
$config->setProxyDir(APPPATH . '/models/proxies');
$config->setProxyNamespace('Proxies');
$config->setAutoGenerateProxyClasses(true);
AnnotationRegistry::registerLoader('class_exists');
// Database connection information
$connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']);
// Create EntityManager
$this->em = EntityManager::create($connectionOptions, $config);
}
protected function setUp()
{
$pathToEntities = [__DIR__ . '/Entity'];
$isDevMode = true;
$connectionParams = array('user' => 'user', 'password' => 'password', 'driver' => 'pdo_sqlite', 'memory' => true);
$config = Setup::createConfiguration($isDevMode);
$driver = new AnnotationDriver(new AnnotationReader(), $pathToEntities);
AnnotationRegistry::registerLoader('class_exists');
$config->setMetadataDriverImpl($driver);
$this->em = EntityManager::create($connectionParams, $config);
/*
* Устанавливаем фикстуры, знаю что можно это сделать более универсально, но ... в данном контексте мне больше и не надо
*/
$conn = $this->em->getConnection();
$conn->exec("CREATE TABLE clients (id INTEGER PRIMARY KEY, name TEXT, surname TEXT);");
$conn->exec("CREATE TABLE authors (id INTEGER PRIMARY KEY, name TEXT, surname TEXT);");
$conn->exec("CREATE TABLE books (id INTEGER, owner_id INTEGER, name TEXT, surname TEXT, CONSTRAINT 'pk' PRIMARY KEY (id, owner_id));");
$conn->exec("INSERT INTO clients (name,surname) VALUES('Nikita','Sapogov')");
$conn->exec("INSERT INTO clients (name,surname) VALUES('Alex','Ivanov')");
$conn->exec("INSERT INTO clients (name,surname) VALUES('Sura','Soir')");
$conn->exec("INSERT INTO clients (name,surname) VALUES('Vasya','Poliakocv')");
$conn->exec("INSERT INTO books (id, owner_id, name) VALUES (1,1,'SuperBookNAme')");
$conn->exec("INSERT INTO books (id, owner_id, name) VALUES (2,15,'SuperBookNAme2')");
$conn->exec("INSERT INTO books (id, owner_id, name) VALUES (3,3,'SuperBookNAme3')");
}
public function register(Application $app)
{
//Load Doctrine Configuration
$app['db.configuration'] = $app->share(function () use($app) {
AnnotationRegistry::registerAutoloadNamespace("Doctrine\\ORM\\Mapping", __DIR__ . '/../../../../../doctrine/orm/lib');
$config = new ORMConfiguration();
$cache = $app['debug'] == false ? new ApcCache() : new ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$chain = new DriverChain();
foreach ((array) $app['db.orm.entities'] as $entity) {
switch ($entity['type']) {
case 'annotation':
$reader = new AnnotationReader();
$driver = new AnnotationDriver($reader, (array) $entity['path']);
$chain->addDriver($driver, $entity['namespace']);
break;
/*case 'yml':
$driver = new YamlDriver((array)$entity['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $entity['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array)$entity['path'], $entity['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $entity['namespace']);
break;*/
/*case 'yml':
$driver = new YamlDriver((array)$entity['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $entity['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array)$entity['path'], $entity['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $entity['namespace']);
break;*/
default:
throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $type));
break;
}
}
$config->setMetadataDriverImpl($chain);
$config->setProxyDir($app['db.orm.proxies_dir']);
$config->setProxyNamespace($app['db.orm.proxies_namespace']);
$config->setAutoGenerateProxyClasses($app['db.orm.auto_generate_proxies']);
return $config;
});
//Set Defaut Configuration
$defaults = array('entities' => array(array('type' => 'annotation', 'path' => 'Entity', 'namespace' => 'Entity')), 'proxies_dir' => 'cache/doctrine/Proxy', 'proxies_namespace' => 'DoctrineProxy', 'auto_generate_proxies' => true);
foreach ($defaults as $key => $value) {
if (!isset($app['db.orm.' . $key])) {
$app['db.orm.' . $key] = $value;
}
}
$self = $this;
$app['db.orm.em'] = $app->share(function () use($self, $app) {
return EntityManager::create($app['db'], $app['db.configuration']);
});
}
public function onBootstrap(MvcEvent $e)
{
$eventManager = $e->getApplication()->getEventManager();
$moduleRouteListener = new ModuleRouteListener();
$moduleRouteListener->attach($eventManager);
AnnotationRegistry::registerAutoloadNamespace('TgBotApi\\Model\\Annotation');
}
public function __construct(Reader $reader = null)
{
$this->reader = $reader ?: new AnnotationReader();
// register our own namespace in the doctrine annotation-class-registry
// not quite sure, why this is necessary
AnnotationRegistry::registerAutoloadNamespace('Hydra\\', array(dirname(dirname(__DIR__))));
}
public function startTestSuite(\PHPUnit_Framework_TestSuite $suite)
{
$suiteName = $suite->getName();
if (-1 === $this->state) {
echo "Testing {$suiteName}\n";
$this->state = 0;
if (!class_exists('Doctrine\\Common\\Annotations\\AnnotationRegistry', false) && class_exists('Doctrine\\Common\\Annotations\\AnnotationRegistry')) {
AnnotationRegistry::registerLoader('class_exists');
}
if ($this->skippedFile = getenv('SYMFONY_PHPUNIT_SKIPPED_TESTS')) {
$this->state = 1;
if (file_exists($this->skippedFile)) {
$this->state = 2;
if (!($this->wasSkipped = (require $this->skippedFile))) {
echo "All tests already ran successfully.\n";
$suite->setTests(array());
}
}
}
} elseif (2 === $this->state) {
$skipped = array();
foreach ($suite->tests() as $test) {
if (!$test instanceof \PHPUnit_Framework_TestCase || isset($this->wasSkipped[$suiteName]['*']) || isset($this->wasSkipped[$suiteName][$test->getName()])) {
$skipped[] = $test;
}
}
$suite->setTests($skipped);
}
}
/**
* Create a new event scanner instance.
*
* @param array $scan
* @return void
*/
public function __construct(array $scan)
{
$this->scan = $scan;
foreach (Finder::create()->files()->in(__DIR__ . '/Annotations') as $file) {
AnnotationRegistry::registerFile($file->getRealPath());
}
}
/**
*
* @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator
* @return object
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$manifest = $serviceLocator->get('manifest');
$extension = $serviceLocator->get('extension.odmcore');
$config = new Configuration();
$config->setProxyDir($extension->getProxyDir());
$config->setProxyNamespace('Proxies');
$config->setHydratorDir($extension->getHydratorDir());
$config->setHydratorNamespace('Hydrators');
$config->setDefaultDB($extension->getDefaultDb());
$config->setClassMetadataFactoryName($extension->getClassMetadataFactory());
$config->setMetadataCacheImpl(new ArrayCache());
//create driver chain
$chain = new MappingDriverChain();
foreach ($manifest->getModels() as $namespace => $path) {
$driver = new AnnotationDriver(new AnnotationReader(), $path);
$chain->addDriver($driver, $namespace);
}
$config->setMetadataDriverImpl($chain);
//register filters
foreach ($extension->getFilters() as $name => $class) {
$config->addFilter($name, $class);
}
//create event manager
$eventManager = new EventManager();
foreach ($manifest->getSubscribers() as $subscriber) {
$eventManager->addEventSubscriber($serviceLocator->get($subscriber));
}
//register annotations
AnnotationRegistry::registerLoader(function ($className) {
return class_exists($className);
});
$conn = new Connection(null, array(), $config);
return ModelManager::create($conn, $config, $eventManager);
}
/**
* @param Container|Application $app
*/
public function register(Container $app)
{
if (!$app->offsetExists('annot.useServiceControllers')) {
$app['annot.useServiceControllers'] = true;
}
$app["annot"] = function (Container $app) {
return new AnnotationService($app);
};
// A custom auto loader for Doctrine Annotations since it can't handle PSR-4 directory structure
AnnotationRegistry::registerLoader(function ($class) {
return class_exists($class);
});
// Register ServiceControllerServiceProvider here so the user doesn't have to.
if ($app['annot.useServiceControllers']) {
$app->register(new ServiceControllerServiceProvider());
}
// this service registers the service controller and can be overridden by the user
$app['annot.registerServiceController'] = $app->protect(function ($controllerName) use($app) {
if ($app['annot.useServiceControllers']) {
$app["{$controllerName}"] = function (Application $app) use($controllerName) {
return new $controllerName($app);
};
}
});
$app['annot.controllerFinder'] = $app->protect(function (Application $app, $dir) {
return $app['annot']->getFiles($dir, $app['annot.controllerNamespace']);
});
/** @noinspection PhpUnusedParameterInspection */
$app['annot.controller_factory'] = $app->protect(function (Application $app, $controllerName, $methodName, $separator) {
return $controllerName . $separator . $methodName;
});
$app['annot.controllerNamespace'] = '';
}
public function __construct($setConfigFiles = true)
{
if ($setConfigFiles) {
$this->configFile = __DIR__ . '/../../../config.php';
$this->localConfigFile = __DIR__ . '/../../../config.local.php';
}
parent::__construct();
$isDevMode = false;
$cache = new \Doctrine\Common\Cache\FilesystemCache(__DIR__ . '/../../tmp');
$config = Setup::createConfiguration($isDevMode, __DIR__ . '/../../tmp', $cache);
$config->setProxyDir(__DIR__ . '/../../tmp');
$config->setProxyNamespace('MyProject\\Proxies');
$config->setAutoGenerateProxyClasses(true);
$paths = [__DIR__ . '/../Entity'];
$driver = new \Doctrine\ORM\Mapping\Driver\AnnotationDriver(new AnnotationReader(), $paths);
\Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists');
$config->setMetadataDriverImpl($driver);
//$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$conn = ['driver' => 'mysqli', 'host' => '127.0.0.1', 'user' => $this->databaseFactory->getUserName(), 'password' => $this->databaseFactory->getPassword(), 'dbname' => $this->databaseFactory->getDatabaseName()];
$this->entityManager = EntityManager::create($conn, $config);
$this->entityManager->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string');
\Doctrine\DBAL\Types\Type::addType('enum', StringType::class);
$this->entityManager->getConfiguration()->addCustomStringFunction('DATE', DateFunction::class);
$this->user = $this->entityManager->createQueryBuilder()->select('u')->from(Sources\Tests\Entity\User::class, 'u');
}
protected static function registerValidatorAnnotations($force = false)
{
if (!$force && self::$registered) {
return;
}
$refl = new \ReflectionClass(Validation::class);
if ($refl->getFileName() === false) {
// We can't setup the auto loading without knowing the path
return;
}
$filePath = str_replace('\\', '/', $refl->getFileName());
// Detect PSR-0 loading
$psr0Path = '/Symfony/Component/Validator/Validation.php';
if (substr($filePath, -strlen($psr0Path)) === $psr0Path) {
AnnotationRegistry::registerAutoloadNamespace('Symfony\\Component\\Validator\\Constraints', substr($filePath, 0, -strlen($psr0Path)));
self::$registered = true;
return;
}
// Custom PSR-4 loader
$constraintsDir = dirname($filePath) . '/Constraints/';
AnnotationRegistry::registerLoader(function ($class) use($constraintsDir) {
$ns = 'Symfony\\Component\\Validator\\Constraints\\';
if (strpos($class, $ns) !== 0) {
return;
}
$filePath = $constraintsDir . str_replace('\\', DIRECTORY_SEPARATOR, substr($class, strlen($ns))) . '.php';
if (file_exists($filePath)) {
include $filePath;
return true;
}
});
self::$registered = true;
}
public function __construct()
{
// Hack to ensure an attempt to autoload an annotation class is made
AnnotationRegistry::registerLoader(function ($class) {
return (bool) class_exists($class);
});
}
/**
* @param array $paths
* @return \Doctrine\ORM\Mapping\Driver\AnnotationDriver
*/
protected function createAnnotationDriver($paths = array(), $alias = null)
{
if (version_compare(\Doctrine\Common\Version::VERSION, '3.0.0', '>=')) {
$reader = new \Doctrine\Common\Annotations\CachedReader(new \Doctrine\Common\Annotations\AnnotationReader(), new ArrayCache());
} else {
if (version_compare(\Doctrine\Common\Version::VERSION, '2.2.0-DEV', '>=')) {
// Register the ORM Annotations in the AnnotationRegistry
$reader = new \Doctrine\Common\Annotations\SimpleAnnotationReader();
$reader->addNamespace('Doctrine\\ORM\\Mapping');
$reader = new \Doctrine\Common\Annotations\CachedReader($reader, new ArrayCache());
} else {
if (version_compare(\Doctrine\Common\Version::VERSION, '2.1.0-BETA3-DEV', '>=')) {
$reader = new \Doctrine\Common\Annotations\AnnotationReader();
$reader->setIgnoreNotImportedAnnotations(true);
$reader->setEnableParsePhpImports(false);
if ($alias) {
$reader->setAnnotationNamespaceAlias('Doctrine\\ORM\\Mapping\\', $alias);
} else {
$reader->setDefaultAnnotationNamespace('Doctrine\\ORM\\Mapping\\');
}
$reader = new \Doctrine\Common\Annotations\CachedReader(new \Doctrine\Common\Annotations\IndexedReader($reader), new ArrayCache());
} else {
$reader = new \Doctrine\Common\Annotations\AnnotationReader();
if ($alias) {
$reader->setAnnotationNamespaceAlias('Doctrine\\ORM\\Mapping\\', $alias);
} else {
$reader->setDefaultAnnotationNamespace('Doctrine\\ORM\\Mapping\\');
}
}
}
}
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(__DIR__ . "/../../../lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php");
return new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($reader, (array) $paths);
}
public function __construct(array $dbConfig, array $options = array())
{
extract($options);
$entityClassLoader = new ClassLoader("Entities", $entityPath);
$entityClassLoader->register();
$proxyPath = isset($proxyPath) ? $proxyPath : $entityPath;
$proxyClassLoader = new ClassLoader("Proxies", $proxyPath);
$proxyClassLoader->register();
$config = new Configuration();
if ($isDevMode || $isArrayCache) {
$cache = new ArrayCache();
} else {
$cache = new ApcCache();
}
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setProxyDir($proxyPath);
$config->setProxyNamespace($namespaces["proxy"]);
if (isset($isDevMode) && $isDevMode) {
$config->setAutogenerateProxyClasses(true);
}
if (isset($driverClass) && class_exists($driverClass)) {
$annotationDriver = new $driverClass($entity_driver);
} else {
$annotationDriver = new AnnotationDriver(new AnnotationReader(), array($entityPath));
AnnotationRegistry::registerLoader('class_exists');
}
$config->setMetadataDriverImpl($annotationDriver);
$this->setEntityManager($dbConfig, $config);
}
public function setup()
{
$class = new ReflectionClass('Doctrine\\ORM\\Mapping\\Annotation');
$filename = $class->getFileName();
AnnotationRegistry::registerLoader('class_exists');
AnnotationRegistry::registerAutoloadNamespace("Doctrine\\ORM\\Mapping", dirname($filename));
}
/**
* Return a DIC-IT container, using adapter to respect Pyrite interface.
*
* @param Request $request Current request object.
* @param string $containerPath Path to load config from.
*
* @return \Pyrite\Container\Container
*/
public static function build(Request $request, $containerPath)
{
$config = new NullConfig();
if (null !== $containerPath && preg_match('/.*yml$/', $containerPath)) {
$config = new YML($containerPath);
}
if (null !== $containerPath && preg_match('/.*php$/', $containerPath)) {
$config = new PHP($containerPath);
}
$activator = new ActivatorFactory();
$container = new DICITAdapter($config, $activator);
$activator->addActivator('security', $container->get('SecurityActivator'), false);
// initialize the translation engine
$translationManager = $container->get('TranslationEngine');
$host = $request->getHttpHost();
$locale = $container->getParameter('default_locale.' . str_replace('.', '_', $host));
if ($locale === null) {
$locale = $container->getParameter('default_locale.default');
}
$container->setParameter('current_locale', $locale);
$translationManager->setLocale($locale);
$reader = new \Doctrine\Common\Annotations\AnnotationReader();
\Doctrine\Common\Annotations\AnnotationRegistry::registerLoader(function ($class) {
return class_exists($class);
});
$container->bind('AnnotationReader', $reader);
$director = $container->get('PyRestDirector');
$packages = $container->getParameter('crud.packages');
foreach ($packages as $packageName => $packageConfiguration) {
$director->buildAll($packageName);
}
return $container;
}
public function __construct(Reader $reader = null)
{
AnnotationRegistry::registerFile(__DIR__ . '/Annotations/PluginAnnotations.php');
if ($reader) {
$this->setAnnotationReader($reader);
}
}
protected function setUp()
{
// Register the DREST annotations
\Drest\Mapping\Driver\AnnotationDriver::registerAnnotations();
// Register the ORM annotations
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile(__DIR__ . '/../../vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
}
