PHP Filesystem::deleteDir方法代码示例

 /**
  * 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/'));
 }