public function testGetMetadataReturnsNullIfNoMetadataIsFound() { $driver = $this->getMock('Metadata\\Driver\\DriverInterface'); $driver->expects($this->once())->method('loadMetadataForClass')->will($this->returnValue(null)); $factory = new MetadataFactory($driver); $this->assertNull($factory->getMetadataForClass('stdClass')); }
function it_generates_a_validation(MetadataFactory $metadataFactory) { $classMetadata = $this->getClassMetadata(); $classMetadata->propertyMetadata['prop']->rules = ['required']; $data = $this->getData(); $data['prop']['rules'] = ['required']; $metadataFactory->getMetadataForClass('Indigo\\Fieldset\\Stubs\\Entity')->willReturn($classMetadata); $this->generateValidation('Indigo\\Fieldset\\Stubs\\Entity')->shouldHaveType('Fuel\\Validation\\Validator'); }
/** * @param $classes * @return array */ public function guessRdfClassFiliation($classes) { foreach ($classes as $class) { $metadata = $this->metadataFactory->getMetadataForClass($class); $types = $metadata->getTypes(); if (!empty($types)) { $parentClasses = $metadata->getParentClasses(); $this->addParentClass($types, $parentClasses); } } return $this->rdfFiliation; }
/** * @param LoggerInterface $logger * @param bool $dryRun * * @SuppressWarnings(PHPMD.NPathComplexity) * @SuppressWarnings(PHPMD.CyclomaticComplexity) */ public function doExecute(LoggerInterface $logger, $dryRun = false) { $classNames = $this->getAllConfigurableEntities($logger); foreach ($classNames as $className) { if (!class_exists($className)) { // skip if a class no longer exists continue; } $fieldConfigs = $this->loadFieldConfigs($logger, $className); $fieldsChangedByUser = $this->loadFieldsChangedByUser($logger, $className); /** @var EntityMetadata $metadata */ $metadata = $this->metadataFactory->getMetadataForClass($className); foreach ($fieldConfigs as $fieldName => $fieldConfig) { if (isset($fieldsChangedByUser[$fieldName])) { // skip because the value is changed by an user continue; } if (!isset(self::$allowedTypes[$fieldConfig['type']])) { // skip because this data type should not be available in email templates continue; } if ($metadata && $metadata->configurable && isset($metadata->propertyMetadata[$fieldName])) { /** @var FieldMetadata $fieldMetadata */ $fieldMetadata = $metadata->propertyMetadata[$fieldName]; if (isset($fieldMetadata->defaultValues['email']) && array_key_exists('available_in_template', $fieldMetadata->defaultValues['email'])) { // skip because this field has @ConfigField annotations with email.available_in_template continue; } } $data = $fieldConfig['data']; if (isset($data['email']['available_in_template']) && $data['email']['available_in_template']) { // skip because the value is already TRUE continue; } if (!isset($data['email'])) { $data['email'] = []; } $data['email']['available_in_template'] = true; $query = 'UPDATE oro_entity_config_field SET data = :data WHERE id = :id'; $params = ['data' => $data, 'id' => $fieldConfig['id']]; $types = ['data' => 'array', 'id' => 'integer']; $this->logQuery($logger, $query, $params, $types); if (!$dryRun) { $this->connection->executeUpdate($query, $params, $types); } } } }
/** * @param object $object * @param object|null $entity */ protected function processExclusions($object, $entity) { $class = get_class($object); if (!$entity) { return; } $reflection = new \ReflectionClass($class); /** Backfill data that is ignored or read only from the serializer */ $metadata = $this->metadataFactory->getMetadataForClass($class); foreach ($reflection->getProperties() as $property) { $name = $property->getName(); if (!isset($metadata->propertyMetadata[$name]) || $metadata->propertyMetadata[$name]->readOnly) { $property->setAccessible(true); $property->setValue($object, $property->getValue($entity)); } } $em = $this->doctrine->getManagerForClass($class); /** @var \Doctrine\Common\Persistence\Mapping\ClassMetadata $metadata */ $metadata = $em->getMetadataFactory()->getMetadataFor($class); // Look for relationships, compare against preloaded entity foreach ($metadata->getAssociationNames() as $fieldName) { if ($metadata->isCollectionValuedAssociation($fieldName)) { $property = $reflection->getProperty($fieldName); $property->setAccessible(true); if ($property->getValue($object)) { foreach ($property->getValue($object) as $i => $value) { $v = $property->getValue($entity); $this->processExclusions($value, $v[$i]); } } } } }
/** * @param string $className * * @return ClassMetadata|MergeableClassMetadata|null */ public function getMetadataForClass($className) { $classMetadata = parent::getMetadataForClass($className); if ($classMetadata !== null && $classMetadata instanceof ClassHierarchyMetadata) { return $classMetadata->getOutsideClassMetadata(); } return $classMetadata; }
/** * @param $type * * @return \Metadata\ClassHierarchyMetadata|\Metadata\MergeableClassMetadata|null */ public function getMetadata($type) { $class = TypeMapper::get($type); if ($class) { return $this->metadataFactory->getMetadataForClass($class); } return; }
private function getParentObjectInlining($object, SerializationContext $context) { $metadataStack = $context->getMetadataStack(); $visitingStack = $context->getVisitingStack(); $parentObject = null; if (count($visitingStack) > 0) { $parentObject = $visitingStack[0]; } if ($parentObject === $object && count($visitingStack) > 1) { $parentObject = $visitingStack[1]; // $object is inlined inside $parentObject } if ($metadataStack->count() > 0 && isset($metadataStack[0]->inline) && $metadataStack[0]->inline && $this->serializerMetadataFactory->getMetadataForClass(get_class($parentObject)) === $metadataStack[1]) { return $parentObject; } return null; }
/** * Get translatable metadata * * @param string $className * @return TranslatableMetadata|TranslationMetadata */ public function getTranslatableMetadata($className) { if (array_key_exists($className, $this->cache)) { return $this->cache[$className]; } if ($metadata = $this->metadataFactory->getMetadataForClass($className)) { $metadata->validate(); } $this->cache[$className] = $metadata; return $metadata; }
/** * @param mixed $controller * * @return \BackBee\Rest\Mapping\ActionMetadata */ protected function getControllerActionMetadata($controller) { $controllerClass = get_class($controller[0]); $metadata = $this->metadataFactory->getMetadataForClass($controllerClass); $controllerMetadata = $metadata->getOutsideClassMetadata(); $action_metadatas = null; if (array_key_exists($controller[1], $controllerMetadata->methodMetadata)) { $action_metadatas = $controllerMetadata->methodMetadata[$controller[1]]; } return $action_metadatas; }
/** * Create open graph object */ public function build() { $annotationReader = $this->annotationReader; if (null === $annotationReader) { $annotationReader = new AnnotationReader(); if (null !== $this->cacheDirectory) { $cacheDirectory = sprintf('%s/annotations', $this->cacheDirectory); $this->createDirectory($cacheDirectory); $annotationReader = new CachedReader($annotationReader, new FilesystemCache($cacheDirectory)); } } $metadataDriver = $this->driverFactory->createDriver($this->metadataDirectories, $annotationReader); $metadataFactory = new MetadataFactory($metadataDriver, null, $this->debug); $metadataFactory->setIncludeInterfaces($this->includeInterfaceMetadata); if (null !== $this->cacheDirectory) { $directory = sprintf('%s/metadata', $this->cacheDirectory); $this->createDirectory($directory); $metadataFactory->setCache(new FileCache($directory)); } return new OpenGraphGenerator($metadataFactory); }
/** * Builds validation for a class * * @param string $class * @param Validator $validator */ public function buildValidation($class, Validator $validator) { $classMetadata = $this->metadataFactory->getMetadataForClass($class); foreach ($classMetadata->propertyMetadata as $propertyMetadata) { $validator->addField($propertyMetadata->name, $propertyMetadata->label); foreach ($propertyMetadata->rules as $name => $arguments) { if (is_int($name)) { $name = $arguments; $arguments = []; } $rule = $validator->createRuleInstance($name, [$arguments]); $validator->addRule($propertyMetadata->name, $rule); } } }
/** * @param FilterControllerEvent $event */ public function onKernelController(FilterControllerEvent $event) { list($controller, $method) = $event->getController(); $classMetadata = $this->metadataFactory->getMetadataForClass(get_class($controller)); $methodMetadata = $classMetadata->methodMetadata[$method]; if ($methodMetadata->frame) { $this->frame = $methodMetadata->frame; } elseif ($classMetadata->frame) { $this->frame = $classMetadata->frame; } if ($methodMetadata->options) { $this->options = $methodMetadata->options; } elseif ($classMetadata->options) { $this->options = $classMetadata->options; } }
/** * Accepts an objectpair and going through its properties for calling the visitor on each * comparable property. * * @param object $mergeFrom Sourceobject * @param object $mergeTo Targetobject * * @throws Exception\MergeException */ public function accept($mergeFrom, $mergeTo) { // No object is passed either for mergeFrom or mergeTo. if (!is_object($mergeFrom) || !is_object($mergeTo)) { return; } $class = get_class($mergeFrom); if (!$mergeTo instanceof $class) { throw new MergeException('Not able to merge objects with different types.'); } // If the object is not visited. if (isset($this->visitedObjects[spl_object_hash($mergeFrom)])) { return; } $classMetadata = $this->metadataFactory->getMetadataForClass(get_class($mergeFrom)); $this->walkProperties($mergeFrom, $mergeTo, $classMetadata); }
/** * Search parent frame pathes * @param $parentClass * @param array $parentFrames * @return array */ public function getParentFrames($type) { $parentClasses = $this->filiationBuilder->getParentTypes($type); $parentFrames = array(); if (!$parentClasses || empty($parentClasses)) { return $parentFrames; } foreach ($parentClasses as $parentClass) { $phpClass = TypeMapper::get($parentClass); if ($phpClass) { $metadata = $this->metadataFactory->getMetadataForClass($phpClass); $frame = $metadata->getFrame(); if ($frame) { $parentFrames[] = $metadata->getFrame(); } } } return $parentFrames; }
public function testGetMetadataWithInterfaces() { $driver = $this->getMock('Metadata\\Driver\\DriverInterface'); $driver->expects($this->at(3))->method('loadMetadataForClass')->with($this->equalTo(new \ReflectionClass('Metadata\\Tests\\Fixtures\\ComplexHierarchy\\SubClassA'))); $driver->expects($this->at(2))->method('loadMetadataForClass')->with($this->equalTo(new \ReflectionClass('Metadata\\Tests\\Fixtures\\ComplexHierarchy\\InterfaceB'))); $driver->expects($this->at(1))->method('loadMetadataForClass')->with($this->equalTo(new \ReflectionClass('Metadata\\Tests\\Fixtures\\ComplexHierarchy\\BaseClass'))); $driver->expects($this->at(0))->method('loadMetadataForClass')->with($this->equalTo(new \ReflectionClass('Metadata\\Tests\\Fixtures\\ComplexHierarchy\\InterfaceA'))); $factory = new MetadataFactory($driver); $factory->setIncludeInterfaces(true); $factory->getMetadataForClass('Metadata\\Tests\\Fixtures\\ComplexHierarchy\\SubClassA'); }
public function testGetAllClassNamesThrowsException() { $this->setExpectedException('RuntimeException'); $factory = new MetadataFactory($this->getMock('Metadata\Driver\DriverInterface')); $factory->getAllClassNames(); }
public function build() { $annotationReader = $this->annotationReader; if (null === $annotationReader) { $annotationReader = new AnnotationReader(); if (null !== $this->cacheDir) { $this->createDir($this->cacheDir . '/annotations'); $annotationReader = new FileCacheReader($annotationReader, $this->cacheDir . '/annotations', $this->debug); } } $metadataDriver = $this->driverFactory->createDriver($this->metadataDirs, $annotationReader); $metadataFactory = new MetadataFactory($metadataDriver, null, $this->debug); $metadataFactory->setIncludeInterfaces($this->includeInterfaceMetadata); if (null !== $this->cacheDir) { $this->createDir($this->cacheDir . '/metadata'); $metadataFactory->setCache(new FileCache($this->cacheDir . '/metadata')); } if (!$this->handlersConfigured) { $this->addDefaultHandlers(); } if (!$this->listenersConfigured) { $this->addDefaultListeners(); } if (!$this->visitorsAdded) { $this->addDefaultSerializationVisitors(); $this->addDefaultDeserializationVisitors(); } return new Serializer($metadataFactory, $this->handlerRegistry, $this->objectConstructor ?: new UnserializeObjectConstructor(), $this->serializationVisitors, $this->deserializationVisitors, $this->eventDispatcher); }
/** * @param string $class * @return ClassMetadata|null */ public function getMetadataFor($class) { return $this->metadataFactory->getMetadataForClass($class); }
public function build() { $annotationReader = $this->annotationReader; if (null === $annotationReader) { $annotationReader = new AnnotationReader(); if (null !== $this->cacheDir) { $this->createDir($this->cacheDir . '/annotations'); $annotationReader = new FileCacheReader($annotationReader, $this->cacheDir . '/annotations', $this->debug); } } if (!empty($this->metadataDirs)) { $fileLocator = new FileLocator($this->metadataDirs); $metadataDriver = new DriverChain(array(new YamlDriver($fileLocator), new XmlDriver($fileLocator), new AnnotationDriver($annotationReader))); } else { $metadataDriver = new AnnotationDriver($annotationReader); } $metadataFactory = new MetadataFactory($metadataDriver, null, $this->debug); if (null !== $this->cacheDir) { $this->createDir($this->cacheDir . '/metadata'); $metadataFactory->setCache(new FileCache($this->cacheDir . '/metadata')); } if (!$this->handlersConfigured) { $this->addDefaultHandlers(); } if (!$this->listenersConfigured) { $this->addDefaultListeners(); } if (!$this->visitorsAdded) { $this->addDefaultSerializationVisitors(); $this->addDefaultDeserializationVisitors(); } return new Serializer($metadataFactory, $this->handlerRegistry, $this->objectConstructor ?: new UnserializeObjectConstructor(), $this->serializationVisitors, $this->deserializationVisitors, $this->eventDispatcher); }
private function buildMetadataFactory() { $annotationReader = $this->annotationReader; if (null === $annotationReader) { $annotationReader = new AnnotationReader(); if (null !== $this->cacheDir) { $this->createDir($this->cacheDir . '/annotations'); $annotationReader = new FileCacheReader($annotationReader, $this->cacheDir . '/annotations', $this->debug); } } if (!empty($this->metadataDirs)) { $fileLocator = new FileLocator($this->metadataDirs); $metadataDriver = new DriverChain(array(new YamlDriver($fileLocator), new XmlDriver($fileLocator), new AnnotationDriver($annotationReader))); } else { $metadataDriver = new AnnotationDriver($annotationReader); } $metadataDriver = new ExtensionDriver($metadataDriver, $this->configurationExtensions); $metadataFactory = new MetadataFactory($metadataDriver, null, $this->debug); $metadataFactory->setIncludeInterfaces($this->includeInterfaceMetadata); if (null !== $this->cacheDir) { $this->createDir($this->cacheDir . '/metadata'); $metadataFactory->setCache(new FileCache($this->cacheDir . '/metadata')); } return $metadataFactory; }
/** * Builds and return a Manager instance. * * @return Manager */ public function build() { $annotationReader = $this->annotationReader; if (null === $annotationReader) { $annotationReader = new AnnotationReader(); if (null !== $this->cacheDir) { $this->createDir($this->cacheDir . '/annotations'); $annotationReader = new FileCacheReader($annotationReader, $this->cacheDir . '/annotations', $this->debug); } } $metadataDriver = $this->driverFactory->createDriver($this->metadataDirs, $annotationReader); $metadataFactory = new MetadataFactory($metadataDriver); $metadataFactory->setIncludeInterfaces($this->includeInterfaceMetadata); if (null !== $this->cacheDir) { $this->createDir($this->cacheDir . '/metadata'); $metadataFactory->setCache(new FileCache($this->cacheDir . '/metadata')); } $schemaRegistry = new SchemaRegistry($this->schemaDirs); // TODO registry caching return new Manager($metadataFactory, $schemaRegistry); }
private function getFactory() { $factory = new MetadataFactory(new AnnotationDriver(new AnnotationReader())); $factory->setIncludeInterfaces(true); return $factory; }
/** * @param string $className * * @return EntityMetadata|null */ public function getEntityMetadata($className) { return class_exists($className) ? $this->metadataFactory->getMetadataForClass($className) : null; }
public function testNotFoundMetadataIsNotCachedInDebug() { $driver = $this->getMock('Metadata\\Driver\\DriverInterface'); $driver->expects($this->exactly(2))->method('loadMetadataForClass')->will($this->returnValue(null)); $cachedMetadata = null; $cache = $this->getMock('Metadata\\Cache\\CacheInterface'); $cache->expects($this->any())->method('loadClassMetadataFromCache')->with($this->equalTo(new \ReflectionClass('Metadata\\Tests\\Fixtures\\TestObject')))->will($this->returnValue(null)); $cache->expects($this->never())->method('putClassMetadataInCache'); $factory = new MetadataFactory($driver, 'Metadata\\ClassHierarchyMetadata', true); $factory->setCache($cache); $factory->getMetadataForClass('Metadata\\Tests\\Fixtures\\TestObject'); $this->assertNull($factory->getMetadataForClass('Metadata\\Tests\\Fixtures\\TestObject')); // We use another factory with the same cache, to simulate another request and skip the in memory $factory = new MetadataFactory($driver, 'Metadata\\ClassHierarchyMetadata', true); $factory->setCache($cache); $factory->getMetadataForClass('Metadata\\Tests\\Fixtures\\TestObject'); $this->assertNull($factory->getMetadataForClass('Metadata\\Tests\\Fixtures\\TestObject')); }