/** @inheritdoc */ public function clean($validPackages) { foreach (Linq::from($this->filesystem->listContents($this->vendorDir))->where(function ($v) { return $v['type'] == 'dir'; }) as $vendor) { if (!Linq::from($validPackages)->any(function ($v, $k) use($vendor) { return preg_match('/^' . $vendor['basename'] . '/i', $k); })) { $this->notify("DELETING: " . $vendor['path'] . "\n"); $this->filesystem->deleteDir($vendor['path']); continue; } foreach (Linq::from($this->filesystem->listContents($vendor['path']))->where(function ($v) { return $v['type'] == 'dir'; }) as $package) { if (!Linq::from($validPackages)->any(function ($v, $k) use($vendor, $package) { return $k == $vendor['basename'] . '/' . $package['basename']; })) { $this->notify("DELETING: " . $package['path'] . "\n"); $this->filesystem->deleteDir($package['path']); continue; } foreach (Linq::from($this->filesystem->listContents($package['path']))->where(function ($v) { return $v['type'] == 'dir'; }) as $version) { if (!Linq::from($validPackages[$vendor['basename'] . '/' . $package['basename']])->any(function ($v) use($version) { return $v == $version['basename']; })) { $this->notify("DELETING: " . $version['path'] . "\n"); $this->filesystem->deleteDir($version['path']); } } } } }
public function handle($path) { $files = []; $folders = []; $list = $this->filesystem->listContents($path); $ignored = ['.', '..', '.DS_Store', '.gitignore', '.htaccess']; foreach ($list as $entry) { if (in_array($entry['basename'], $ignored)) { continue; } if (!$this->filesystem->authorized($entry['path'])) { continue; } if ($entry['type'] === 'file') { try { $url = $this->filesystem->url($entry['path']); } catch (\Exception $e) { $url = $entry['path']; } // Ugh, for some reason the foldername for the theme is included twice. Why? // For now we 'fix' this with an ugly hack, replacing it. :-/ // TODO: dig into Filesystem and figure out why this happens. $pathsegments = explode('/', $entry['path']); if (!empty($pathsegments[0])) { $url = str_replace('/' . $pathsegments[0] . '/' . $pathsegments[0] . '/', '/' . $pathsegments[0] . '/', $url); } $files[$entry['path']] = ['path' => $entry['dirname'], 'filename' => $entry['basename'], 'newpath' => $entry['path'], 'relativepath' => $entry['path'], 'writable' => true, 'readable' => false, 'type' => isset($entry['extension']) ? $entry['extension'] : '', 'filesize' => Lib::formatFilesize($entry['size']), 'modified' => date("Y/m/d H:i:s", $entry['timestamp']), 'permissions' => 'public', 'url' => $url]; /* **** Extra checks for files that can be resolved via PHP urlopen functions **** */ try { $files[$entry['path']]['permissions'] = $this->filesystem->getVisibility($entry['path']); } catch (\Exception $e) { // Computer says "No!" } $fullfilename = $this->filesystem->getAdapter()->applyPathPrefix($entry['path']); if (is_readable($fullfilename)) { $files[$entry['path']]['readable'] = true; if (!empty($entry['extension']) && in_array($entry['extension'], ['gif', 'jpg', 'png', 'jpeg'])) { $size = getimagesize($fullfilename); $files[$entry['path']]['imagesize'] = sprintf("%s × %s", $size[0], $size[1]); } $files[$entry['path']]['permissions'] = util::full_permissions($fullfilename); } } if ($entry['type'] == 'dir') { $folders[$entry['path']] = ['path' => $entry['dirname'], 'foldername' => $entry['basename'], 'newpath' => $entry['path'], 'modified' => date("Y/m/d H:i:s", $entry['timestamp']), 'writable' => true]; $fullfilename = $this->filesystem->getAdapter()->applyPathPrefix($entry['path']); /* **** Extra checks for files that can be resolved via PHP urlopen functions **** */ if (is_readable($fullfilename)) { if (!is_writable($fullfilename)) { $folders[$entry['path']]['writable'] = false; } } } } ksort($files); ksort($folders); return [$files, $folders]; }
/** * @return array */ private function getComposerFiles() { $files = []; $fileList = $this->fileSystem->listContents('./', true); foreach ($fileList as $file) { if ($file['basename'] === self::LOCATE_FILE) { $files[] = $file['path']; } } return $files; }
public function handle($term, $extensions = 'jpg,jpeg,gif,png') { $extensions = explode(",", $extensions); $allFiles = $this->filesystem->listContents('', true); $files = array(); foreach ($allFiles as $file) { if ($file['type'] == 'file' && ($term == '*' || strpos($file['path'], $term) !== false) && in_array($file['extension'], $extensions)) { $files[] = $file['path']; } } return $files; }
/** * {@inheritdoc} */ public function handle($config, CertificateResponse $response) { $remoteAdapter = $this->createAdapter($config); $remote = new Filesystem($remoteAdapter); $files = $this->master->listContents('.', true); foreach ($files as $file) { if (0 === strpos($file['basename'], '.')) { continue; } $this->mirror($file['type'], $file['path'], $remote, $remoteAdapter); } }
/** * @param string $containerName * * @return array */ public function listFilesByContainerName($containerName) { $files = []; foreach ($this->filesystem->listContents($containerName, true) as $file) { $file['mapped_path'] = sprintf('%s/%s', $this->baseUrl, $file['path']); if (array_key_exists('size', $file)) { $file['size_human'] = FileSize::convertToHumanReadable($file['size']); } $files[] = $file; } return $files; }
/** * Recursively yield files that meet the specification * * @param SpecificationInterface $specification * @param string $path * @return Generator */ private function yieldFilesInPath(SpecificationInterface $specification, $path) { $listContents = $this->filesystem->listContents($path); foreach ($listContents as $location) { if ($specification->isSatisfiedBy($location)) { (yield $location); } if ($location['type'] == 'dir') { foreach ($this->yieldFilesInPath($specification, $location['path']) as $returnedLocation) { (yield $returnedLocation); } } } }
/** * Return files list in directory * * @param string $path dir path * @return array **/ protected function _scandir($path) { $paths = array(); foreach ($this->fs->listContents($path, false) as $object) { $paths[] = $object['path']; } return $paths; }
public function generate($query) { $files = $this->filesystem->listContents($this->config['directory']); array_filter($files, [$this, 'filterFiles']); if (empty($files)) { throw new RuntimeException('Cannot generate fractal image: template folder is empty'); } mt_srand((double) microtime() * 1000000); mt_rand(0, 1); $random_file = mt_rand(0, count($files) - 1); $resource = imagecreatefromjpeg(DIRECTORY_SEPARATOR . $files[$random_file]['path']); if (!is_resource($resource)) { throw new RuntimeException('Cannot create image from the fractal template: ' . $files[$random_file]['basename']); } return $resource; // this variant will not work because of the different resource type // return $this->filesystem->readStream($files[$random_file]['path']); }
/** * @inheritdoc */ public function listFiles($directory = '') { $files = []; foreach ($this->filesystem->listContents($directory, true) as $file) { if ($file['type'] == 'dir' || strstr($file['path'], '/.') !== false) { continue; } $files[] = $file['path']; } return $files; }
protected function getPaths(FilesystemInterface $filesystem, $skipDirs) { $paths = []; foreach ($filesystem->listContents($this->dir, true) as $path) { if ($skipDirs && $path['type'] === 'dir') { continue; } $paths[$path['path']] = $path; } ksort($paths); return $paths; }
/** @inheritdoc */ public function extract($zipBallPath, $to) { $absolutePathToZipBall = $this->filesystem->getAdapter()->applyPathPrefix($zipBallPath); if ($this->zip->open($absolutePathToZipBall) === true) { $absolutePathToExtract = $this->filesystem->getAdapter()->applyPathPrefix($to); $this->zip->extractTo($absolutePathToExtract); $this->zip->close(); $zipCreatedFolder = Linq::from($this->filesystem->listContents($to))->single(function ($object) { return $object['type'] == 'dir'; })['path']; foreach ($this->filesystem->listContents($zipCreatedFolder, true) as $object) { if ($object['type'] == "file") { $segments = explode('/', $object['path']); unset($segments[4]); $this->filesystem->rename($object['path'], implode('/', $segments)); } } $this->filesystem->deleteDir($zipCreatedFolder); return; } throw new ZipExtractionFailed($zipBall, $to); }
/** * {@inheritdoc} */ protected function removeEmptyDirectories($backupName) { /** * @var \SplFileInfo $dir */ foreach ($this->flysystem->listContents($backupName) as $dir) { if ($dir['type'] != 'dir') { continue; } if (count($this->flysystem->listContents($dir['path'])) > 0) { $this->removeEmptyDirectories($dir['path']); } else { $this->flysystem->deleteDir($dir['path']); } } }
/** * Erase a directory. * * @param string $dirname * @throws IoWriteException */ public function eraseDir($dirname = '') { try { $listing = $this->fs->listContents($dirname, false); foreach ($listing as $item) { if ($item['type'] === 'dir') { $this->fs->deleteDir($item['path']); } else { $this->fs->delete($item['path']); } } } catch (Error $ex) { throw new IoWriteException("Directory {$dirname} could not be erased.", $ex); } catch (Exception $ex) { throw new IoWriteException("Directory {$dirname} could not be erased.", $ex); } }
/** * Erase a directory. * * @param string $dirname * @throws WriteException */ private function ensuredEraseDir($dirname) { try { $listing = $this->fs->listContents($dirname, false); foreach ($listing as $item) { if ($item['type'] === 'dir') { $this->fs->deleteDir($item['path']); } else { $this->fs->delete($item['path']); } } return; } catch (Error $ex) { } catch (Exception $ex) { } throw new WriteException("Directory {$dirname} could not be erased.", $ex); }
/** * Given an array of mappings we will return a list of php src files. * * @param array $mappings * @return array */ private function getFilesFromMap($package, $version, $mappings) { $paths = []; $basePath = $this->vendorDir . '/' . $package . '/' . $version; foreach ($mappings as $ns => $mapping) { // Handle an exact file if (s($mapping)->endsWith('.php')) { $paths[] = $mapping; continue; } $files = $this->filesystem->listContents($basePath . '/' . $mapping, true); $query = Linq::from($files)->where(function ($v) { return $v['type'] == 'file'; })->where(function ($v) { return isset($v['extension']); })->where(function ($v) { return $v['extension'] == 'php'; })->select(function ($v) use($basePath) { return str_replace($basePath . '/', '', $v['path']); })->where(function ($v) { foreach ($this->excludes as $regex) { if (preg_match($regex, $v)) { return false; } } return true; })->toArray(); if (is_int($ns)) { // Handle a classmap $paths = array_merge($paths, $query); } else { // Handle a PSR-0/4 map // We save the namespace for later use. if (!isset($paths[$ns])) { $paths[$ns] = []; } $paths[$ns] = array_merge($paths[$ns], $query); } } return $paths; }
/** * @param string $trimmedSourcePath * @param string $trimmedTargetPath * @return bool */ protected function copyFolderRecursively($trimmedSourcePath, $trimmedTargetPath) { try { $contents = $this->filesystem->listContents($trimmedSourcePath, true); foreach ($contents as $item) { if ('file' === $item['type']) { try { $relPath = substr_replace($trimmedSourcePath, '', 0, strlen($item['path'])); $targetPath = $trimmedTargetPath . $relPath . '/' . $item['basename']; $this->filesystem->copy($item['path'], $targetPath); } catch (FileExistsException $fee) { continue; } catch (FileNotFoundException $fnfe) { return false; } } } } catch (\Exception $e) { return false; } return true; }
/** * Get all files in directory * * @param FilesystemInterface $filesystem * @param string $path * @return array */ protected function allFiles(FilesystemInterface $filesystem, $path) { $files = []; foreach ($filesystem->listContents($path, true) as $file) { if ($file['type'] == 'file') { $files[] = $file['path']; } } return $files; }
/** * Get all of the directories within a given directory. * * @param string|null $directory * @param bool $recursive * @return array */ public function directories($directory = null, $recursive = false) { $contents = $this->driver->listContents($directory, $recursive); return $this->filterContentsByType($contents, 'dir'); }
/** * List contents of a directory. * * @param string $directory The directory to list. * @param bool $recursive Whether to list recursively. * * @return array A list of file metadata. */ public function listContents($directory = '', $recursive = false) { return $this->fileSystem->listContents($directory, $recursive); }