vendor/symfony/finder/Iterator/RecursiveDirectoryIterator.php line 61

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Finder\Iterator;
  14. use Symfony\Component\Finder\Exception\AccessDeniedException;
  15. use Symfony\Component\Finder\SplFileInfo;
  17. /**
  18.  * Extends the \RecursiveDirectoryIterator to support relative paths.
  19.  *
  20.  * @author Victor Berchet <victor@suumit.com>
  21.  */
  22. class RecursiveDirectoryIterator extends \RecursiveDirectoryIterator
  23. {
  24.     /**
  25.      * @var bool
  26.      */
  27.     private $ignoreUnreadableDirs;
  29.     /**
  30.      * @var bool
  31.      */
  32.     private $rewindable;
  34.     // these 3 properties take part of the performance optimization to avoid redoing the same work in all iterations
  35.     private $rootPath;
  36.     private $subPath;
  37.     private $directorySeparator = '/';
  39.     /**
  40.      * @throws \RuntimeException
  41.      */
  42.     public function __construct(string $path, int $flags, bool $ignoreUnreadableDirs = false)
  43.     {
  44.         if ($flags & (self::CURRENT_AS_PATHNAME | self::CURRENT_AS_SELF)) {
  45.             throw new \RuntimeException('This iterator only support returning current as fileinfo.');
  46.         }
  48.         parent::__construct($path, $flags);
  49.         $this->ignoreUnreadableDirs = $ignoreUnreadableDirs;
  50.         $this->rootPath = $path;
  51.         if ('/' !== \DIRECTORY_SEPARATOR && !($flags & self::UNIX_PATHS)) {
  52.             $this->directorySeparator = \DIRECTORY_SEPARATOR;
  53.         }
  54.     }
  56.     /**
  57.      * Return an instance of SplFileInfo with support for relative paths.
  58.      *
  59.      * @return SplFileInfo File information
  60.      */
  61.     public function current()
  62.     {
  63.         // the logic here avoids redoing the same work in all iterations
  65.         if (null === $subPathname = $this->subPath) {
  66.             $subPathname = $this->subPath = (string) $this->getSubPath();
  67.         }
  68.         if ('' !== $subPathname) {
  69.             $subPathname .= $this->directorySeparator;
  70.         }
  71.         $subPathname .= $this->getFilename();
  73.         return new SplFileInfo($this->rootPath.$this->directorySeparator.$subPathname, $this->subPath, $subPathname);
  74.     }
  76.     /**
  77.      * @return \RecursiveIterator
  78.      *
  79.      * @throws AccessDeniedException
  80.      */
  81.     public function getChildren()
  82.     {
  83.         try {
  84.             $children = parent::getChildren();
  86.             if ($children instanceof self) {
  87.                 // parent method will call the constructor with default arguments, so unreadable dirs won't be ignored anymore
  88.                 $children->ignoreUnreadableDirs = $this->ignoreUnreadableDirs;
  90.                 // performance optimization to avoid redoing the same work in all children
  91.                 $children->rewindable = &$this->rewindable;
  92.                 $children->rootPath = $this->rootPath;
  93.             }
  95.             return $children;
  96.         } catch (\UnexpectedValueException $e) {
  97.             if ($this->ignoreUnreadableDirs) {
  98.                 // If directory is unreadable and finder is set to ignore it, a fake empty content is returned.
  99.                 return new \RecursiveArrayIterator([]);
  100.             } else {
  101.                 throw new AccessDeniedException($e->getMessage(), $e->getCode(), $e);
  102.             }
  103.         }
  104.     }
  106.     /**
  107.      * Do nothing for non rewindable stream.
  108.      */
  109.     public function rewind()
  110.     {
  111.         if (false === $this->isRewindable()) {
  112.             return;
  113.         }
  115.         parent::rewind();
  116.     }
  118.     /**
  119.      * Checks if the stream is rewindable.
  120.      *
  121.      * @return bool true when the stream is rewindable, false otherwise
  122.      */
  123.     public function isRewindable()
  124.     {
  125.         if (null !== $this->rewindable) {
  126.             return $this->rewindable;
  127.         }
  129.         if (false !== $stream = @opendir($this->getPath())) {
  130.             $infos = stream_get_meta_data($stream);
  131.             closedir($stream);
  133.             if ($infos['seekable']) {
  134.                 return $this->rewindable = true;
  135.             }
  136.         }
  138.         return $this->rewindable = false;
  139.     }
  140. }