/** * {@inheritDoc} */ public function loadMetadata($class) { // Try get object annotation from class $objectAnnotation = null; $classAnnotations = Reflection::loadClassAnnotations($this->reader, $class, true); foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof ObjectAnnotation) { if ($objectAnnotation) { throw new \RuntimeException(sprintf('Many @Transformer\\Object annotation in class "%s".', $class)); } $objectAnnotation = $classAnnotation; } } if (!$objectAnnotation) { throw new TransformAnnotationNotFoundException(sprintf('Not found @Object annotations in class "%s".', $class)); } // Try get properties annotations $properties = []; $classProperties = Reflection::getClassProperties($class, true); foreach ($classProperties as $classProperty) { $propertyAnnotations = $this->reader->getPropertyAnnotations($classProperty); foreach ($propertyAnnotations as $propertyAnnotation) { if ($propertyAnnotation instanceof PropertyAnnotation) { $property = new PropertyMetadata($propertyAnnotation->propertyName ?: $classProperty->getName(), $propertyAnnotation->groups, $propertyAnnotation->shouldTransform, $propertyAnnotation->expressionValue); $properties[$classProperty->getName()] = $property; } } } return new ObjectMetadata($objectAnnotation->transformedClass, $properties); }
/** * 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; }
/** * {@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; }
/** * {@inheritdoc} */ public function loadClassMetadata(ClassMetadata $metadata) { $reflClass = $metadata->getReflectionClass(); $className = $reflClass->name; $loaded = false; foreach ($reflClass->getProperties() as $property) { if ($property->getDeclaringClass()->name == $className) { foreach ($this->reader->getPropertyAnnotations($property) as $groups) { if ($groups instanceof Groups) { foreach ($groups->getGroups() as $group) { $metadata->addAttributeGroup($property->name, $group); } } $loaded = true; } } } foreach ($reflClass->getMethods() as $method) { if ($method->getDeclaringClass()->name == $className) { foreach ($this->reader->getMethodAnnotations($method) as $groups) { if ($groups instanceof Groups) { if (preg_match('/^(get|is)(.+)$/i', $method->name, $matches)) { foreach ($groups->getGroups() as $group) { $metadata->addAttributeGroup(lcfirst($matches[2]), $group); } } else { throw new \BadMethodCallException(sprintf('Groups on "%s::%s" cannot be added. Groups can only be added on methods beginning with "get" or "is".', $className, $method->name)); } } $loaded = true; } } } return $loaded; }
/** * {@inheritdoc} */ public function loadClassMetadata(ClassMetadataInterface $classMetadata) { $reflectionClass = $classMetadata->getReflectionClass(); $className = $reflectionClass->name; $loaded = false; $attributesMetadata = $classMetadata->getAttributesMetadata(); foreach ($reflectionClass->getProperties() as $property) { if (!isset($attributesMetadata[$property->name])) { $attributesMetadata[$property->name] = new AttributeMetadata($property->name); $classMetadata->addAttributeMetadata($attributesMetadata[$property->name]); } if ($property->getDeclaringClass()->name === $className) { foreach ($this->reader->getPropertyAnnotations($property) as $annotation) { if ($annotation instanceof Groups) { foreach ($annotation->getGroups() as $group) { $attributesMetadata[$property->name]->addGroup($group); } } elseif ($annotation instanceof MaxDepth) { $attributesMetadata[$property->name]->setMaxDepth($annotation->getMaxDepth()); } $loaded = true; } } } foreach ($reflectionClass->getMethods() as $method) { if ($method->getDeclaringClass()->name !== $className) { continue; } $accessorOrMutator = preg_match('/^(get|is|has|set)(.+)$/i', $method->name, $matches); if ($accessorOrMutator) { $attributeName = lcfirst($matches[2]); if (isset($attributesMetadata[$attributeName])) { $attributeMetadata = $attributesMetadata[$attributeName]; } else { $attributesMetadata[$attributeName] = $attributeMetadata = new AttributeMetadata($attributeName); $classMetadata->addAttributeMetadata($attributeMetadata); } } foreach ($this->reader->getMethodAnnotations($method) as $annotation) { if ($annotation instanceof Groups) { if (!$accessorOrMutator) { throw new MappingException(sprintf('Groups on "%s::%s" cannot be added. Groups can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name)); } foreach ($annotation->getGroups() as $group) { $attributeMetadata->addGroup($group); } } elseif ($annotation instanceof MaxDepth) { if (!$accessorOrMutator) { throw new MappingException(sprintf('MaxDepth on "%s::%s" cannot be added. MaxDepth can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name)); } $attributeMetadata->setMaxDepth($annotation->getMaxDepth()); } $loaded = true; } } return $loaded; }
public function create($class, \ReflectionProperty $reflectionProperty) { $annotations = $this->reader->getPropertyAnnotations($reflectionProperty); foreach ($annotations as $annotation) { if ($annotation instanceof GraphId) { return new IdAnnotationMetadata(); } } }
/** * @param \ReflectionClass $reflectionClass * @return Annotation[] * @throws AnnotationReaderException */ private function readPropertyAnnotations(\ReflectionClass $reflectionClass) : array { return array_reduce($reflectionClass->getProperties(), function (array $accumulator, \ReflectionProperty $reflectionProperty) { /* @var $annotations \Doctrine\Common\Annotations\Annotation[] */ $annotations = array_filter($this->reader->getPropertyAnnotations($reflectionProperty), function ($annotation) : bool { return $annotation instanceof Annotation; }); if (empty($annotations)) { return $accumulator; } return array_merge($accumulator, $this->processPropertyAnnotations($annotations, $reflectionProperty)); }, []); }
/** * @param \ReflectionProperty $property * * @return array */ private function getPropertyMapping(ReflectionProperty $property) { $metadata = []; foreach ($this->reader->getPropertyAnnotations($property) as $value) { if (!$value instanceof RiakAnnotation) { continue; } $class = get_class($value); $name = $property->getName(); $key = lcfirst(substr($class, strrpos($class, '\\') + 1)); $metadata[$key] = $name; } return $metadata; }
/** * Reads annotations for a selected property in the class * * @param ReflectionProperty $property * @param ClassMetadataInterface $metadata */ private function readProperty(ReflectionProperty $property, ClassMetadataInterface $metadata) { // Skip if this property is not from this class if ($property->getDeclaringClass()->getName() != $metadata->getClassName()) { return; } //Iterate over all annotations foreach ($this->reader->getPropertyAnnotations($property) as $rule) { //Skip is its not a rule if (!$rule instanceof Rules\Rule) { continue; } //Add Rule $metadata->addPropertyRule($property->getName(), $rule); } }
/** * {@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); }
/** * Get converter annotation * * @param \ReflectionProperty $property * * @return Money * * @throws MoneyAnnotationNotFoundException */ private function getConverterAnnotation(\ReflectionProperty $property) { $annotations = $this->reader->getPropertyAnnotations($property); $moneyAnnotation = null; foreach ($annotations as $annotation) { if ($annotation instanceof Money) { if ($moneyAnnotation) { throw new \RuntimeException(sprintf('Many Money annotation in property %s->%s', $property->getDeclaringClass()->getName(), $property->getName())); } $moneyAnnotation = $annotation; } } if ($moneyAnnotation) { return $moneyAnnotation; } throw new MoneyAnnotationNotFoundException(sprintf('Not found DateTime annotation in property %s->%s', $property->getDeclaringClass()->getName(), $property->getName())); }
/** * Get annotations for property * * @param \ReflectionProperty $property * @return array */ public function getPropertyAnnotations(\ReflectionProperty $property) { $annotations = array(); foreach ($this->delegate->getPropertyAnnotations($property) as $annot) { $annotations[get_class($annot)] = $annot; } return $annotations; }
/** * {@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; } }
/** * Return the class metadata instance * * @param string $entityName * * @return ClassMetaDataCollection */ public function getClassMetadata($entityName) { $r = new ReflectionClass($entityName); $instanceMetadataCollection = new ClassMetaDataCollection(); $instanceMetadataCollection->name = $entityName; $classAnnotations = $this->reader->getClassAnnotations($r); foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof RepositoryAttribute) { $instanceMetadataCollection->setRepository($classAnnotation->getValue()); } if ($classAnnotation instanceof ObjectClass) { $instanceMetadataCollection->setObjectClass($classAnnotation->getValue()); } if ($classAnnotation instanceof SearchDn) { $instanceMetadataCollection->setSearchDn($classAnnotation->getValue()); } if ($classAnnotation instanceof Dn) { $instanceMetadataCollection->setDn($classAnnotation->getValue()); } } foreach ($r->getProperties() as $publicAttr) { $annotations = $this->reader->getPropertyAnnotations($publicAttr); foreach ($annotations as $annotation) { if ($annotation instanceof Attribute) { $varname = $publicAttr->getName(); $attribute = $annotation->getName(); $instanceMetadataCollection->addMeta($varname, $attribute); } if ($annotation instanceof DnLinkArray) { $varname = $publicAttr->getName(); $instanceMetadataCollection->addArrayOfLink($varname, $annotation->getValue()); } if ($annotation instanceof Sequence) { $varname = $publicAttr->getName(); $instanceMetadataCollection->addSequence($varname, $annotation->getValue()); } if ($annotation instanceof DnPregMatch) { $varname = $publicAttr->getName(); $instanceMetadataCollection->addRegex($varname, $annotation->getValue()); } if ($annotation instanceof ParentDn) { $varname = $publicAttr->getName(); $instanceMetadataCollection->addParentLink($varname, $annotation->getValue()); } if ($annotation instanceof ArrayField) { $instanceMetadataCollection->addArrayField($varname); } if ($annotation instanceof Must) { $instanceMetadataCollection->addMust($varname); } if ($annotation instanceof Operational) { $instanceMetadataCollection->addOperational($varname); } } } return $instanceMetadataCollection; }
/** * @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); }
/** * {@inheritDoc} */ public function loadMetadataForClass(\ReflectionClass $class) { $metadata = new ClassMetadata($class->getName()); $metadata->fileResources[] = $class->getFileName(); $classAnnotations = $this->reader->getClassAnnotations($class); foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof Mergeable) { $metadata->accessor = $classAnnotation->accessor; } elseif ($classAnnotation instanceof ObjectIdentifier) { $metadata->objectIdentifier = $classAnnotation->fields; } } $propertiesMetadata = array(); $propertiesAnnotations = array(); foreach ($class->getProperties() as $property) { $propertiesMetadata[] = new PropertyMetadata($class->getName(), $property->getName()); $propertiesAnnotations[] = $this->reader->getPropertyAnnotations($property); } foreach ($propertiesMetadata as $key => $propertyMetadata) { $canAdd = null; if (empty($propertiesAnnotations[$key])) { continue; } /** @var PropertyMetadata $propertyMetadata */ foreach ($propertiesAnnotations[$key] as $propertyAnnotation) { $canAdd = true; if ($propertyAnnotation instanceof Mergeable) { $propertyMetadata->setType($propertyAnnotation->type); } elseif ($propertyAnnotation instanceof CollectionMergeStrategy) { $propertyMetadata->collectionMergeStrategy = $propertyAnnotation->strategies; } elseif ($propertyAnnotation instanceof IgnoreNullValue) { $propertyMetadata->ignoreNullValue = $propertyAnnotation->activated; } else { $canAdd = false; } } // Only add propertymetadata if it is defined within the mergeannotations. if ($canAdd) { $metadata->addPropertyMetadata($propertyMetadata); } } return $metadata; }
/** * @param LifecycleEventArgs $args */ public function prePersist(LifecycleEventArgs $args) { $entity = $args->getEntity(); $em = $args->getEntityManager(); $meta = $em->getClassMetadata(get_class($entity)); $this->repo = $em->getRepository($meta->getName()); $object = new \ReflectionObject($entity); foreach ($object->getProperties() as $property) { foreach ($this->reader->getPropertyAnnotations($property) as $annotation) { if ($annotation instanceof GeneratorAnnotation) { $property->setAccessible(true); if (!$annotation->override && $property->getValue($entity)) { break; } $string = $this->generateString($property->name, $annotation, $object); $property->setValue($entity, $string); } } } }
/** * @return array|null */ public function getPropertyAnnotations() { if (null === $this->propertyAnnotations) { $this->propertyAnnotations = array(); /** @var \ReflectionProperty $reflectionProperty */ foreach ($this->reflectionProperties as $reflectionProperty) { $this->propertyAnnotations[$reflectionProperty->getName()] = $this->reader->getPropertyAnnotations($reflectionProperty); } } return $this->propertyAnnotations; }
/** * {@inheritDoc} */ public function loadMetadata($class) { // Try get @Object annotation $objectAnnotation = null; $classAnnotations = Reflection::loadClassAnnotations($this->reader, $class); foreach ($classAnnotations as $classAnnotation) { if ($classAnnotation instanceof ObjectAnnotation) { if ($objectAnnotation) { throw new \RuntimeException(sprintf('Many @Normalize\\Object annotations in class "%s".', $class)); } $objectAnnotation = $classAnnotation; } } // Try get @Property annotation from properties $properties = []; $classProperties = Reflection::getClassProperties($class, true); if ($objectAnnotation && $objectAnnotation->allProperties) { foreach ($classProperties as $classProperty) { /** @var PropertyAnnotation $propertyAnnotation */ $propertyAnnotation = $this->reader->getPropertyAnnotation($classProperty, 'FivePercent\\Component\\ModelNormalizer\\Annotation\\Property'); if ($propertyAnnotation) { $properties[$classProperty->getName()] = new PropertyMetadata($propertyAnnotation->fieldName ?: $classProperty->getName(), $propertyAnnotation->groups, $propertyAnnotation->shouldNormalize, $propertyAnnotation->expressionValue, $propertyAnnotation->denormalizerClass); } else { $properties[$classProperty->getName()] = new PropertyMetadata($classProperty->getName(), [], false, null); } } } else { foreach ($classProperties as $classProperty) { $propertyAnnotations = $this->reader->getPropertyAnnotations($classProperty); foreach ($propertyAnnotations as $propertyAnnotation) { if ($propertyAnnotation instanceof PropertyAnnotation) { $properties[$classProperty->getName()] = new PropertyMetadata($propertyAnnotation->fieldName ?: $classProperty->getName(), $propertyAnnotation->groups, $propertyAnnotation->shouldNormalize, $propertyAnnotation->expressionValue, $propertyAnnotation->denormalizerClass); } } } } if (!count($properties) && !$objectAnnotation) { throw new NormalizeAnnotationNotFoundException(sprintf('Not found normalize annotations in class "%s".', $class)); } return new ObjectMetadata($properties); }
/** * {@inheritdoc} */ public function loadMetadataForClass(\ReflectionClass $class) { $metadata = new ClassMetadata($class->getName()); $propertyMetadata = []; foreach ($class->getProperties() as $reflProperty) { $annotations = $this->reader->getPropertyAnnotations($reflProperty); foreach ($annotations as $annotation) { if ($annotation instanceof Annotations\Field) { $propertyMetadata = new PropertyMetadata($class->getName(), $reflProperty->getName(), $annotation->type, $annotation->role, $annotation->group, ['shared' => $annotation->shared, 'form' => $annotation->form, 'view' => $annotation->view, 'storage' => $annotation->storage]); $propertyMetadatas[] = $propertyMetadata; } } } if (empty($propertyMetadatas)) { return; } foreach ($propertyMetadatas as $propertyMetadata) { $metadata->addPropertyMetadata($propertyMetadata); } return $metadata; }
/** * {@inheritdoc} */ public function getPropertyKey(\ReflectionProperty $property) { foreach ($this->reader->getPropertyAnnotations($property) as $annotation) { if ($annotation instanceof Inject) { $value = $annotation->getSingleValue(); if ($value !== null) { return $value; } } } return null; }
function it_can_configure_a_generator(Registry $registry, Reader $reader, LifecycleEventArgs $args, ConfigurableGeneratorInterface $generator) { $annotation = new GeneratorAnnotation([]); $reader->getPropertyAnnotations(Argument::any())->willReturn([$annotation]); $registry->get(Argument::any())->willReturn($generator); $generator->generate()->shouldBeCalled(); $generator->setLength(Argument::any())->shouldBeCalled(); $resolver = new OptionsResolver(); $generator->getDefaultOptions($resolver)->shouldBeCalled(); $generator->setOptions(Argument::any())->shouldBeCalled(); $this->prePersist($args); }
public function loadMetadataForClass(\ReflectionClass $class) { $classMetadata = new ClassMetadata($class->getName()); foreach ($this->reader->getClassAnnotations($class) as $annotation) { if ($annotation instanceof Type) { $classMetadata->setType($annotation->value, $annotation->options); } else { if ($annotation instanceof EventSubscribers) { $classMetadata->setEventSubscribers($annotation->getValues()); } else { if ($annotation instanceof ModelTransformers) { $classMetadata->setModelTransformers($annotation->getValues()); } else { if ($annotation instanceof ViewTransformers) { $classMetadata->setViewTransformers($annotation->getValues()); } } } } } foreach ($class->getMethods() as $reflectionMethod) { foreach ($this->reader->getMethodAnnotations($reflectionMethod) as $annotation) { if ($annotation instanceof EventListener) { $methodMetadata = new MethodMetadata($class->getName(), $reflectionMethod->getName()); $methodMetadata->addEventListener($annotation->event, $annotation->priority); $classMetadata->addMethodMetadata($methodMetadata); } } } foreach ($class->getProperties() as $reflectionProperty) { foreach ($this->reader->getPropertyAnnotations($reflectionProperty) as $annotation) { if ($annotation instanceof Field) { $propertyMetadata = new PropertyMetadata($class->getName(), $reflectionProperty->getName()); $propertyMetadata->setField($annotation->type, $annotation->options); $classMetadata->addPropertyMetadata($propertyMetadata); } } } return $classMetadata; }
/** * {@inheritDoc} */ public function getPropertyAnnotations(\ReflectionProperty $property) { $class = $property->getDeclaringClass(); $cacheKey = $class->getName() . '$' . $property->getName(); if (isset($this->loadedAnnotations[$cacheKey])) { return $this->loadedAnnotations[$cacheKey]; } if (false === ($annots = $this->fetchFromCache($cacheKey, $class))) { $annots = $this->delegate->getPropertyAnnotations($property); $this->saveToCache($cacheKey, $annots); } return $this->loadedAnnotations[$cacheKey] = $annots; }
/** * @param $objectToValidate * @return bool * @throws ObjectFailedValidationException */ public function validate($objectToValidate) { $object = new ReflectionObject($objectToValidate); $errors = []; foreach ($object->getProperties() as $property) { $annotations = $this->annotationReader->getPropertyAnnotations($property); $property->setAccessible(true); foreach ($annotations as $annotation) { if ($annotation instanceof AssertionInterface) { try { $annotation->assert($objectToValidate, $property->getName(), $property->getValue($objectToValidate)); } catch (ValidationException $e) { $errors[$property->getName()][] = $e->getMessage(); } } } } if (count($errors) > 0) { throw new ObjectFailedValidationException($objectToValidate, $errors); } return true; }
/** * Parse JSON API resource metadata * * @param ApiResource $resource * @param \ReflectionClass $class * @return ResourceMetadata */ private function loadResourceMetadata(ApiResource $resource, \ReflectionClass $class) { $metadata = new ResourceMetadata($class->name); $metadata->setName($resource->name); $properties = $class->getProperties(); foreach ($properties as $property) { if ($property->getDeclaringClass()->name !== $class->name) { continue; } foreach ($this->reader->getPropertyAnnotations($property) as $annotation) { if ($annotation instanceof Attribute) { $metadata->addAttribute($this->loadPropertyMetadata($annotation, $property)); } elseif ($annotation instanceof Relationship) { $metadata->addRelationship($this->loadPropertyMetadata($annotation, $property)); } elseif ($annotation instanceof Id) { $metadata->setIdMetadata($this->loadPropertyMetadata($annotation, $property)); } } } $this->loadDiscriminatorMetadata($resource, $metadata); return $metadata; }
/** * Return list of annotations for reflection point * * @param \ReflectionClass|\ReflectionMethod|\ReflectionProperty $refPoint Reflection instance * * @return array list of annotations * @throws \InvalidArgumentException if $refPoint is unsupported */ protected function getAnnotations($refPoint) { switch (true) { case $refPoint instanceof \ReflectionClass: return $this->annotationReader->getClassAnnotations($refPoint); case $refPoint instanceof \ReflectionMethod: return $this->annotationReader->getMethodAnnotations($refPoint); case $refPoint instanceof \ReflectionProperty: return $this->annotationReader->getPropertyAnnotations($refPoint); default: throw new \InvalidArgumentException("Unsupported reflection point " . get_class($refPoint)); } }
/** * @param string $className * * @return NodeEntityMetadata|RelationshipEntityMetadata */ public function create($className) { $reflectionClass = new \ReflectionClass($className); $entityIdMetadata = null; $propertiesMetadata = []; $relationshipsMetadata = []; if (null !== ($annotation = $this->reader->getClassAnnotation($reflectionClass, Node::class))) { $annotationMetadata = $this->nodeAnnotationMetadataFactory->create($className); foreach ($reflectionClass->getProperties() as $reflectionProperty) { $propertyAnnotationMetadata = $this->propertyAnnotationMetadataFactory->create($className, $reflectionProperty->getName()); if (null !== $propertyAnnotationMetadata) { $propertiesMetadata[] = new EntityPropertyMetadata($reflectionProperty->getName(), $reflectionProperty, $propertyAnnotationMetadata); } else { $idA = $this->IdAnnotationMetadataFactory->create($className, $reflectionProperty); if (null !== $idA) { $entityIdMetadata = new EntityIdMetadata($reflectionProperty->getName(), $reflectionProperty, $idA); } } foreach ($this->reader->getPropertyAnnotations($reflectionProperty) as $annot) { if ($annot instanceof Label) { $propertiesMetadata[] = new LabeledPropertyMetadata($reflectionProperty->getName(), $reflectionProperty, $annot); } if ($annot instanceof Relationship) { $isLazy = null !== $this->reader->getPropertyAnnotation($reflectionProperty, Lazy::class); $orderBy = $this->reader->getPropertyAnnotation($reflectionProperty, OrderBy::class); $relationshipsMetadata[] = new RelationshipMetadata($className, $reflectionProperty, $annot, $isLazy, $orderBy); } } } return new NodeEntityMetadata($className, $reflectionClass, $annotationMetadata, $entityIdMetadata, $propertiesMetadata, $relationshipsMetadata); } elseif (null !== ($annotation = $this->reader->getClassAnnotation($reflectionClass, RelationshipEntity::class))) { return $this->relationshipEntityMetadataFactory->create($className); } if (null !== get_parent_class($className)) { return $this->create(get_parent_class($className)); } throw new MappingException(sprintf('The class "%s" is not a valid OGM entity', $className)); }
/** * @param Reader $reader * @param ReflectionProperty $property */ function __construct(Reader $reader, ReflectionProperty $property) { $this->reader = $reader; $this->property = $property; if ($this->isProperty() || $this->isRelation()) { $this->name = $property->getName(); } else { // as far as we know only relation list are collections with names we can 'normalize' $this->name = Reflection::singularizeProperty($property->getName()); } if ($this->isProperty()) { foreach ($this->reader->getPropertyAnnotations($this->property) as $annotation) { if ($annotation instanceof Annotation\Index) { $copy = clone $annotation; $copy->name = $copy->name ?: $this->property->class; $copy->field = $copy->field ?: $this->property->name; $copy->type = $copy->type ?: 'node'; $this->indexes[] = $copy; } } } $property->setAccessible(true); }