PHP Path::isBasePath方法代码示例

 protected static function configureDir(Event $event, $name, $defaultInSkeleton, $prefix = '', $chmod = true)
 {
     $default = static::getOption($event, $name . '-dir', $defaultInSkeleton);
     $validator = function ($value) use($prefix, $name) {
         if ($prefix) {
             $basePath = Path::makeAbsolute($prefix, getcwd());
             $path = Path::makeAbsolute($value, $basePath);
             if (!Path::isBasePath($basePath, $path)) {
                 throw new \RuntimeException("The {$name} directory must be inside the {$prefix} directory.");
             }
         }
         return Path::canonicalize($value);
     };
     $default = $validator($default);
     $relative = $prefix ? '<comment>' . $prefix . '</comment>' : 'project root';
     $question = sprintf('<info>Where do you want your <comment>%s</comment> directory? (relative to %s) [default: <comment>%s</comment>] </info>', $name, $relative, $default);
     $dir = $event->getIO()->askAndValidate($question, $validator, null, $default);
     $fs = new Filesystem();
     $origin = $prefix . $defaultInSkeleton;
     $target = $prefix . $dir;
     $dirMode = static::configureDirMode($event);
     if ($dir !== $defaultInSkeleton) {
         $event->getIO()->writeError(sprintf('Moving <info>%s</info> directory from <info>%s</info> to <info>%s</info>', $name, $origin, $target));
         $fs->mkdir(dirname($target));
         // ensure parent directory exists
         $fs->rename($origin, $target);
     }
     if ($chmod) {
         $it = (new Finder())->directories()->in($target)->append([$target]);
         $fs->chmod($it, $dirMode);
     }
     return $target;
 }

 /**
  * Splits a path into mount point and path.
  *
  * @param string $path The path to split.
  *
  * @return array An array with the mount point and the path. If no mount
  *               point was found, both are `null`.
  */
 private function splitPath($path)
 {
     Assert::stringNotEmpty($path, 'The path must be a non-empty string. Got: %s');
     Assert::startsWith($path, '/', 'The path %s is not absolute.');
     $path = Path::canonicalize($path);
     foreach ($this->repos as $mountPoint => $_) {
         if (Path::isBasePath($mountPoint, $path)) {
             // Special case "/": return the complete path
             if ('/' === $mountPoint) {
                 return array($mountPoint, $path);
             }
             return array($mountPoint, substr($path, strlen($mountPoint)));
         }
     }
     return array(null, null);
 }

 /**
  * @expectedException \InvalidArgumentException
  * @expectedExceptionMessage The path must be a string. Got: array
  */
 public function testIsBasePathFailsIfInvalidPath()
 {
     Path::isBasePath('/base/path', array());
 }

 /**
  * @param PackageConflict[] $packageConflicts
  */
 private function deduplicatePackageConflicts(array &$packageConflicts)
 {
     $indicesByPath = array();
     $indicesToRemove = array();
     foreach ($packageConflicts as $index => $packageConflict) {
         $indicesByPath[$packageConflict->getConflictingToken()] = $index;
     }
     foreach ($indicesByPath as $repositoryPath => $index) {
         foreach ($indicesByPath as $otherPath => $otherIndex) {
             if ($otherPath !== $repositoryPath && Path::isBasePath($otherPath, $repositoryPath)) {
                 $indicesToRemove[$index] = true;
             }
         }
     }
     foreach ($indicesToRemove as $index => $true) {
         unset($packageConflicts[$index]);
     }
     // Reorganize indices
     $packageConflicts = array_values($packageConflicts);
 }

 /**
  * Adds a conflict to the mapping.
  *
  * A mapping can refer to at most one conflict per conflicting repository
  * path. If the same conflict is added twice, the second addition is
  * ignored. If a different conflict is added for an existing repository
  * path, the previous conflict is removed before adding the new conflict
  * for the repository path.
  *
  * The repository path of the conflict must either be the repository path
  * of the mapping or any path within. If a conflict with a different path
  * is added, an exception is thrown.
  *
  * The method {@link load()} needs to be called before calling this method,
  * otherwise an exception is thrown.
  *
  * @param PathConflict $conflict The conflict to be added.
  *
  * @throws NotLoadedException       If the mapping is not loaded.
  * @throws InvalidArgumentException If the path of the conflict is not
  *                                  within the repository path of the
  *                                  mapping.
  */
 public function addConflict(PathConflict $conflict)
 {
     if (null === $this->state) {
         throw new NotLoadedException('The mapping is not loaded.');
     }
     if (!Path::isBasePath($this->repositoryPath, $conflict->getRepositoryPath())) {
         throw new InvalidArgumentException(sprintf('The conflicting path %s is not within the path %s of the ' . 'mapping.', $conflict->getRepositoryPath(), $this->repositoryPath));
     }
     $repositoryPath = $conflict->getRepositoryPath();
     $previousConflict = isset($this->conflicts[$repositoryPath]) ? $this->conflicts[$repositoryPath] : null;
     if ($previousConflict === $conflict) {
         return;
     }
     if ($previousConflict) {
         $previousConflict->removeMapping($this);
     }
     $this->conflicts[$repositoryPath] = $conflict;
     $conflict->addMapping($this);
     $this->refreshState();
 }

 /**
  * @param string          $repositoryPath
  * @param PathMapping[][] $uncheckedMappings
  * @param string[][]      $filesystemPaths
  * @param string[][]      $filesystemPaths
  */
 private function collectEnabledFilesystemPaths($repositoryPath, array &$uncheckedMappings, array &$filesystemPaths = null, array &$processedPaths = null)
 {
     if (null === $filesystemPaths) {
         $filesystemPaths = array();
         $processedPaths = array();
     }
     // We had this one before
     if (isset($processedPaths[$repositoryPath])) {
         return;
     }
     $processedPaths[$repositoryPath] = true;
     foreach ($uncheckedMappings as $mappedPath => $mappingsByPackage) {
         // Check mappings for the passed repository path or any of its
         // nested paths
         if ($repositoryPath !== $mappedPath && !Path::isBasePath($repositoryPath, $mappedPath)) {
             continue;
         }
         foreach ($mappingsByPackage as $packageName => $mapping) {
             // Don't check the mapping again for this repository path
             unset($uncheckedMappings[$mappedPath][$packageName]);
             // The path of the mapping is not necessarily the current repository
             // path. The paths are different when checking the nested paths of
             // a mapping.
             $mappingPath = $mapping->getRepositoryPath();
             // We added the mapping before or it is not enabled
             if (isset($filesystemPaths[$packageName][$mappingPath]) || !$mapping->isEnabled()) {
                 continue;
             }
             if (!isset($filesystemPaths[$packageName])) {
                 $filesystemPaths[$packageName] = array();
             }
             $filesystemPaths[$packageName][$mappingPath] = $mapping->getFilesystemPaths();
             // Check all nested paths of the mapping for other mappings that
             // map to the same paths
             foreach ($mapping->listRepositoryPaths() as $nestedRepositoryPath) {
                 // Don't repeat the call for the current path
                 if ($nestedRepositoryPath !== $mappedPath) {
                     $this->collectEnabledFilesystemPaths($nestedRepositoryPath, $uncheckedMappings, $filesystemPaths, $processedPaths);
                 }
             }
         }
     }
 }

 /**
  * @param string          $repositoryPath
  * @param PathMapping[][] $inMappings
  * @param PathMapping[][] $outMappings
  * @param bool[]          $processedPaths
  */
 private function filterEnabledMappings($repositoryPath, array &$inMappings, array &$outMappings, array &$processedPaths = array())
 {
     $repositoryPaths = array();
     $processedPaths[$repositoryPath] = true;
     foreach ($inMappings as $mappingPath => $mappingsByPackage) {
         foreach ($mappingsByPackage as $packageName => $mapping) {
             if (!$mapping->isEnabled()) {
                 continue;
             }
             $nestedMappingPaths = $mapping->listRepositoryPaths();
             // Check that the mapping actually contains the path
             if (!Path::isBasePath($repositoryPath, $mappingPath) && !in_array($repositoryPath, $nestedMappingPaths, true)) {
                 continue;
             }
             // Don't check this mapping anymore in recursive calls
             unset($inMappings[$mappingPath][$packageName]);
             if (empty($inMappings[$mappingPath])) {
                 unset($inMappings[$mappingPath]);
             }
             // Add mapping to output
             $outMappings[$mappingPath][$packageName] = $mapping;
             foreach ($nestedMappingPaths as $nestedMappingPath) {
                 $repositoryPaths[$nestedMappingPath] = true;
             }
         }
     }
     // Continue to search for mappings for the repository paths we collected
     // already until there are no more mappings
     if (!empty($inMappings)) {
         foreach ($repositoryPaths as $nestedMappingPath => $true) {
             // Don't process paths twice
             if (!isset($processedPaths[$nestedMappingPath])) {
                 $this->filterEnabledMappings($nestedMappingPath, $inMappings, $outMappings, $processedPaths);
             }
         }
     }
 }

 /**
  * Returns true if path is located under basepath
  * @param string $path
  * @param string $basepath
  * @return bool
  */
 public static function isBasePath($path, $basepath = '/')
 {
     return Path::isBasePath($basepath, $path);
 }

 private function parseAbsoluteInput($input, array $roots, array $vars, array $values)
 {
     // If $input is an absolute file path with one of the given roots,
     // return a file asset
     foreach ($roots as $root) {
         if (Path::isBasePath($root, $input)) {
             $relative = Path::makeRelative($input, $root);
             $asset = $this->createFileAsset($input, $root, $relative, $vars);
             $asset->setValues($values);
             return $asset;
         }
     }
     $inputWithoutVars = VarUtils::resolve($input, $vars, $values);
     // If $input is an absolute file path with none of the given roots,
     // return a file asset with its root set to null
     if (is_file($inputWithoutVars)) {
         $asset = $this->createFileAsset($input, null, $input, $vars);
         $asset->setValues($values);
         return $asset;
     }
     // Otherwise assume to have an absolute Puli path
     if ($this->repo->contains($inputWithoutVars)) {
         $asset = $this->createPuliAsset($input, $vars);
         $asset->setValues($values);
         return $asset;
     }
     throw new RuntimeException(sprintf('The asset "%s" could not be found.', $inputWithoutVars));
 }

 private function createResource($filesystemPath, $path)
 {
     $resource = null;
     if (is_link($filesystemPath)) {
         $baseDir = rtrim($this->baseDir, '/');
         $targetFilesystemPath = $this->readLink($filesystemPath);
         if (Path::isBasePath($baseDir, $targetFilesystemPath)) {
             $targetPath = '/' . Path::makeRelative($targetFilesystemPath, $baseDir);
             $resource = new LinkResource($targetPath);
         }
     }
     if (!$resource && is_dir($filesystemPath)) {
         $resource = new DirectoryResource($filesystemPath);
     }
     if (!$resource) {
         $resource = new FileResource($filesystemPath);
     }
     $resource->attachTo($this, $path);
     return $resource;
 }

 /**
  * {@inheritdoc}
  */
 public function getUrl($rootDir, $prefix = '')
 {
     if (!Path::isBasePath($rootDir, $this->path)) {
         throw new \InvalidArgumentException(sprintf('Path "%s" is not inside root directory "%s"', $this->path, $rootDir));
     }
     $url = Path::makeRelative($this->path, $rootDir);
     $url = str_replace('%2F', '/', rawurlencode($url));
     return $prefix . $url;
 }

 /**
  * Returns whether a resource path matches a query.
  *
  * @param string $resourcePath The resource path.
  * @param string $query        The resource query of a binding.
  *
  * @return bool Returns `true` if the resource path matches the query.
  */
 protected function resourcePathMatchesQuery($resourcePath, $query)
 {
     if (false !== strpos($query, '*')) {
         return Glob::match($resourcePath, $query);
     }
     return $query === $resourcePath || Path::isBasePath($query, $resourcePath);
 }