/** * Remove file or a directory * * @param $path * @return void */ public function remove($path) { if (!$this->filesystem->has($path)) { return; } $meta = $this->filesystem->getMetadata($path); if ($meta['type'] === 'file') { $this->filesystem->delete($path); } else { $this->filesystem->deleteDir($path); } }
/** * @return bool */ public function execute() { if ($this->filesystem->getMimetype($this->filePath) == 'application/x-gzip') { if ($this->filesystem->getMimetype(str_replace('.tar.gz', '', $this->filePath)) == 'directory') { $this->filesystem->deleteDir(str_replace('.tar.gz', '', $this->filePath)); } } if ($this->filesystem->getMimetype($this->filePath) == 'directory') { return $this->filesystem->deleteDir($this->filePath); } else { return $this->filesystem->delete($this->filePath); } }
/** * {@inheritdoc} */ public function rmdir($path) { try { return @$this->flysystem->deleteDir($this->buildPath($path)); } catch (FileNotFoundException $e) { return false; } }
/** * Delete a directory. * * @param string $dirname * * @throws RootViolationException Thrown if $dirname is empty. * * @return bool True on success, false on failure. */ public function deleteDir($dirname) { try { return $this->filesystem->deleteDir($dirname); } catch (FlysystemRootViolationException $e) { RootViolationException::rootViolation(); } }
/** * Clean the cache dir. * * @throws \DomainException * @return void */ public static function cleanCache() { $filesystem = new Filesystem(new Local(self::$cacheDir)); foreach ($filesystem->listContents() as $path) { if ('dir' == $path['type']) { if (false == $filesystem->deleteDir($path['path'])) { throw new \DomainException('Can not clean the cache.'); } } } }
/** * @inheritdoc */ public function deleteDir($dirname) { $innerDirname = $this->getInnerPath($dirname); try { $return = $this->fileSystem->deleteDir($innerDirname); } catch (RootViolationException $e) { throw $this->exceptionWrapper($e, $dirname); } if ($return !== false) { $this->invokePlugin("removePathFromIndex", [$dirname, $innerDirname], $this); } return $return; }
/** * Clean up remote files. * * @return void */ public function cleanupRemote() { if (isset($this->config->keepfor)) { $remotePath = './' . $this->dump_folder; $directories = $this->remoteAdapter->listContents($remotePath); $timestamp = date('YmdHi', time() - (time() - strtotime($this->config->keepfor . ' ago'))); foreach ($directories as $dir) { if ($dir['filename'] < $timestamp) { $this->remoteAdapter->deleteDir($dir['path']); } } } }
private function handleOptions() { if ($this->delete) { $this->getItemsToDelete()->each(function ($item) { if ($item['type'] === 'dir') { dump($item); $this->filesystem->deleteDir($item['path']); return true; } $this->filesystem->delete($item['path']); return true; }); } }
protected function execute(InputInterface $input, OutputInterface $output) { $path = $input->getArgument('path'); if ($this->abortDeletion($path, $output)) { $output->writeln("<comment>Aborted.</comment>"); return; } $package = Package::fromFolder($path); $this->config->removePackage($package); $output->writeln("<comment>Removing package...</comment>"); $filesystem = new Filesystem(new Local(getcwd())); $filesystem->deleteDir($path); $output->writeln("<info>Package successfully removed.</info>"); $output->writeln("<comment>Dumping autoloads...</comment>"); Shell::run('composer dump-autoload'); $output->writeln("<info>Autoloads successfully generated.</info>"); }
public function testConvertCommandWithNamespaceOption() { $codeLocation = __DIR__ . '/mock/src/VendorName/ProjectName/Category/ProductName/v123456/'; $codeLocationArray = explode('/', $codeLocation); $codeLocationArray = array_splice($codeLocationArray, 6, 4); $directory = $codeLocationArray[0]; $destinationLocation = implode('/', $codeLocationArray); $codeDestination = '/tmp/'; $input = new ArrayInput(['convert', 'code-location' => $codeLocation, '--code-destination' => '/tmp', '--create-namespace' => true, '--offset' => 6, '--length' => 4]); $output = new BufferedOutput(); $app = new Application(); $app->get('convert')->run($input, $output); $this->assertFileExists(sprintf('/%s/%s/Date.php', $codeDestination, $destinationLocation)); $this->assertFileExists(sprintf('/%s/%s/DateRange.php', $codeDestination, $destinationLocation)); $this->assertFileExists(sprintf('/%s/%s/OrderBy.php', $codeDestination, $destinationLocation)); // Delete all files/ $filesystem = new Filesystem(new Local($codeDestination)); $filesystem->deleteDir($directory); }
/** * @param string[] $paths The paths where the original files are expected to be. * @param string[] $filters The imagine filters in effect. */ public function remove(array $paths, array $filters) { if (empty($paths) && empty($filters)) { return; } if (empty($paths)) { foreach ($filters as $filter) { $filterCacheDir = $this->cacheRoot . '/' . $filter; $this->flysystem->deleteDir($filterCacheDir); } return; } foreach ($paths as $path) { foreach ($filters as $filter) { if ($this->flysystem->has($this->getFilePath($path, $filter))) { $this->flysystem->delete($this->getFilePath($path, $filter)); } } } }
public function deleteDir($directory) { $this->flysystem->deleteDir($directory); }
private function deleteFiles($codeDestination, $directory) { // Delete all files/ $filesystem = new Filesystem(new Local($codeDestination)); $filesystem->deleteDir($directory); }
public function destroyCMS($identifier) { $adapter = new Local($this->container_path); $filesystem = new Filesystem($adapter); if ($this->checkExistance($identifier)) { if ($this->saveAsZip($identifier)) { $filesystem->deleteDir($identifier); return true; } } return false; }
/** * 3.txt * 2.txt. */ public function testDeleteDir() { $this->assertTrue($this->filesystem->deleteDir('test')); $this->assertFalse($this->filesystem->has('test/')); }
/** @inheritdoc */ public function import($request) { $_from = null; $_instance = $request->getInstance(); $_mount = $_instance->getStorageMount(); $this->info('[provisioning:storage:import] instance "' . $_instance->instance_id_text . '" begin'); // Grab the target (zip archive) and pull out the target of the import $_zip = $request->getTarget(); /** @var \ZipArchive $_archive */ /** @noinspection PhpUndefinedMethodInspection */ $_archive = $_zip->getAdapter()->getArchive(); $_path = null; foreach ($_zip->listContents() as $_file) { if ('dir' != $_file['type'] && false !== strpos($_file['path'], '.storage.zip')) { $_from = Disk::segment([sys_get_temp_dir(), 'dfe', 'import', sha1($_file['path'])], true); if (!$_archive->extractTo($_from, $_file['path'])) { throw new \RuntimeException('Unable to unzip archive file "' . $_file['path'] . '" from snapshot.'); } $_path = Disk::path([$_from, $_file['path']], false); if (!$_path || !file_exists($_path)) { throw new \InvalidArgumentException('$from file "' . $_file['path'] . '" missing or unreadable.'); } $_from = new Filesystem(new ZipArchiveAdapter($_path)); break; } } if (!$_mount instanceof Filesystem) { $_mount = new Filesystem(new ZipArchiveAdapter($_mount)); } // If "clean" == true, storage is wiped clean before restore if (true === $request->get('clean', false)) { $_mount->deleteDir('./'); } // Extract the files $_restored = []; /** @type Filesystem $_archive */ foreach ($_from->listContents() as $_file) { $_filename = $_file['path']; if ('dir' == array_get($_file, 'type')) { $_mount->createDir($_filename); } else { $_mount->writeStream($_filename, $_archive->readStream($_filename)); } $_restored[] = $_file; } unset($_from); $_path && is_dir(dirname($_path)) && Disk::deleteTree(dirname($_path)); // Fire off a "storage.imported" event... \Event::fire('dfe.storage.imported', [$this, $request]); $this->info('[provisioning:storage:import] instance "' . $_instance->instance_id_text . '" complete'); return $_restored; }
/** * Removes temporary directory * * @throws \League\Flysystem\FileExistsException */ public function __destruct() { $fs = new Filesystem(new Local(dirname($this->getPathPrefix()))); $fs->deleteDir(basename($this->getPathPrefix())); $fs->assertAbsent($this->getPathPrefix()); }
/** * @inheritdoc */ protected function _rmdir($path) { return $this->fs->deleteDir($path); }
public function testDeleteDir() { $this->prophecy->deleteDir('dirname')->willReturn(true); $response = $this->filesystem->deleteDir('dirname'); $this->assertTrue($response); }
/** * Delete a directory. * * @param string $dirname * * @throws RootViolationException Thrown if $dirname is empty. * * @return bool True on success, false on failure. */ public function deleteDir($dirname) { $result = parent::deleteDir($dirname); if ($result && ($resource = $this->get($dirname))) { return $this->dispatch(new DeleteFolder($resource)); } return $result; }
/** * Removes a folder from oc * @param string $directoryName * * @return bool */ public function removeDirectory($directoryName) { return $this->fs->deleteDir($directoryName); }
/** * Deletes a directory. * * @param string $dirname * * @return bool */ public function deleteDir($dirname) { $baseAdapter = $this->getBaseAdapter(); // For FTP first remove recursively all directory contents if ($baseAdapter instanceof Ftp) { $this->deleteContents($dirname); } return parent::deleteDir($dirname); }
/** * Clear directory if it's empty * * @param string $dirname Name of directory * @param Filesystem $filesystem */ protected function truncateDirectory($dirname, Filesystem $filesystem) { if ($dirname && ltrim(dirname($dirname), '.') && !Config::inst()->get(get_class($this), 'keep_empty_dirs') && !$filesystem->listContents($dirname)) { $filesystem->deleteDir($dirname); } }
private function cleanup() { if ($this->keepFiles) { // Don't cleanup return $this; } $filesystem = new Filesystem(new Local($this->outPath)); $filesystem->deleteDir('zips'); $filesystem->createDir('zips'); $filesystem->deleteDir('sources'); $filesystem->createDir('sources'); return $this; }
function tearDown() { $flysystem = new Filesystem(new Local(MY_DRINKS_VAR_DIR)); $flysystem->deleteDir('tmp'); }
/** * Clear current dir */ public function deleteAll() { foreach (parent::listContents() as $value) { if (!isset($value['type']) || $value['type'] === self::TYPE_DIR) { parent::deleteDir($value['path']); continue; } parent::delete($value['path']); } }