/** * Modifies the Request object to apply configuration information found in * controllers annotations like the template to render or HTTP caching * configuration. * * @param FilterControllerEvent $event A FilterControllerEvent instance */ public function onKernelController(FilterControllerEvent $event) { if (!is_array($controller = $event->getController())) { return; } $className = class_exists('Doctrine\\Common\\Util\\ClassUtils') ? ClassUtils::getClass($controller[0]) : get_class($controller[0]); $object = new \ReflectionClass($className); $method = $object->getMethod($controller[1]); $classConfigurations = $this->getConfigurations($this->reader->getClassAnnotations($object)); $methodConfigurations = $this->getConfigurations($this->reader->getMethodAnnotations($method)); $configurations = array(); foreach (array_merge(array_keys($classConfigurations), array_keys($methodConfigurations)) as $key) { if (!array_key_exists($key, $classConfigurations)) { $configurations[$key] = $methodConfigurations[$key]; } elseif (!array_key_exists($key, $methodConfigurations)) { $configurations[$key] = $classConfigurations[$key]; } else { if (is_array($classConfigurations[$key])) { if (!is_array($methodConfigurations[$key])) { throw new \UnexpectedValueException('Configurations should both be an array or both not be an array'); } $configurations[$key] = array_merge($classConfigurations[$key], $methodConfigurations[$key]); } else { // method configuration overrides class configuration $configurations[$key] = $methodConfigurations[$key]; } } } $request = $event->getRequest(); foreach ($configurations as $key => $attributes) { $request->attributes->set($key, $attributes); } }
/** * Load metadata class * * @param \ReflectionClass $class * @return ClassMetadata */ public function loadMetadataForClass(\ReflectionClass $class) { $classMetadata = new ClassMetadata($class->name); $classMetadata->fileResources[] = $class->getFileName(); foreach ($this->reader->getClassAnnotations($class) as $annotation) { if ($annotation instanceof NamespaceNode) { $classMetadata->addGraphNamespace($annotation); } if ($annotation instanceof GraphNode) { $classMetadata->addGraphMetadata($annotation, new MetadataValue($annotation->value)); } } foreach ($class->getProperties() as $property) { foreach ($this->reader->getPropertyAnnotations($property) as $annotation) { if ($annotation instanceof GraphNode) { $classMetadata->addGraphMetadata($annotation, new PropertyMetadata($class->name, $property->name)); } } } foreach ($class->getMethods() as $method) { foreach ($this->reader->getMethodAnnotations($method) as $annotation) { if ($annotation instanceof GraphNode) { $classMetadata->addGraphMetadata($annotation, new MethodMetadata($class->name, $method->name)); } } } return $classMetadata; }
public function onKernelController(FilterControllerEvent $event) { if (!is_array($controller = $event->getController())) { return; } $object = new \ReflectionObject($controller[0]); $method = $object->getMethod($controller[1]); $classConfigurations = $this->reader->getClassAnnotations($object); $methodConfigurations = $this->reader->getMethodAnnotations($method); foreach (array_merge($classConfigurations, $methodConfigurations) as $configuration) { if ($configuration instanceof OAuth2) { $token = $this->token_storage->getToken(); // If no access token is found by the firewall, then returns an authentication error if (!$token instanceof OAuth2Token) { $this->createAuthenticationException($event, 'OAuth2 authentication required'); return; } foreach ($this->getCheckers() as $checker) { $result = $checker->check($token, $configuration); if (null !== $result) { $this->createAccessDeniedException($event, $result); return; } } } } }
/** * {@inheritDoc} */ public function loadForClass($class, $group) { $reflectionClass = Reflection::loadClassReflection($class); $classAnnotations = $this->reader->getClassAnnotations($reflectionClass); $securityClassAnnotation = null; $rules = array(); foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof ClassSecurityAnnotation && $group == $classAnnotation->group) { if ($securityClassAnnotation) { throw new \RuntimeException(sprintf('The @ClassSecurity annotation already defined in class "%s".', $reflectionClass->getName())); } $securityClassAnnotation = $classAnnotation; } if ($rule = $this->transformAnnotationToRule($classAnnotation, $group, $class)) { $rules[] = $rule; } } if (!$securityClassAnnotation && !count($rules)) { return null; } if ($securityClassAnnotation) { $strategy = $securityClassAnnotation->strategy; } else { $strategy = Security::STRATEGY_AFFIRMATIVE; } $securityClass = new ClassSecurity($reflectionClass->getName(), $strategy, $rules, $group); return $securityClass; }
public function onPostSerialize(ObjectEvent $event) { /** * @var JsonSerializationVisitor $visitor */ $visitor = $event->getVisitor(); $object = $event->getObject(); $annotations = $this->annotationReader->getClassAnnotations(new \ReflectionObject($object)); $links = array(); foreach ($annotations as $annotation) { if ($annotation instanceof Link) { if ($annotation->url) { $uri = $this->evaluate($annotation->url, $object); } else { $uri = $this->router->generate($annotation->route, $this->resolveParams($annotation->params, $object)); } // allow a blank URI to be an optional link if ($uri) { $links[$annotation->name] = $uri; } } } if ($links) { $visitor->addData('_links', $links); } }
/** * Reads the "@Access" annotations from the controller stores them in the "access" route option. */ public function onConfigureRoute($event, $route) { if (!$this->reader) { $this->reader = new SimpleAnnotationReader(); $this->reader->addNamespace('Pagekit\\User\\Annotation'); } if (!$route->getControllerClass()) { return; } $access = []; foreach (array_merge($this->reader->getClassAnnotations($route->getControllerClass()), $this->reader->getMethodAnnotations($route->getControllerMethod())) as $annot) { if (!$annot instanceof Access) { continue; } if ($expression = $annot->getExpression()) { $access[] = $expression; } if ($admin = $annot->getAdmin() !== null) { $route->setPath('admin' . rtrim($route->getPath(), '/')); $permission = 'system: access admin area'; if ($admin) { $access[] = $permission; } else { if ($key = array_search($permission, $access)) { unset($access[$key]); } } } } if ($access) { $route->setDefault('_access', array_unique($access)); } }
/** * {@inheritdoc} */ public function loadMetadataForClass(\ReflectionClass $class) { $annotations = $this->reader->getClassAnnotations($class); if (0 === count($annotations)) { return null; } $classMetadata = new ClassMetadata($class->getName()); $classMetadata->fileResources[] = $class->getFileName(); foreach ($annotations as $annotation) { if ($annotation instanceof Annotation\Resource) { // auto transform type from class name if (!$annotation->type) { $annotation->type = String::dasherize($class->getShortName()); } $classMetadata->setResource(new Resource($annotation->type, $annotation->showLinkSelf)); } } $classProperties = $class->getProperties(); foreach ($classProperties as $property) { $annotations = $this->reader->getPropertyAnnotations($property); foreach ($annotations as $annotation) { if ($annotation instanceof Annotation\Id) { $classMetadata->setIdField($property->getName()); } else { if ($annotation instanceof Annotation\Relationship) { $classMetadata->addRelationship(new Relationship($property->getName(), $annotation->includeByDefault, $annotation->showLinkSelf, $annotation->showLinkRelated)); } } } } return $classMetadata; }
public function onFilterController(FilterControllerEvent $event) { list($object, $method) = $event->getController(); // the controller could be a proxy $className = ClassUtils::getClass($object); $reflectionClass = new \ReflectionClass($className); $reflectionMethod = $reflectionClass->getMethod($method); $allControllerAnnotations = $this->annotationReader->getClassAnnotations($reflectionClass); $allMethodAnnotations = $this->annotationReader->getMethodAnnotations($reflectionMethod); $guardAnnotationsFilter = function ($annotation) { return $annotation instanceof Guard; }; $controllerGuardAnnotations = array_filter($allControllerAnnotations, $guardAnnotationsFilter); $methodGuardAnnotations = array_filter($allMethodAnnotations, $guardAnnotationsFilter); $guardAnnotations = array_merge($controllerGuardAnnotations, $methodGuardAnnotations); $permissions = []; foreach ($guardAnnotations as $guardAnnotation) { $value = $guardAnnotation->value; if (!is_array($value)) { $value = [$value]; } $permissions = array_merge($value, $permissions); } $permissions = array_unique($permissions); if (!empty($permissions) && !$this->security->isGranted($permissions)) { $e = new PermissionRequiredException(); $e->setRequiredPermissions($permissions)->setCurrentPermissions($this->security->getToken()->getUser()->getPermissions()); throw $e; } }
/** * Get Annotations for class * * @param \ReflectionClass $class * @return array */ public function getClassAnnotations(\ReflectionClass $class) { $annotations = array(); foreach ($this->delegate->getClassAnnotations($class) as $annot) { $annotations[get_class($annot)] = $annot; } return $annotations; }
/** * {@inheritdoc} */ public function isClassInjected(\ReflectionClass $class) { foreach ($this->reader->getClassAnnotations($class) as $annotation) { if ($annotation instanceof Inject) { return true; } } return false; }
/** * Annotations specifically related to Entity Transformation as defined in the TransformMapping class * * @param $class * @return null | TransformMapping */ public function getTransformAnnotations($class) { $annotations = $this->reader->getClassAnnotations(new \ReflectionClass($class)); foreach ($annotations as $annotation) { if ($annotation instanceof TransformMapping) { return $annotation; } } return null; }
/** * Get the annotation from a class or null if it doesn't exists. * * @param EntityManagerInterface $em * @param mixed $entity * @return bool */ public function isTracked(EntityManagerInterface $em, $entity) { $class = get_class($entity); $annotations = $this->reader->getClassAnnotations($em->getClassMetadata($class)->getReflectionClass()); foreach ($annotations as $annotation) { if ($annotation instanceof Tracked) { return true; } } return false; }
/** * Get object mapping annotation for class * * @param \ReflectionClass $refClass * @param string $group * * @return Object|null */ private function getObjectMappingAnnotation(\ReflectionClass $refClass, $group) { $classAnnotations = $this->reader->getClassAnnotations($refClass); foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof Object) { if ($classAnnotation->group == $group) { return $classAnnotation; } } } return null; }
/** * {@inheritDoc} */ public function getClassAnnotations(\ReflectionClass $class) { $cacheKey = $class->getName(); if (isset($this->loadedAnnotations[$cacheKey])) { return $this->loadedAnnotations[$cacheKey]; } if (false === ($annots = $this->fetchFromCache($cacheKey, $class))) { $annots = $this->delegate->getClassAnnotations($class); $this->saveToCache($cacheKey, $annots); } return $this->loadedAnnotations[$cacheKey] = $annots; }
/** * Annotations specifically related to Entity Transformation as defined in the Proxy class * * @param $class * @return null | Proxy */ public function getProxyAnnotations($class) { if ($this->doctrineProxyResolver->isDoctrineProxy($class)) { $class = $this->doctrineProxyResolver->unwrapDoctrineProxyClass($class); } $annotations = $this->reader->getClassAnnotations(new \ReflectionClass($class)); foreach ($annotations as $annotation) { if ($annotation instanceof Proxy) { return $annotation; } } return null; }
/** * Modifies the Request object to apply configuration information found in * controllers annotations like the template to render or HTTP caching * configuration. * * @param FilterControllerEvent $event A FilterControllerEvent instance */ public function onKernelController(FilterControllerEvent $event) { if (!is_array($controller = $event->getController())) { return; } $object = new \ReflectionObject($controller[0]); $method = $object->getMethod($controller[1]); $request = $event->getRequest(); foreach (array_merge($this->reader->getClassAnnotations($object), $this->reader->getMethodAnnotations($method)) as $configuration) { if ($configuration instanceof ConfigurationInterface) { $request->attributes->set('_' . $configuration->getAliasName(), $configuration); } } }
/** * @return array|null */ public function getClassAnnotations() { if (null === $this->classAnnotations) { $this->classAnnotations = $this->reader->getClassAnnotations($this->reflectionClass); } return $this->classAnnotations; }
/** * {@inheritDoc} */ public function loadMetadataForClass($className, ServiceMetadata $serviceMetadata) { // get all class annotations $reflClass = new \ReflectionClass($className); $classAnnotations = $this->reader->getClassAnnotations($reflClass); $classAnnotations = $this->indexAnnotationsByType($classAnnotations); // load headline service information $serviceAnnotation = $this->getAnnotation($classAnnotations, self::ANNOTATION_SERVICE); if ($serviceAnnotation === false) { throw Exception::classIsNotMappedService($className); } // process events foreach ($reflClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $reflMethod) { $methodAnnotations = $this->reader->getMethodAnnotations($reflMethod); $methodAnnotations = $this->indexAnnotationsByType($methodAnnotations); // process listeners $listenerAnnotations = $this->getAnnotation($methodAnnotations, self::ANNOTATION_LISTENER); if ($listenerAnnotations !== false) { if (!is_array($listenerAnnotations)) { $listenerAnnotations = array($listenerAnnotations); } foreach ($listenerAnnotations as $listenerAnnotation) { // ensure we don't double-up listener entries $existingListeners = $serviceMetadata->getListeners($listenerAnnotation->event); if (!in_array($reflMethod->getName(), $existingListeners)) { $serviceMetadata->addListener($listenerAnnotation->event, $reflMethod->getName()); } } } } }
private static function readFormType(\Doctrine\Common\Annotations\Reader $reader, \ReflectionClass $rc, array &$out, array &$non_deep_fields) { $as = $reader->getClassAnnotations($rc); $annot = null; if ($as) { foreach ($as as $_annot) { if ($_annot instanceof \Symforce\AdminBundle\Compiler\Annotation\FormType) { if (null !== $annot) { throw new \Exception(sprintf("sf_admin.form.type ( class: %s ) has multi form annotation", $rc->getName())); } $annot = $_annot; } } } if ($annot) { foreach ($annot as $key => $value) { if (!isset($out[$key]) || null === $out[$key]) { if (!$out['deep'] || !in_array($key, $non_deep_fields)) { $out[$key] = $value; } } } } $parent = $rc->getParentClass(); if ($parent && !$parent->isAbstract()) { $out['deep']++; self::readFormType($reader, $parent, $out, $non_deep_fields); } }
/** * Retrieves the attachments of the specified object * * @param mixed $object * @return WebDev\AttachmentBundle\Attachement\File[] */ public function files($object) { if (!is_object($object)) { throw new Exception("Can't retrieve the attachments of a " . get_type($object)); } $class = new ReflectionClass($object); $files = array(); foreach ($this->reader->getClassAnnotations($class) as $annotation) { if (!$annotation instanceof FileAttachment) { continue; } $file = new File($annotation, $object, $this); $files[$file->getName()] = $file; } return $files; }
/** * {@inheritDoc} */ public function loadMetadataForClass($className, ResourceMetadata $resourceMetadata) { // get all class annotations $reflClass = new \ReflectionClass($className); $classAnnotations = $this->reader->getClassAnnotations($reflClass); $classAnnotations = $this->indexAnnotationsByType($classAnnotations); $resourceAnnotation = $this->getAnnotation($classAnnotations, 'BedRest\\Resource\\Mapping\\Annotation\\Resource'); if ($resourceAnnotation !== false) { if (!empty($resourceAnnotation->name)) { $resourceMetadata->setName($resourceAnnotation->name); } else { $resourceName = Inflector::tableize(substr($className, strrpos($className, '\\') + 1)); $resourceMetadata->setName($resourceName); } } $handlerAnnotation = $this->getAnnotation($classAnnotations, 'BedRest\\Resource\\Mapping\\Annotation\\Handler'); if ($handlerAnnotation !== false) { if (!empty($handlerAnnotation->service)) { $resourceMetadata->setService($handlerAnnotation->service); } } // properties $subResources = array(); foreach ($reflClass->getProperties() as $reflProp) { $propAnnotations = $this->reader->getPropertyAnnotations($reflProp); $propAnnotations = $this->indexAnnotationsByType($propAnnotations); $subResourceAnnotation = $this->getAnnotation($propAnnotations, 'BedRest\\Resource\\Mapping\\Annotation\\SubResource'); if ($subResourceAnnotation !== false) { $subResources[$subResourceAnnotation->name] = array('fieldName' => $reflProp->name, 'service' => $subResourceAnnotation->service); } } $resourceMetadata->setSubResources($subResources); }
public function getClassAnnotations(\ReflectionClass $class) { $cacheKey = $class->getName() . self::$CACHE_SALT; if (isset($this->loadedAnnotations[$cacheKey])) { return $this->loadedAnnotations[$cacheKey]; } // Attempt to grab data from cache if (($data = $this->cache->fetch($cacheKey)) !== false) { if (!$this->debug || $this->isCacheFresh($cacheKey, $class)) { return $data; } } $annots = $this->delegate->getClassAnnotations($class); $this->cache->save($cacheKey, $annots); $this->cache->save('[C]' . $cacheKey, time()); return $this->loadedAnnotations[$cacheKey] = $annots; }
/** * @param \ReflectionClass $class * * @return \Metadata\ClassMetadata */ public function loadMetadataForClass(\ReflectionClass $class) { $classMetadata = new ClassMetadata($class->name); $classMetadata->fileResources[] = $class->getFilename(); foreach ($this->reader->getClassAnnotations($class) as $annotation) { if ($annotation instanceof Schema) { $classMetadata->schema = $annotation->name; } if ($annotation instanceof Inherit) { $classMetadata->inherit = $annotation->name; } } if (null !== $classMetadata->schema) { return $classMetadata; } return null; }
/** * {@inheritdoc} */ public function loadClassMetadata(ClassMetadata $metadata) { $reflClass = $metadata->getReflectionClass(); $className = $reflClass->name; $success = false; foreach ($this->reader->getClassAnnotations($reflClass) as $constraint) { if ($constraint instanceof GroupSequence) { $metadata->setGroupSequence($constraint->groups); } elseif ($constraint instanceof GroupSequenceProvider) { $metadata->setGroupSequenceProvider(true); } elseif ($constraint instanceof Constraint) { $metadata->addConstraint($constraint); } $success = true; } foreach ($reflClass->getProperties() as $property) { if ($property->getDeclaringClass()->name == $className) { foreach ($this->reader->getPropertyAnnotations($property) as $constraint) { if ($constraint instanceof Constraint) { $metadata->addPropertyConstraint($property->name, $constraint); } $success = true; } } } foreach ($reflClass->getMethods() as $method) { if ($method->getDeclaringClass()->name == $className) { foreach ($this->reader->getMethodAnnotations($method) as $constraint) { if ($constraint instanceof Callback) { $constraint->callback = $method->getName(); $constraint->methods = null; $metadata->addConstraint($constraint); } elseif ($constraint instanceof Constraint) { if (preg_match('/^(get|is|has)(.+)$/i', $method->name, $matches)) { $metadata->addGetterConstraint(lcfirst($matches[2]), $constraint); } else { throw new MappingException(sprintf('The constraint on "%s::%s" cannot be added. Constraints can only be added on methods beginning with "get", "is" or "has".', $className, $method->name)); } } $success = true; } } } return $success; }
private function parseSingleClassFile($className) { //annotation on class $reflectionClass = new \ReflectionClass($className); $classAnnotations = $this->annotationReader->getClassAnnotations($reflectionClass); if (!$classAnnotations) { return; } foreach ($classAnnotations as $classAnnotation) { //name not set => bean name className? if (!isset($classAnnotation->name) or $classAnnotation->name == '') { $beanClassName = lcfirst(join('', array_slice(explode('\\', $className), -1))); $classAnnotation->name = $beanClassName; } $bean = array('name' => $classAnnotation->name, 'class' => $className, 'scope' => $classAnnotation->scope, 'lazyInit' => (string) $classAnnotation->lazyInit); //annotation on method $methods = $reflectionClass->getMethods(); foreach ($methods as $method) { if ($method->name == self::CONSTRUCT_METHOD) { //annotaiton on construct $bean = $this->analyzeConstruct($className, $method, $bean); } else { $reflectionMethod = new \ReflectionMethod($className, $method->name); $methodAnnotations = $this->annotationReader->getMethodAnnotations($reflectionMethod); if ($methodAnnotations) { foreach ($methodAnnotations as $pathToClassFile) { if (isset($method->name)) { $bean[get_class($pathToClassFile)] = $method->name; } } } } } //annotation on properties $properties = $reflectionClass->getProperties(); $allProperties = array(); $temp = array(); foreach ($properties as $property) { $reflectionProperty = new \ReflectionProperty($className, $property->name); $propertyAnnotations = $this->annotationReader->getPropertyAnnotations($reflectionProperty); if ($propertyAnnotations) { foreach ($propertyAnnotations as $pathToClassFile) { $allProperties[$property->name] = array(get_class($pathToClassFile) => $pathToClassFile->name); if ($pathToClassFile->ref) { $temp[] = array('name' => $property->name, 'ref' => $pathToClassFile->ref); } else { $temp[] = array('name' => $property->name, 'value' => $this->replaceVariable($pathToClassFile->value), 'type' => $pathToClassFile->type); } } } if ($temp) { $bean['properties'] = $temp; } } $this->context[$classAnnotation->name] = $bean; } }
/** * @param string $path Directory path to compile */ public function compile($path) { $this->loader->setCallback(function ($class, $file) { $reflClass = new \ReflectionClass($class); //Ignore abstract classes if ($reflClass->isAbstract()) { return; } $classAnnotations = $this->reader->getClassAnnotations($reflClass); $this->compileClass($reflClass, $classAnnotations); foreach ($reflClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $reflMethod) { /** @var $reflMethod \ReflectionMethod */ $methodAnnotations = $this->reader->getMethodAnnotations($reflMethod); $this->compileMethod($reflClass, $reflMethod, $methodAnnotations); } }); $this->loader->load($path); }
/** * @inheritDoc */ public function get(\ReflectionFunctionAbstract $controllerReflector) { if (!$controllerReflector instanceof \ReflectionMethod) { throw new \InvalidArgumentException("Reading annotations from functions other than class methods is not supported yet"); } $methodAnnots = $this->annotationReader->getMethodAnnotations($controllerReflector); $classAnnots = $this->annotationReader->getClassAnnotations($controllerReflector->getDeclaringClass()); $annots = array_merge($classAnnots, $methodAnnots); $params = []; foreach ($annots as $annotation) { if (!$annotation instanceof Param) { continue; } $this->resolve($annotation); $params[$annotation->name] = $annotation; } return $params; }
/** * @test */ public function load_class_loads_metadata_correctly() { $reflClass = new \ReflectionClass('Kcs\\Metadata\\Tests\\Fixtures\\AnnotationProcessorLoader\\SimpleObject'); $metadata = new ClassMetadata($reflClass); $this->reader->getClassAnnotations($reflClass)->willReturn([new ClassAnnot(), new NotHandledAnnotation()]); $this->reader->getMethodAnnotations($reflClass->getMethod('getAuthor'))->willReturn([new NotHandledAnnotation(), new MethodAnnotation1(), new MethodAnnotation2()]); $this->reader->getPropertyAnnotations($reflClass->getProperty('createdAt'))->willReturn([new NotHandledAnnotation()]); $this->reader->getPropertyAnnotations($reflClass->getProperty('author'))->willReturn([]); $this->processorFactory->getProcessor(Argument::type('Kcs\\Metadata\\Tests\\Fixtures\\AnnotationProcessorLoader\\Annotation\\NotHandledAnnotation'))->willReturn(); $classAnnotationProcessor = $this->prophesize('Kcs\\Metadata\\Loader\\Processor\\ProcessorInterface'); $classAnnotationProcessor->process(Argument::type('Kcs\\Metadata\\MetadataInterface'), Argument::type('Kcs\\Metadata\\Tests\\Fixtures\\AnnotationProcessorLoader\\Annotation\\ClassAnnot'))->shouldBeCalledTimes(1); $this->processorFactory->getProcessor(Argument::type('Kcs\\Metadata\\Tests\\Fixtures\\AnnotationProcessorLoader\\Annotation\\ClassAnnot'))->willReturn($classAnnotationProcessor->reveal()); $methodAnnotationProcessor = $this->prophesize('Kcs\\Metadata\\Loader\\Processor\\ProcessorInterface'); $methodAnnotationProcessor->process(Argument::type('Kcs\\Metadata\\MetadataInterface'), Argument::type('Kcs\\Metadata\\Tests\\Fixtures\\AnnotationProcessorLoader\\Annotation\\MethodAnnotation1'))->shouldBeCalledTimes(1); $methodAnnotationProcessor->process(Argument::type('Kcs\\Metadata\\MetadataInterface'), Argument::type('Kcs\\Metadata\\Tests\\Fixtures\\AnnotationProcessorLoader\\Annotation\\MethodAnnotation2'))->shouldBeCalledTimes(1); $this->processorFactory->getProcessor(Argument::type('Kcs\\Metadata\\Tests\\Fixtures\\AnnotationProcessorLoader\\Annotation\\MethodAnnotation1'))->willReturn($methodAnnotationProcessor->reveal()); $this->processorFactory->getProcessor(Argument::type('Kcs\\Metadata\\Tests\\Fixtures\\AnnotationProcessorLoader\\Annotation\\MethodAnnotation2'))->willReturn($methodAnnotationProcessor->reveal()); $this->loader->loadClassMetadata($metadata); }
/** * Whether the class with the specified name is transient. Only non-transient * classes, that is entities and mapped superclasses, should have their metadata loaded. * A class is non-transient if it is annotated with either @Entity or * @MappedSuperclass in the class doc block. * * @param string $className * @return boolean */ public function isTransient($className) { $classAnnotations = $this->reader->getClassAnnotations(new \ReflectionClass($className)); foreach ($classAnnotations as $annot) { if ($annot instanceof ODM\AbstractDocument) { return false; } } return true; }
/** * Modifies the Request object to apply configuration information found in * controllers annotations like the template to render or HTTP caching * configuration. * * @param FilterControllerEvent $event A FilterControllerEvent instance */ public function onKernelController(FilterControllerEvent $event) { if (!is_array($controller = $event->getController())) { return; } $className = class_exists('Doctrine\\Common\\Util\\ClassUtils') ? ClassUtils::getClass($controller[0]) : get_class($controller[0]); $object = new \ReflectionClass($className); $method = $object->getMethod($controller[1]); $classConfigurations = $this->getConfigurations($this->reader->getClassAnnotations($object)); $methodConfigurations = $this->getConfigurations($this->reader->getMethodAnnotations($method)); $configurations = array_merge($classConfigurations, $methodConfigurations); $request = $event->getRequest(); foreach ($configurations as $key => $attributes) { if (is_array($attributes) && count($attributes) == 1) { $attributes = $attributes[0]; } $request->attributes->set($key, $attributes); } }