/** * Get's the possible key used in the typemap for the type * * @param TypeInterface $type * @return string */ protected function getTypeMapKey(TypeInterface $type) { list($prefix, $shortname) = explode(':', $type->getRdfType()); $ns = $type->getVocabularies(); $ns = $ns[$prefix]; return $ns . $shortname; }
public function prepareObject(TypeInterface $controller, $parent = null) { $config = $controller->getConfig(); $class = $config['storage']; $object = new $class(); if (null !== $parent) { $baseclass = \midcom_helper_reflector::resolve_baseclass($class); $reflector = new \midgard_reflection_property($baseclass); $up_property = \midgard_object_class::get_property_up($baseclass); if (!empty($up_property)) { $target_property = $reflector->get_link_target($up_property); $target_class = $reflector->get_link_name($up_property); if (\midcom_helper_reflector::resolve_baseclass($parent) === $target_class) { $object->{$up_property} = $parent->{$target_property}; } } $parent_property = \midgard_object_class::get_property_parent($baseclass); if (!empty($parent_property)) { $target_property = $reflector->get_link_target($parent_property); $target_class = $reflector->get_link_name($parent_property); if (\midcom_helper_reflector::resolve_baseclass($parent) === $target_class) { $object->{$parent_property} = $parent->{$target_property}; } else { $object->{$parent_property} = $parent->{$parent_property}; } } } return $object; }
/** * {@inheritDoc} * * Create the object if a class is defined in the typeMap. This class * can not know how to set the parent, so if you ever create collection * entries, your extending class should handle the parent - it can still * call this method to create the basic object, just omit the parent * parameter and then set the parent on the returned value. For an example, * see DoctrinePhpcrOdmMapper. * * Just overwrite if you use a different concept. */ public function prepareObject(TypeInterface $type, $parent = null) { if ($parent !== null) { throw new \Exception('Parent is not null, please extend this method to configure the parent'); } list($prefix, $shortname) = explode(':', $type->getRdfType()); $ns = $type->getVocabularies(); $ns = $ns[$prefix]; $name = $ns.$shortname; if (isset($this->typeMap[$name])) { $class = $this->typeMap[$name]; return new $class; } throw new \Exception('No information on ' . $name); }
public function test_render() { $collection = new Collection('test', $this->mockTypeFactory, array('is_child' => true)); $collection->addTypeName('test'); $collection->setRev('test:rev'); $parent = array('id' => 'parent_id', 'children' => array(array('id' => 'child1'))); $this->parentController->test = $collection; $entity = $this->parentController->createWithObject($parent); $this->assertEquals("<div xmlns:test=\"http://test.org/\" about=\"parent_id\"><div rev=\"test:rev\"><div about=\"child1\"></div>\n</div>\n</div>\n", $entity->render()); }
/** * Expand a property name to use full namespace instead of short name, * as used in reference fields. Additionally jsonld-encodes that link. * * @param string $name the name to expand, including namespace * @param TypeInterface $type the type context for the vocabulary * * @return string the jsonld-encoded expanded name * * @throws \RuntimeException if the prefix is not in the vocabulary of * $type */ private function _expandPropertyName($name, TypeInterface $type) { $parts = explode(":", $name); $vocabularies = $type->getVocabularies(); if (!isset($vocabularies[$parts[0]])) { throw new \RuntimeException('Undefined namespace prefix \'' . $parts[0] . "' in '{$name}'"); } return $this->jsonldEncode($vocabularies[$parts[0]] . $parts[1]); }
/** * Build the attributes from the property|rel field and any custom attributes * * @param mixed $child the child element to parse * @param \ArrayAccess $childData the child to read field from * @param string $field the field to be read, property for properties, rel for collections * @param string $identifier to be used in case there is no property field in $child * @param TypeInterface $parentType the parent object, i.e. for namespaces * @param boolean $add_default_vocabulary flag to tell whether to add vocabulary for * the default namespace. * * @return array properties */ protected function parseChild($child, $childData, $identifier, TypeInterface $parentType, &$add_default_vocabulary) { if ($child instanceof PropertyDefinitionInterface) { /** @var $child PropertyDefinitionInterface */ $child->setProperty($this->buildInformation($childData, $identifier, 'property', $add_default_vocabulary)); } elseif ($child instanceof CollectionDefinitionInterface) { /** @var $child CollectionDefinitionInterface */ $child->setRel($this->buildInformation($childData, $identifier, 'rel', $add_default_vocabulary)); $child->setRev($this->buildInformation($childData, $identifier, 'rev', $add_default_vocabulary)); if (isset($childData['childtypes'])) { foreach ($childData['childtypes'] as $type) { $expanded = NamespaceHelper::expandNamespace($type, $parentType->getVocabularies()); $child->addTypeName($expanded); } } } if ($child instanceof NodeInterface) { $this->parseNodeInfo($child, $childData); } }