PHP Finder::path方法代码示例

 /**
  * Create a map for a given path
  *
  * @param array $paths
  * @return array
  */
 public function createMap(...$paths)
 {
     $classes = [];
     $this->finder->files()->ignoreUnreadableDirs()->in($paths);
     foreach ($this->excludePathPatterns as $exclude) {
         $this->finder->notPath($exclude);
     }
     foreach ($this->inPathPatterns as $inPath) {
         $this->finder->path($inPath);
     }
     foreach ($this->names as $name) {
         $this->finder->name($name);
     }
     /** @var SplFileInfo $file */
     foreach ($this->finder as $file) {
         $content = file_get_contents($file->getPathname());
         preg_match('^\\s*class ([\\S]*)\\s*(extends|implements|{)^', $content, $match, PREG_OFFSET_CAPTURE);
         if (isset($match[1])) {
             $className = '\\' . trim($match[1][0]);
             $offset = $match[1][1];
         } else {
             continue;
         }
         preg_match('|\\s*namespace\\s*([\\S]*)\\s*;|', substr($content, 0, $offset), $match);
         if (isset($match[1]) && trim($match[1]) !== '') {
             $className = '\\' . trim($match[1]) . $className;
         }
         if ($className !== '\\') {
             $classes[$file->getPathname()] = $className;
         }
     }
     return $classes;
 }

 /**
  * @param array $filters
  * @return $this
  */
 public function withFilters(array $filters)
 {
     if (!empty($filters)) {
         foreach ($filters as $currentFilter) {
             if (!strpos($currentFilter, ':')) {
                 throw new \InvalidArgumentException(sprintf('The filter "%s" is not a valid filter. A valid filter has the format <name>:<value>.', $currentFilter));
             }
             $currentFilterElements = explode(':', $currentFilter, 2);
             switch (trim($currentFilterElements[0])) {
                 case 'exclude':
                     $this->finder->exclude($currentFilterElements[1]);
                     break;
                 case 'name':
                     $this->finder->name($currentFilterElements[1]);
                     break;
                 case 'notName':
                     $this->finder->notName($currentFilterElements[1]);
                     break;
                 case 'path':
                     $this->finder->path($currentFilterElements[1]);
                     break;
                 case 'size':
                     $this->finder->size($currentFilterElements[1]);
             }
         }
     }
     return $this;
 }

 /**
  * Action for Add an ignore pattern.
  *
  * @param string $pattern The pattern
  */
 public function doAddPattern($pattern)
 {
     if (0 === strpos($pattern, '!')) {
         $this->finder->notPath(Glob::toRegex(substr($pattern, 1), true, false));
     } else {
         $this->finder->path(Glob::toRegex($pattern, true, false));
     }
 }

 /**
  * Step2: Converter pattern to glob.
  *
  * @param string $prefix        The prefix
  * @param string $searchPattern The search pattern
  * @param string $pattern       The pattern
  */
 protected function convertPatternStep2($prefix, $searchPattern, $pattern)
 {
     if ('.*' === $searchPattern) {
         $this->doAddPattern($prefix . '**/.*');
     } elseif ('**' === $searchPattern) {
         $this->finder->path('/.*/');
         $this->finder->notPath('/^\\..*(?!\\/)/');
     } elseif (preg_match('/\\/\\*$|\\/\\*\\*$/', $pattern, $matches)) {
         $this->doAddPattern(substr($pattern, 0, strlen($pattern) - strlen($matches[0])));
     }
 }

 public function getItems(array $include, array $exclude)
 {
     $finder = new Finder();
     $finder->in($this->getRootPath());
     foreach ($include as $path) {
         $finder->path($this->normalizePath($path));
     }
     foreach ($exclude as $path) {
         $finder->notPath($this->normalizePath($path));
     }
     $items = [];
     foreach ($finder as $resource) {
         $items[] = $this->loadItem($resource);
     }
     return $items;
 }

 /**
  * Quick helper function for automatic class share in Silex
  *
  * @param string $searchDirectory Directory to scan for php classes
  * @param string $nameEndWith     End string to find in the name to consider the class as valid
  *                                Example : for classes of type 'UserController', set 'Controller' for this parameter
  * @param string $pathFilter      Path filter (optional)
  *                                Usage example : we want to add the condition that the path contains a folder 'Controllers'
  * @param bool   $useCache        Use cache feature or not
  * @param string $cacheDir        Cache directory to use ('app/cache' by default)
  *
  * @return array
  */
 public static function appShareClassHelper($searchDirectory, $nameEndWith, $pathFilter, $useCache = true, $cacheDir = 'app/cache')
 {
     if ($useCache) {
         if (file_exists($cacheDir . '/shares/' . strtolower($nameEndWith) . '.log')) {
             return unserialize(file_get_contents($cacheDir . '/shares/' . strtolower($nameEndWith) . '.log'));
         }
     }
     if (!file_exists($searchDirectory)) {
         return false;
     }
     $shares = array();
     $classFinder = new Finder();
     $searchDirectory = realpath($searchDirectory);
     $cacheDir = realpath($cacheDir);
     $fileNameFilter = $nameEndWith;
     if (false === strripos($fileNameFilter, '.php')) {
         $fileNameFilter .= '.php';
     }
     $classFinder->files()->name('*' . $fileNameFilter);
     if (!empty($pathFilter)) {
         $classFinder->path('/' . $pathFilter . '/');
     }
     $classFinder->in($searchDirectory);
     /**
      * @var SplFileInfo $classFile
      */
     foreach ($classFinder as $classFile) {
         $key = strtolower(str_replace($fileNameFilter, '', $classFile->getFilename()));
         if (!empty($key)) {
             $className = str_replace('.php', '', $classFile->getFilename());
             $classFQCN = str_replace(realpath($searchDirectory) . DIRECTORY_SEPARATOR, '', realpath($classFile->getPath()));
             $classFQCN = str_replace('/', '\\', $classFQCN) . '\\' . $className;
             $shares[$key . '.' . strtolower($nameEndWith)] = $classFQCN;
         }
     }
     if ($useCache) {
         if (!file_exists($cacheDir . '/shares')) {
             mkdir($cacheDir . '/shares', 0755, true);
         }
         if (!file_exists($cacheDir . '/shares/' . strtolower($nameEndWith) . '')) {
             file_put_contents($cacheDir . '/shares/' . strtolower($nameEndWith) . '', serialize($shares));
         }
     }
     return $shares;
 }

 public function process($professorName = null, $path = null)
 {
     if ($professorName === null) {
         $this->processAll();
     } else {
         $professor = $this->getProfessor($professorName);
         if ($path === null) {
             $photos = $this->findAll();
             $arr = [];
             foreach ($photos as $photo) {
                 $dest = $this->baseCacheDestination . '/' . $professor->name . '/' . $photo->getRelativePathname();
                 $arr[] = $dest;
                 $this->processSingleFile($photo->getRealPath(), $dest, $professor->transformFunction, $professor->transformClass);
             }
             $this->lastProcessedFiles = $arr;
         } else {
             $photos = new Finder();
             $photos->files()->in($this->basePath);
             $pathBase = dirname($path);
             if ($pathBase !== '.') {
                 $photos->path($pathBase);
             }
             $photos->name(basename($path));
             foreach ($photos as $photo) {
                 if (preg_match($this->extenstions, $photo->getRealPath())) {
                     $dest = $this->baseCacheDestination . '/' . $professor->name . '/' . $photo->getRelativePathname();
                     $this->lastProcessedFiles = $dest;
                     $this->processSingleFile($photo->getRealPath(), $dest, $professor->transformFunction, $professor->transformClass);
                 } else {
                     return false;
                 }
             }
         }
     }
     return $this;
 }

 /**
  * Get the Oro fixtures list
  *
  * @return array
  */
 protected function getOroFixturesList()
 {
     $bundles = $this->getContainer()->getParameter('kernel.bundles');
     $basePath = realpath($this->getContainer()->getParameter('kernel.root_dir') . DIRECTORY_SEPARATOR . '..');
     $finder = new Finder();
     foreach ($bundles as $bundleName => $bundleNamespace) {
         if (strpos($bundleNamespace, 'Oro\\') === 0) {
             $bundle = $this->getContainer()->get('kernel')->getBundle($bundleName);
             $finder->in($bundle->getPath());
         }
     }
     // Oro User Bundle overriden by Pim User Bundle, but we still need the data fixtures inside OroUserBundle
     $finder->in($basePath . "/vendor/oro/platform/src/Oro/Bundle/UserBundle");
     $directories = $finder->path('/^DataFixtures$/')->directories();
     $oroFixtures = array();
     foreach ($directories as $directory) {
         $oroFixtures[] = $directory->getPathName();
     }
     return $oroFixtures;
 }

 /**
  * @return Finder
  */
 public function getTempFolders()
 {
     $finder = new Finder();
     $sysPath = $this->getSysPath();
     $finder->directories()->in($sysPath);
     $finder->path('archive');
     $finder->path('data/temp');
     return $finder;
 }

$directoryIterator = $directoryFinder->in($path->path);
$directoryArray = array();
foreach ($directoryIterator as $directory) {
    $directoryArray[] = array("path" => $directory->getRelativePathname(), "name" => $directory->getBasename());
}
$fileFinder = new Finder();
$fileFinder->files()->ignoreUnreadableDirs()->depth(0);
$allowedImageTypes = loadPicFile("helpers/imagetypes.php");
foreach ($allowedImageTypes as $imageType) {
    $fileFinder->name("*.{$imageType}");
}
foreach (array_map("strtoupper", $allowedImageTypes) as $imageType) {
    $fileFinder->name("*.{$imageType}");
}
$fileFinder->sortByName();
if ($path->hasPermission("symlinks")) {
    $fileFinder->followLinks();
}
if (!empty($relpath)) {
    $fileFinder->path($relpath)->depth(substr_count($relpath, "/") + 1);
}
if ($path->hasPermission("nsfw") === false) {
    $fileFinder->notPath("/.*\\/NSFW\\/.*/")->notPath("/NSFW\\/.*/")->notPath("/.*\\/NSFW/");
}
$fileIterator = $fileFinder->in($path->path);
$fileArray = array();
foreach ($fileIterator as $file) {
    $fileArray[] = array("filename" => $file->getBasename(), "relpath" => $file->getRelativePathname(), "size" => humanFilesize($file->getSize()), "mtime" => date("Y-m-d H:i:s", $file->getMTime()));
}
header("Content-type: application/json");
echo json_encode(array("directories" => $directoryArray, "files" => $fileArray));

 /**
  * Apply configuration to finder
  *
  * @param Finder $finder
  */
 public function apply(Finder $finder)
 {
     $finder->exclude($this->excludeDirs);
     foreach ($this->excludePaths as $pattern) {
         $finder->notPath($pattern);
     }
     foreach ($this->excludeFiles as $pattern) {
         $finder->notName($pattern);
     }
     $finder->in($this->includeDirs);
     foreach ($this->includePaths as $pattern) {
         $finder->path($pattern);
     }
     foreach ($this->includeFiles as $pattern) {
         $finder->name($pattern);
     }
 }

 /**
  * @param  InputInterface $input
  * @return Finder
  */
 public function createFinder(InputInterface $input)
 {
     $finder = new Finder();
     $finder->files();
     foreach ($input->getArgument('directory') as $dir) {
         $finder->in($dir);
     }
     foreach ($input->getOption('not-dir') as $ignoreDir) {
         $finder->exclude($ignoreDir);
     }
     foreach ($input->getOption('file-name') as $pattern) {
         $finder->name($pattern);
     }
     foreach ($input->getOption('not-file-name') as $pattern) {
         $finder->notName($pattern);
     }
     foreach ($input->getOption('contains') as $pattern) {
         $finder->contains($pattern);
     }
     foreach ($input->getOption('not-contains') as $pattern) {
         $finder->notContains($pattern);
     }
     foreach ($input->getOption('path') as $pattern) {
         $finder->path($pattern);
     }
     foreach ($input->getOption('not-path') as $pattern) {
         $finder->notPath($pattern);
     }
     if ($size = $input->getOption('size')) {
         $finder->size($size);
     }
     if ($modified = $input->getOption('modified')) {
         $finder->date($modified);
     }
     if ($depth = $input->getOption('depth')) {
         $finder->depth($depth);
     }
     return $finder;
 }

 /**
  * @return Finder
  */
 public function getConfigFolders()
 {
     $finder = new Finder();
     $sysPath = $this->getSysPath();
     $finder->directories()->in($sysPath);
     $finder->path('main/inc/conf');
     $finder->path('app/config');
     return $finder;
 }

 /**
  * @return Finder
  */
 public function path($pattern)
 {
     return parent::path($pattern);
 }