/** * * @param array $values * @throws AnnotationException on missing parameters */ public function __construct(array $values = array()) { if (array_key_exists('filepath', $values)) { $this->filepath_property = $values['filepath']; } else { throw AnnotationException::requiredError('filepath', '@FileUpload'); } if (array_key_exists('file', $values)) { $this->file_property = $values['file']; } else { throw AnnotationException::requiredError('fileProperty', '@FileUpload'); } if (array_key_exists('tempFilePath', $values)) { $this->temp_filepath_property = $values['tempFilePath']; } else { throw AnnotationException::requiredError('tempFilePath', '@FileUpload', get_class($this), 'expected'); } if (array_key_exists('filenameMethod', $values)) { $this->filename_method = $values['filenameMethod']; } else { throw AnnotationException::requiredError('filenameMethod', '@FileUpload'); } if (array_key_exists('uploadSubDirectory', $values)) { $this->upload_sub_directory = $values['uploadSubDirectory']; } else { throw AnnotationException::requiredError('uploadSubDirectory', '@FileUpload'); } }
/** * Store options from the Vlabs\Media annotation * * @param array $options * @throws \Doctrine\Common\Annotations\AnnotationException */ public function __construct($options) { if (isset($options['identifier'])) { $this->identifier = $options['identifier']; } else { $e = new AnnotationException(); throw $e->requiredError('identifier', 'Vlabs\\Media', 'entity', 'configuration entity identifier'); } if (isset($options['upload_dir'])) { $this->uploadDir = $options['upload_dir']; } else { $e = new AnnotationException(); throw $e->requiredError('upload_dir', 'Vlabs\\Media', 'entity', 'configuration media upload directory'); } }
/** * @param \Doctrine\ORM\Event\LoadClassMetadataEventArgs $eventArgs * @throws AnnotationException */ public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs) { $reader = new AnnotationReader(); $meta = $eventArgs->getClassMetadata(); foreach ($meta->getReflectionClass()->getProperties() as $property) { if ($meta->isMappedSuperclass && !$property->isPrivate() || $meta->isInheritedField($property->name) || isset($meta->associationMappings[$property->name]['inherited'])) { continue; } if ($annotation = $reader->getPropertyAnnotation($property, 'Leapt\\CoreBundle\\Doctrine\\Mapping\\File')) { $property->setAccessible(true); $field = $property->getName(); if (null === $annotation->mappedBy) { throw AnnotationException::requiredError('mappedBy', 'LeaptCore\\File', $meta->getReflectionClass()->getName(), 'another class property to map onto'); } if (null === $annotation->path && null === $annotation->pathCallback) { throw AnnotationException::syntaxError(sprintf('Annotation @%s declared on %s expects "path" or "pathCallback". One of them should not be null.', 'LeaptCore\\File', $meta->getReflectionClass()->getName())); } if (!$meta->hasField($annotation->mappedBy)) { throw AnnotationException::syntaxError(sprintf('The entity "%s" has no field named "%s", but it is documented in the annotation @%s', $meta->getReflectionClass()->getName(), $annotation->mappedBy, 'LeaptCore\\File')); } $this->config[$meta->getName()]['fields'][$field] = array('property' => $property, 'path' => $annotation->path, 'mappedBy' => $annotation->mappedBy, 'filename' => $annotation->filename, 'meta' => $meta, 'nameCallback' => $annotation->nameCallback, 'pathCallback' => $annotation->pathCallback); } } }
/** * Annotation ::= "@" AnnotationName ["(" [Values] ")"] * AnnotationName ::= QualifiedName | SimpleName * QualifiedName ::= NameSpacePart "\" {NameSpacePart "\"}* SimpleName * NameSpacePart ::= identifier | null | false | true * SimpleName ::= identifier | null | false | true * * @throws AnnotationException * @return mixed False if it is not a valid annotation. */ private function Annotation() { $this->match(DocLexer::T_AT); // check if we have an annotation $name = $this->Identifier(); // only process names which are not fully qualified, yet // fully qualified names must start with a \ $originalName = $name; if ('\\' !== $name[0]) { $alias = false === ($pos = strpos($name, '\\')) ? $name : substr($name, 0, $pos); $found = false; if ($this->namespaces) { foreach ($this->namespaces as $namespace) { if ($this->classExists($namespace . '\\' . $name)) { $name = $namespace . '\\' . $name; $found = true; break; } } } elseif (isset($this->imports[$loweredAlias = strtolower($alias)])) { if (false !== $pos) { $name = $this->imports[$loweredAlias] . substr($name, $pos); } else { $name = $this->imports[$loweredAlias]; } $found = true; } elseif (isset($this->imports['__NAMESPACE__']) && $this->classExists($this->imports['__NAMESPACE__'] . '\\' . $name)) { $name = $this->imports['__NAMESPACE__'] . '\\' . $name; $found = true; } elseif ($this->classExists($name)) { $found = true; } if (!$found) { if ($this->ignoreNotImportedAnnotations || isset($this->ignoredAnnotationNames[$name])) { return false; } throw AnnotationException::semanticalError(sprintf('The annotation "@%s" in %s was never imported. Did you maybe forget to add a "use" statement for this annotation?', $name, $this->context)); } } if (!$this->classExists($name)) { throw AnnotationException::semanticalError(sprintf('The annotation "@%s" in %s does not exist, or could not be auto-loaded.', $name, $this->context)); } // at this point, $name contains the fully qualified class name of the // annotation, and it is also guaranteed that this class exists, and // that it is loaded // collects the metadata annotation only if there is not yet if (!isset(self::$annotationMetadata[$name])) { $this->collectAnnotationMetadata($name); } // verify that the class is really meant to be an annotation and not just any ordinary class if (self::$annotationMetadata[$name]['is_annotation'] === false) { if (isset($this->ignoredAnnotationNames[$originalName])) { return false; } throw AnnotationException::semanticalError(sprintf('The class "%s" is not annotated with @Annotation. Are you sure this class can be used as annotation? If so, then you need to add @Annotation to the _class_ doc comment of "%s". If it is indeed no annotation, then you need to add @IgnoreAnnotation("%s") to the _class_ doc comment of %s.', $name, $name, $originalName, $this->context)); } //if target is nested annotation $target = $this->isNestedAnnotation ? Target::TARGET_ANNOTATION : $this->target; // Next will be nested $this->isNestedAnnotation = true; //if annotation does not support current target if (0 === (self::$annotationMetadata[$name]['targets'] & $target) && $target) { throw AnnotationException::semanticalError(sprintf('Annotation @%s is not allowed to be declared on %s. You may only use this annotation on these code elements: %s.', $originalName, $this->context, self::$annotationMetadata[$name]['targets_literal'])); } $values = array(); if ($this->lexer->isNextToken(DocLexer::T_OPEN_PARENTHESIS)) { $this->match(DocLexer::T_OPEN_PARENTHESIS); if (!$this->lexer->isNextToken(DocLexer::T_CLOSE_PARENTHESIS)) { $values = $this->Values(); } $this->match(DocLexer::T_CLOSE_PARENTHESIS); } // checks all declared attributes foreach (self::$annotationMetadata[$name]['attribute_types'] as $property => $type) { if ($property === self::$annotationMetadata[$name]['default_property'] && !isset($values[$property]) && isset($values['value'])) { $property = 'value'; } // handle a not given attribute or null value if (!isset($values[$property])) { if ($type['required']) { throw AnnotationException::requiredError($property, $originalName, $this->context, 'a(n) ' . $type['value']); } continue; } if ($type['type'] === 'array') { // handle the case of a single value if (!is_array($values[$property])) { $values[$property] = array($values[$property]); } // checks if the attribute has array type declaration, such as "array<string>" if (isset($type['array_type'])) { foreach ($values[$property] as $item) { if (gettype($item) !== $type['array_type'] && !$item instanceof $type['array_type']) { throw AnnotationException::typeError($property, $originalName, $this->context, 'either a(n) ' . $type['array_type'] . ', or an array of ' . $type['array_type'] . 's', $item); } } } } elseif (gettype($values[$property]) !== $type['type'] && !$values[$property] instanceof $type['type']) { throw AnnotationException::typeError($property, $originalName, $this->context, 'a(n) ' . $type['value'], $values[$property]); } } // check if the annotation expects values via the constructor, // or directly injected into public properties if (self::$annotationMetadata[$name]['has_constructor'] === true) { return new $name($values); } $instance = new $name(); foreach ($values as $property => $value) { if (!isset(self::$annotationMetadata[$name]['properties'][$property])) { if ('value' !== $property) { throw AnnotationException::creationError(sprintf('The annotation @%s declared on %s does not have a property named "%s". Available properties: %s', $originalName, $this->context, $property, implode(', ', self::$annotationMetadata[$name]['properties']))); } // handle the case if the property has no annotations if (!($property = self::$annotationMetadata[$name]['default_property'])) { throw AnnotationException::creationError(sprintf('The annotation @%s declared on %s does not accept any values, but got %s.', $originalName, $this->context, json_encode($values))); } } $instance->{$property} = $value; } return $instance; }
/** * Gets the Lucene index to the related object * * @param object $object * * @return ZendSearch\Lucene\SearchIndexInterface */ private function getIndexForObject($object) { $reflClass = new ReflectionClass($object); $annotation = $this->reader->getClassAnnotation($reflClass, '\\Keratine\\Lucene\\Mapping\\Annotation\\Indexable'); if (!$annotation) { // throw new \Exception(sprintf('%s must define annotation @%s', get_class($object), '\Keratine\Lucene\Mapping\Annotation\Indexable')); return; } if (empty($annotation->index)) { AnnotationException::requiredError('index', '\\Keratine\\Lucene\\Mapping\\Annotation\\Indexable', $object, 'string'); } if (false === isset($this->indices[$annotation->index])) { throw new \Exception(sprintf('Unknown index "%s".', $annotation->index)); } if (false === $this->indices[$annotation->index] instanceof SearchIndexInterface) { throw new \Exception(sprintf('Index "%s" must be an instance of "ZendSearch\\Lucene\\SearchIndexInterface". "%s" given.', $annotation->index, is_object($this->indices[$annotation->index]) ? get_class($this->indices[$annotation->index]) : $this->indices[$annotation->index])); } return $this->indices[$annotation->index]; }
/** * Load receiver properties and NotBlank constraints from ReflectionClass. * * @param \ReflectionClass $class * * @throws AnnotationException * * @return array */ protected function loadReceiverProperties(\ReflectionClass $class) { $receiverPropertiesTypes = []; $properties = $class->getProperties(); //Store receiver properties foreach ($properties as $property) { $annotations = $this->reader->getPropertyAnnotations($property); foreach ($annotations as $key => $annotationObj) { if ($annotationObj instanceof ReceiverPropertyAnnotation && !in_array($class, $receiverPropertiesTypes)) { if (!$annotations[$key]->getTypes()) { $message = $class->name . ':$' . $property->name . '" field'; throw AnnotationException::requiredError('type', 'ReceiverProperty annotation', $message, 'array or string'); } foreach ($annotations[$key]->getTypes() as $type) { $receiverProperty = new ReceiverProperty(); $receiverProperty->setFieldName($property->name); $receiverPropertiesTypes[$type][] = $receiverProperty; } } } } //Set receiver properties as required if necessary foreach ($receiverPropertiesTypes as $type => $receiverProperties) { /* @var ReceiverProperty[] $receiverProperties */ foreach ($receiverProperties as $receiverProperty) { $receiverPropertyName = $receiverProperty->getFieldName(); $refProperty = $class->getProperty($receiverPropertyName); $annotations = $this->reader->getPropertyAnnotations($refProperty); foreach ($annotations as $key => $annotationObj) { if ($annotationObj instanceof Column && $annotationObj->nullable === false) { throw new Exception(sprintf('Property "%s" in class "%s" has a @ReceiverProperty annotation and by consequence must have "nullable=true" for ORM\\Column annotation', $refProperty->name, $refProperty->class)); } elseif ($annotationObj instanceof NotBlank) { throw new Exception(sprintf('Property "%s" in class "%s" has a @ReceiverProperty annotation and by consequence can not use NotBlank annotation', $refProperty->name, $refProperty->class)); } elseif ($annotationObj instanceof NotNull) { throw new Exception(sprintf('Property "%s" in class "%s" has a @ReceiverProperty annotation and by consequence can not use NotNull annotation', $refProperty->name, $refProperty->class)); } elseif ($annotationObj instanceof ReceiverPropertyAnnotation && $annotationObj->isRequired()) { $receiverProperty->setRequired(true); } } } } return $receiverPropertiesTypes; }
private function loadReceiverProperties() { $receiverProperties = array(); //Add widgetItems to widgets $widgetItems = $this->widgetItemChain->getWidgetItems(); $widgets = array_merge($this->widgets, $widgetItems); foreach ($widgets as $widget) { $class = new \ReflectionClass($widget['class']); $properties = $class->getProperties(); foreach ($properties as $property) { $annotations = $this->reader->getPropertyAnnotations($property); foreach ($annotations as $key => $annotationObj) { if ($annotationObj instanceof ReceiverProperty && !in_array($class, $receiverProperties)) { if (!$annotations[$key]->getTypes()) { $message = $class->name . ':$' . $property->name . '" field'; throw AnnotationException::requiredError('type', 'BusinessProperty annotation', $message, 'array or string'); } foreach ($annotations[$key]->getTypes() as $type) { $receiverProperties[$widget['name']][$type][$property->name] = $property->name; } } } } } return $receiverProperties; }