PHP PathHelper::absolutizePath方法代码示例

 /**
  * {@inheritdoc}
  */
 public function mapPathToId($path, $rootPath = null)
 {
     // The path is being the id
     $id = PathHelper::absolutizePath($path, '/');
     if (is_string($rootPath) && 0 !== strpos($id, $rootPath)) {
         throw new \OutOfBoundsException(sprintf('The path "%s" is out of the root path "%s" were the file system is located.', $path, $rootPath));
     }
     return $id;
 }

 /**
  * Remove a node or a property.
  *
  * If this is a node, sets all cached items below this node to deleted as
  * well.
  *
  * If property is set, the path denotes the node containing the property,
  * otherwise the node at path is removed.
  *
  * @param string $absPath The absolute path to the node to be removed,
  *      including the node name.
  * @param PropertyInterface $property optional, property instance to delete from the
  *      given node path. If set, absPath is the path to the node containing
  *      this property.
  *
  * @throws RepositoryException If node cannot be found at given path
  *
  * @see Item::remove()
  */
 public function removeItem($absPath, PropertyInterface $property = null)
 {
     if (!$this->transport instanceof WritingInterface) {
         throw new UnsupportedRepositoryOperationException('Transport does not support writing');
     }
     // the object is always cached as invocation flow goes through Item::remove() without exception
     if (!isset($this->objectsByPath['Node'][$absPath])) {
         throw new RepositoryException("Internal error: Item not found in local cache at {$absPath}");
     }
     if ($property) {
         $absPath = PathHelper::absolutizePath($property->getName(), $absPath);
         $this->performPropertyRemove($absPath, $property);
     } else {
         $node = $this->objectsByPath['Node'][$absPath];
         $this->performNodeRemove($absPath, $node);
         $this->cascadeDelete($absPath);
     }
 }

 private function absolutizePath($path, $context = null)
 {
     if (null !== $context) {
         $context = $this->defaultRootPath . DIRECTORY_SEPARATOR . $context;
     }
     if (isset($path[0]) && '/' === $path[0]) {
         $path = $context ?: $this->rootPath;
     }
     return (string) PathHelper::absolutizePath($path, $context ?: $this->rootPath);
 }

 /**
  * {@inheritDoc}
  *
  * @api
  */
 public function getNodes($nameFilter = null, $typeFilter = null)
 {
     $this->checkState();
     $names = self::filterNames($nameFilter, $this->nodes);
     $result = array();
     if (!empty($names)) {
         $paths = array();
         foreach ($names as $name) {
             $paths[] = PathHelper::absolutizePath($name, $this->path);
         }
         $nodes = $this->objectManager->getNodesByPath($paths, 'Node', $typeFilter);
         // OPTIMIZE if we lazy-load in ObjectManager we should not do this loop
         foreach ($nodes as $node) {
             $result[$node->getName()] = $node;
         }
     }
     return new ArrayIterator($result);
 }

 /**
  * {@inheritDoc}
  *
  * @throws InvalidItemStateException
  *
  * @api
  */
 public function getProperty()
 {
     $this->checkState();
     $values = $this->isMultiple() ? $this->value : array($this->value);
     $results = array();
     switch ($this->type) {
         case PropertyType::PATH:
         case PropertyType::STRING:
         case PropertyType::NAME:
             foreach ($values as $value) {
                 $results[] = $this->objectManager->getPropertyByPath(PathHelper::absolutizePath($value, $this->parentPath));
             }
             break;
         default:
             throw new ValueFormatException('Property is not a PATH (or convertible to PATH)');
     }
     return $this->isMultiple() ? $results : $results[0];
 }

 /**
  * @param string  $name    Name of the menu to load
  * @param array   $options
  * @param boolean $throw   Whether to throw an exception if the menu is not
  *                         found or no valid menu. Returns false if $throw is false and there
  *                         is no menu at $name.
  *
  * @return object|boolean The menu root found with $name or false if $throw
  *                        is false and the menu was not found.
  *
  * @throws \InvalidArgumentException Only if $throw is true throws this
  *                                   exception if the name is empty or no menu found.
  */
 protected function find($name, array $options, $throw)
 {
     if (empty($name)) {
         if ($throw) {
             throw new \InvalidArgumentException('The menu name may not be empty');
         }
         return false;
     }
     $path = PathHelper::absolutizePath($name, $this->getMenuRoot());
     $dm = $this->getObjectManager();
     $session = $dm->getPhpcrSession();
     if ($this->getPrefetch() > 0) {
         try {
             if ($session instanceof Session && 0 < $session->getSessionOption(Session::OPTION_FETCH_DEPTH) && 0 === strncmp($path, $this->getMenuRoot(), strlen($this->getMenuRoot()))) {
                 // we have jackalope with a fetch depth. prefetch all menu
                 // nodes of all menues.
                 $session->getNode($this->getMenuRoot(), $this->getPrefetch() + 1);
             } else {
                 $session->getNode($path, $this->getPrefetch());
             }
         } catch (PathNotFoundException $e) {
             if ($throw) {
                 throw new \InvalidArgumentException(sprintf('The menu root "%s" does not exist.', $this->getMenuRoot()));
             }
             return false;
         }
     }
     $menu = $dm->find(null, $path);
     if (null === $menu) {
         if ($throw) {
             throw new \InvalidArgumentException(sprintf('The menu "%s" is not defined.', $name));
         }
         return false;
     }
     if (!$menu instanceof NodeInterface) {
         if ($throw) {
             throw new \InvalidArgumentException("Menu at '{$name}' is not a valid menu node");
         }
         return false;
     }
     return $menu;
 }

 /**
  * Get subject
  *
  * Overridden to allow a broader set of valid characters in the ID, and
  * if the ID is not a UUID, to call absolutizePath on the ID.
  *
  * @return mixed
  */
 public function getSubject()
 {
     if ($this->subject === null && $this->request) {
         $id = $this->request->get($this->getIdParameter());
         if (!preg_match('#^[0-9A-Za-z/\\-_]+$#', $id)) {
             $this->subject = false;
         } else {
             if (!UUIDHelper::isUUID($id)) {
                 $id = PathHelper::absolutizePath($id, '/');
             }
             $this->subject = $this->getModelManager()->find($this->getClass(), $id);
         }
     }
     return $this->subject;
 }

 protected function mapUrlSafePathToId($path)
 {
     // The path is being the id
     return PathHelper::absolutizePath($path, '/');
 }

 /**
  * @dataProvider dataproviderAbsolutizePathInvalid
  */
 public function testAbsolutizePathInvalidNoThrow($inputPath, $context, $target)
 {
     $this->assertFalse(PathHelper::absolutizePath($inputPath, $context, $target, false));
 }

 /**
  * Gather the parent and all child mappings so they can be fetched in one
  * go.
  *
  * @param ClassMetadata $class  The metadata about the document to know what to do.
  * @param NodeInterface $node   The node to prefetch parent and childs for.
  * @param string|null   $locale The locale to also prefetch the translation
  *      child if applicable.
  *
  * @return array List of absolute paths to nodes that should be prefetched.
  */
 public function collectPrefetchHierarchy(ClassMetadata $class, NodeInterface $node, $locale = null)
 {
     $prefetch = array();
     if ($class->parentMapping && $node->getDepth() > 0) {
         $prefetch[] = PathHelper::getParentPath($node->getPath());
     }
     foreach ($class->childMappings as $fieldName) {
         $childName = $class->mappings[$fieldName]['nodeName'];
         $prefetch[] = PathHelper::absolutizePath($childName, $node->getPath());
     }
     if ($locale && count($prefetch) && 'child' === $class->translator) {
         $prefetch[] = $node->getPath() . '/phpcr_locale:' . $locale;
     }
     return $prefetch;
 }

 /**
  * Validation if all the data is correct before writing it into the database.
  *
  * @param PropertyInterface $property
  *
  * @throws RepositoryException
  * @throws ValueFormatException
  */
 private function assertValidProperty(PropertyInterface $property)
 {
     $type = $property->getType();
     switch ($type) {
         case PropertyType::NAME:
             $values = $property->getValue();
             if (!$property->isMultiple()) {
                 $values = array($values);
             }
             foreach ($values as $value) {
                 $pos = strpos($value, ':');
                 if (false !== $pos) {
                     $prefix = substr($value, 0, $pos);
                     if (!isset($this->namespaces[$prefix])) {
                         throw new ValueFormatException(sprintf('Invalid value for NAME property type at "%s", the namespace prefix "%s" does not exist.");', $property->getPath(), $prefix));
                     }
                 }
             }
             break;
         case PropertyType::PATH:
             $values = $property->getValue();
             if (!$property->isMultiple()) {
                 $values = array($values);
             }
             foreach ($values as $value) {
                 try {
                     // making the path absolute also validates the result to be a valid path
                     PathHelper::absolutizePath($value, $property->getPath());
                 } catch (RepositoryException $e) {
                     throw new ValueFormatException(sprintf('Value "%s" for PATH property at "%s" is invalid', $value, $property->getPath()), 0, $e);
                 }
             }
             break;
         case PropertyType::URI:
             $values = $property->getValue();
             if (!$property->isMultiple()) {
                 $values = array($values);
             }
             foreach ($values as $value) {
                 if (!preg_match(self::VALIDATE_URI_RFC3986, $value)) {
                     throw new ValueFormatException(sprintf('Invalid value "%s" for URI property at "%s". Value has to comply with RFC 3986.', $value, $property->getPath()));
                 }
             }
             break;
         case PropertyType::DECIMAL:
         case PropertyType::STRING:
             $values = (array) $property->getValue();
             foreach ($values as $value) {
                 if (0 !== preg_match(self::VALIDATE_STRING, $value)) {
                     throw new ValueFormatException(sprintf('Invalid character detected in value %s for STRING property at "%s".', json_encode($value), $property->getPath()));
                 }
             }
             break;
     }
 }