protected function setUp() { AnnotationRegistry::registerLoader('class_exists'); $conn = DriverManager::getConnection(array('driver' => 'pdo_sqlite', 'memory' => true)); $this->em = $this->_getTestEntityManager($conn); $reader = new SimpleAnnotationReader(); $reader->addNamespace('Bazinga\\Bundle\\GeocoderBundle\\Mapping\\Annotations'); $reader->addNamespace('Doctrine\\ORM\\Mapping'); $driver = new AnnotationDriver($reader); $geocoder = new GoogleMaps(new CurlHttpAdapter()); $this->listener = new GeocoderListener($geocoder, $driver); $this->em->getEventManager()->addEventSubscriber($this->listener); $sm = new SchemaTool($this->em); $sm->createSchema(array($this->em->getClassMetadata('Bazinga\\Bundle\\GeocoderBundle\\Tests\\Doctrine\\ORM\\Dummy'))); }
protected function getReader() { $reader = new SimpleAnnotationReader(); $reader->addNamespace(__NAMESPACE__); $reader->addNamespace(__NAMESPACE__ . '\\Fixtures'); $reader->addNamespace(__NAMESPACE__ . '\\Fixtures\\Annotation'); return $reader; }
/** * Register the annotation loader. * * @return void */ protected function registerAnnotationLoader() { $this->reader->addNamespace('Dingo\\Blueprint\\Annotation'); $this->reader->addNamespace('Dingo\\Blueprint\\Annotation\\Method'); AnnotationRegistry::registerLoader(function ($class) { $path = __DIR__ . '/' . str_replace(['Dingo\\Blueprint\\', '\\'], ['', DIRECTORY_SEPARATOR], $class) . '.php'; if (file_exists($path)) { require_once $path; return true; } }); }
/** * @param array $paths * @return \Doctrine\Common\Annotations\AnnotationReader */ protected function createAnnotationDriver($paths = array(), $alias = null) { if (version_compare(\Doctrine\Common\Version::VERSION, '2.2.0-DEV', '>=')) { // Register the ORM Annotations in the AnnotationRegistry AnnotationRegistry::registerFile(__DIR__ . '/../../../lib/Doctrine/ORM//Mapping/Driver/DoctrineAnnotations.php'); $reader = new 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\\'); } } } return new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($reader, (array) $paths); }
/** * @return null */ public function init() { parent::init(); $this->annotReader = new SimpleAnnotationReader(); $this->annotReader->addNamespace(__NAMESPACE__ . '\\Annotation\\Action'); $this->annotReader->addNamespace(__NAMESPACE__ . '\\Annotation\\Common'); }
public function testIssueSimpleAnnotationReader() { $reader = new SimpleAnnotationReader(); $reader->addNamespace('Doctrine\\Tests\\Common\\Annotations\\Ticket\\Doctrine\\ORM\\Mapping'); $annots = $reader->getClassAnnotations(new \ReflectionClass(__NAMESPACE__ . "\\MappedClass")); $this->assertEquals(1, count($annots)); $this->assertInstanceOf("Doctrine\\Tests\\Common\\Annotations\\Ticket\\Doctrine\\ORM\\Mapping\\Entity", $annots[0]); }
public function test_get_all_class_names_considers_class_paths_from_config() { Kohana::$config->load('doctrine')->set('entity_paths', array('Some/Entity/Path' => TRUE, 'Other/Entities' => TRUE)); $reader = new SimpleAnnotationReader(); $reader->addNamespace('Doctrine\\ORM\\Mapping'); $driver = new Doctrine_KohanaAnnotationDriver(new CachedReader($reader, new ArrayCache()), Kohana::include_paths()); $this->assertEquals(array('Some_Entity_Path_Entity', 'Other_Entities_Entity'), $driver->getAllClassNames()); }
/** * @return SimpleAnnotationReader */ protected function getAnnotationReader() { if ($this->annotationReader === null) { $this->annotationReader = new SimpleAnnotationReader(); $this->annotationReader->addNamespace('Supra\\Core\\Doctrine\\Annotation'); } return $this->annotationReader; }
/** * @return Reader */ public function getAnnotationReader() { if (!$this->annotationReader) { $reader = new SimpleAnnotationReader(); $reader->addNamespace('Oow\\Plugin\\Annotations'); $this->annotationReader = $reader; } return $this->annotationReader; }
/** * Constructor * * @param EntityManagerInterface $em * @param ReaderInterface $reader * @param array $namespaces * @param CacheProvider $cacheProvider */ public function __construct(EntityManagerInterface $em, ReaderInterface $reader = null, array $namespaces = array('Doctrine\\ORM\\Mapping', 'Mindgruve\\Gordo\\Domain'), CacheProvider $cacheProvider = null) { $this->em = $em; if (!$reader) { $reader = new SimpleAnnotationReader(); } foreach ($namespaces as $namespace) { $reader->addNamespace($namespace); } if ($cacheProvider) { $reader = new CachedReader($reader, $cacheProvider); } $this->reader = $reader; }
/** * Gets an annotation. * * @param mixed $from * @param string $name * @return Annotation */ protected function getAnnotation($from, $name) { if (!$this->reader) { $this->reader = new SimpleAnnotationReader(); $this->reader->addNamespace($this->namespace); } $name = "{$this->namespace}\\{$name}"; if ($from instanceof \ReflectionClass) { $annotation = $this->reader->getClassAnnotation($from, $name); } elseif ($from instanceof \ReflectionMethod) { $annotation = $this->reader->getMethodAnnotation($from, $name); } elseif ($from instanceof \ReflectionProperty) { $annotation = $this->reader->getPropertyAnnotation($from, $name); } return $annotation; }
/** * @return \Doctrine\ORM\Configuration */ protected function getDoctrine_ConfigService() { $this->services['doctrine.config'] = $instance = new Configuration(); $baseDir = $this->getParameter('app.baseDir'); $cache = $this->get('app.cache'); $instance->setMetadataCacheImpl($cache); $instance->setQueryCacheImpl($cache); $instance->setResultCacheImpl($cache); $instance->setProxyDir($baseDir . $this->getParameter('doctrine.proxy.dir')); $instance->setProxyNamespace($this->getParameter('doctrine.proxy.namespace')); $instance->setAutoGenerateProxyClasses($this->getParameter('app.devmode')); AnnotationRegistry::registerFile($baseDir . 'vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); $reader = new SimpleAnnotationReader(); $reader->addNamespace('Doctrine\\ORM\\Mapping'); $instance->setMetadataDriverImpl(new AnnotationDriver(new CachedReader($reader, $cache), array($baseDir . $this->getParameter('doctrine.entity.dir')))); return $instance; }
/** * @param ObjectManager $objectManager * @param DoctrineProxyResolver $doctrineProxyResolver * @param ReaderInterface $reader * @param array $namespaces * @param CacheProvider $cacheProvider */ public function __construct(ObjectManager $objectManager, DoctrineProxyResolver $doctrineProxyResolver = null, ReaderInterface $reader = null, array $namespaces = array('Doctrine\\ORM\\Mapping', 'Mindgruve\\Gordo\\Annotations'), CacheProvider $cacheProvider = null) { $this->objectManager = $objectManager; if (!$doctrineProxyResolver) { $doctrineProxyResolver = new DoctrineProxyResolver(); } $this->doctrineProxyResolver = $doctrineProxyResolver; if (!$reader) { $reader = new SimpleAnnotationReader(); } foreach ($namespaces as $namespace) { $reader->addNamespace($namespace); } if ($cacheProvider) { $reader = new CachedReader($reader, $cacheProvider); } $this->reader = $reader; }
/** * @param \Doctrine\Common\Cache\Cache|NULL * @param bool * @return \Doctrine\Common\Annotations\Reader */ public static function createAnnotationReader(Cache $cache = NULL, $useSimple = FALSE) { // force load doctrine annotations AnnotationRegistry::registerFile(dirname(ClassType::from('Doctrine\\ORM\\Version')->getFileName()) . '/Mapping/Driver/DoctrineAnnotations.php'); AnnotationRegistry::registerFile(__DIR__ . '/../Mapping/DiscriminatorEntry.php'); if ($useSimple) { $reader = new SimpleAnnotationReader(); $reader->addNamespace('Doctrine\\ORM\\Mapping'); } else { $reader = new AnnotationReader(); } if (!$cache) { return $reader; } return new CachedReader($reader, $cache); }
/** * Discovers all available tests in all extensions. * * @param string $extension * (optional) The name of an extension to limit discovery to; e.g., 'node'. * * @return array * An array of tests keyed by the first @group specified in each test's * PHPDoc comment block, and then keyed by class names. For example: * @code * $groups['block'] => array( * 'Drupal\block\Tests\BlockTest' => array( * 'name' => 'Drupal\block\Tests\BlockTest', * 'description' => 'Tests block UI CRUD functionality.', * 'group' => 'block', * ), * ); * @endcode * * @throws \ReflectionException * If a discovered test class does not match the expected class name. * * @todo Remove singular grouping; retain list of groups in 'group' key. * @see https://www.drupal.org/node/2296615 * @todo Add base class groups 'Kernel' + 'Web', complementing 'PHPUnit'. */ public function getTestClasses($extension = NULL) { $reader = new SimpleAnnotationReader(); $reader->addNamespace('Drupal\\simpletest\\Annotation'); if (!isset($extension)) { if ($this->cacheBackend && ($cache = $this->cacheBackend->get('simpletest:discovery:classes'))) { return $cache->data; } } $list = array(); $classmap = $this->findAllClassFiles($extension); // Prevent expensive class loader lookups for each reflected test class by // registering the complete classmap of test classes to the class loader. // This also ensures that test classes are loaded from the discovered // pathnames; a namespace/classname mismatch will throw an exception. $this->classLoader->addClassMap($classmap); foreach ($classmap as $classname => $pathname) { $finder = MockFileFinder::create($pathname); $parser = new StaticReflectionParser($classname, $finder, TRUE); try { $info = static::getTestInfo($classname, $parser->getDocComment()); } catch (MissingGroupException $e) { // If the class name ends in Test and is not a migrate table dump. if (preg_match('/Test$/', $classname) && strpos($classname, 'migrate_drupal\\Tests\\Table') === FALSE) { throw $e; } // If the class is @group annotation just skip it. Most likely it is an // abstract class, trait or test fixture. continue; } // Skip this test class if it requires unavailable modules. // @todo PHPUnit skips tests with unmet requirements when executing a test // (instead of excluding them upfront). Refactor test runner to follow // that approach. // @see https://www.drupal.org/node/1273478 if (!empty($info['requires']['module'])) { if (array_diff($info['requires']['module'], $this->availableExtensions['module'])) { continue; } } $list[$info['group']][$classname] = $info; } // Sort the groups and tests within the groups by name. uksort($list, 'strnatcasecmp'); foreach ($list as &$tests) { uksort($tests, 'strnatcasecmp'); } // Allow modules extending core tests to disable originals. \Drupal::moduleHandler()->alter('simpletest', $list); if (!isset($extension)) { if ($this->cacheBackend) { $this->cacheBackend->set('simpletest:discovery:classes', $list); } } return $list; }
public static function newInstance($paths = array(), $excludePaths = array()) { $reader = new SimpleAnnotationReader(); $reader->addNamespace('SlimAnnotation\\Mapping\\Annotation'); $cachedReader = new CachedReader($reader, new ArrayCache()); AnnotationRegistry::registerFile(__DIR__ . '/SlimAnnotations.php'); return new SlimAnnotationDriver($cachedReader, $paths, $excludePaths); }
/** * Add a new default annotation driver with a correctly configured annotation reader. If $useSimpleAnnotationReader * is true, the notation `@Document` will work, otherwise, the notation `@ODM\Document` will be supported. * * @param array $paths * @param bool $useSimpleAnnotationReader * * @return AnnotationDriver */ public function newDefaultAnnotationDriver($paths = [], $useSimpleAnnotationReader = true) { AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Annotations/DoctrineAnnotations.php'); if ($useSimpleAnnotationReader) { // Register the ORM Annotations in the AnnotationRegistry $reader = new SimpleAnnotationReader(); $reader->addNamespace('Doctrine\\ODM\\OrientDB\\Mapping\\Annotations'); $cachedReader = new CachedReader($reader, new ArrayCache()); return new AnnotationDriver($cachedReader, (array) $paths); } return new AnnotationDriver(new CachedReader(new AnnotationReader(), new ArrayCache()), (array) $paths); }
/** * Add a new default annotation driver with a correctly configured annotation reader. * * @param array $paths * @return Mapping\Driver\AnnotationDriver */ public function newDefaultAnnotationDriver($paths = array()) { if (version_compare(\Doctrine\Common\Version::VERSION, '3.0.0-DEV', '>=')) { // Register the ORM Annotations in the AnnotationRegistry AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Driver/DoctrineAnnotations.php'); $reader = new AnnotationReader(); $reader = new \Doctrine\Common\Annotations\CachedReader($reader, new \Doctrine\Common\Cache\ApcCache()); } else { if (version_compare(\Doctrine\Common\Version::VERSION, '2.3.0-DEV', '>=')) { // Register the ORM Annotations in the AnnotationRegistry // Done manually according to MongoDB ODM but that breaks existing code quickly AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Driver/DoctrineAnnotations.php'); $reader = new SimpleAnnotationReader(); $reader->addNamespace('Doctrine\\OXM\\Mapping'); $reader = new \Doctrine\Common\Annotations\CachedReader($reader, new \Doctrine\Common\Cache\ApcCache()); } else { if (version_compare(\Doctrine\Common\Version::VERSION, '2.1.0-DEV', '>=')) { // Register the ORM Annotations in the AnnotationRegistry AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Driver/DoctrineAnnotations.php'); $reader = new AnnotationReader(); $reader->setDefaultAnnotationNamespace('Doctrine\\OXM\\Mapping\\'); $reader->setIgnoreNotImportedAnnotations(true); $reader->setEnableParsePhpImports(false); $reader = new \Doctrine\Common\Annotations\CachedReader(new \Doctrine\Common\Annotations\IndexedReader($reader), new \Doctrine\Common\Cache\ApcCache()); } else { $reader = new AnnotationReader(); $reader->setDefaultAnnotationNamespace('Doctrine\\OXM\\Mapping\\'); } } } return new AnnotationDriver($reader, (array) $paths); }
/** * Create an instance of the Kohana annotation driver, which supports loading model files from across the CFS. Also * handles registering the Doctrine annotations in the Annotation registry - which would normally be handled by * Doctrine\ORM\Configuration::newDefaultAnnotationDriver. * * @return Doctrine_KohanaAnnotationDriver * @see Doctrine\ORM\Configuration::newDefaultAnnotationDriver */ protected function create_annotation_driver() { $config = $this->config->load('doctrine'); // Register the Doctrine annotations $vendor_path = $config->get('composer_vendor_path'); AnnotationRegistry::registerFile($vendor_path . 'doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php'); if ($config->get('use_simple_annotation_reader')) { // Register the ORM Annotations in the AnnotationReader $reader = new SimpleAnnotationReader(); $reader->addNamespace('Doctrine\\ORM\\Mapping'); } else { $reader = new AnnotationReader(); } $cachedReader = new CachedReader($reader, new ArrayCache()); return new Doctrine_KohanaAnnotationDriver($cachedReader, Kohana::include_paths()); }
/** * @param array $namespaces * @return \Doctrine\Common\Annotations\Reader */ protected function newDoctrineAnnotationImpl(array $namespaces) { $this->registerAnnotationLoader($namespaces); $reader = new Annotations\SimpleAnnotationReader(); foreach ($namespaces as $namespace) { $reader->addNamespace($namespace); } return $reader; }
public function addNamespace($namespace) { $this->reader->addNamespace($namespace); }
/** * Get an annotation reader instance. * * @return \Doctrine\Common\Annotations\SimpleAnnotationReader */ protected function getReader() { $reader = new SimpleAnnotationReader(); foreach ($this->namespaces as $namespace) { $reader->addNamespace($namespace); } return $reader; }
public static function getService(ArrayObject $config, Loops $loops) { if (@$config->simple) { $annotation_reader = new SimpleAnnotationReader(); $annotation_reader->addNamespace("Loops\\Annotations"); $annotation_reader->addNamespace("Loops\\Annotations\\Access"); $annotation_reader->addNamespace("Loops\\Annotations\\Admin"); $annotation_reader->addNamespace("Loops\\Annotations\\Element"); $annotation_reader->addNamespace("Loops\\Annotations\\Element\\Doctrine"); $annotation_reader->addNamespace("Loops\\Annotations\\Event\\Form"); $annotation_reader->addNamespace("Loops\\Annotations\\Event\\Renderer"); $annotation_reader->addNamespace("Loops\\Annotations\\Event\\Session"); $annotation_reader->addNamespace("Loops\\Annotations\\Form"); $annotation_reader->addNamespace("Loops\\Annotations\\Form\\Element"); $annotation_reader->addNamespace("Loops\\Annotations\\Navigation"); $annotation_reader->addNamespace("Loops\\Annotations\\Session"); return $annotation_reader; } else { return new AnnotationReader(); } }
protected function getDomainObjectAnnotations() { $reader = new SimpleAnnotationReader(); $reader->addNamespace('Oneup\\AclBundle\\Mapping\\Annotation'); $object = new \ReflectionClass('Oneup\\AclBundle\\Tests\\Model\\SomeObject'); return $reader->getClassAnnotations($object); }