PHP Filesystem::isWritable方法代码示例

 /**
  * Set the path for the JSON file.
  *
  * @param  string  $path
  *
  * @return self
  */
 public function setPath($path)
 {
     if (!$this->files->exists($path) && $this->files->put($path, '{}') === false) {
         throw new InvalidArgumentException("Could not write to {$path}.");
     }
     if (!$this->files->isWritable($path)) {
         throw new InvalidArgumentException("{$path} is not writable.");
     }
     $this->path = $path;
     return $this;
 }

 /**
  * Compile routes template and generate
  *
  * @param string $path
  * @param string $name
  * @param array $options
  * @return boolean
  */
 public function make($path, $name, array $options = [])
 {
     $options += ['filter' => null, 'prefix' => null];
     $this->parsedRoutes = $this->getParsedRoutes($options['filter'], $options['prefix']);
     $template = $this->file->get(__DIR__ . '/templates/Router.js');
     $template = str_replace("routes: null,", 'routes: ' . json_encode($this->parsedRoutes) . ',', $template);
     $template = str_replace("'Router'", "'" . $options['object'] . "'", $template);
     if ($this->file->isWritable($path)) {
         $filename = $path . '/' . $name;
         return $this->file->put($filename, $template) !== false;
     }
     return false;
 }

 /**
  * Set the path for the JSON file.
  *
  * @param string $path
  */
 public function setPath($path)
 {
     if (!$this->filesystem->exists($path)) {
         $result = $this->filesystem->put($path, '{}');
         if (!$result) {
             throw new \InvalidArgumentException("Could not write to {$path}.");
         }
     }
     if (!$this->filesystem->isWritable($path)) {
         throw new \InvalidArgumentException("{$path} is not writable.");
     }
     $this->path = $path;
 }

 /**
  * Set the path for the JSON file.
  *
  * @param string $path
  * @throws NotWritableException
  */
 public function setPath($path)
 {
     if (!$this->files->exists($path)) {
         $result = $this->files->put($path, '{}');
         if ($result === false) {
             throw new NotWritableException("Could not write to {$path}.");
         }
     }
     if (!$this->files->isWritable($path)) {
         throw new NotWritableException("{$path} is not writable.");
     }
     $this->path = $path;
 }

 /**
  * Perform undo action
  *
  * @return void
  */
 protected function undo()
 {
     // Delete status
     $deleteCompleted = true;
     // Get files from the json undo file
     $files = json_decode($this->filesystem->get($this->undoFilePath), true);
     // For each file
     $this->info('Deleting files:');
     foreach ($files as $file) {
         // If this file can be deleted
         if ($this->filesystem->isWritable($file)) {
             // Delete it
             $this->filesystem->delete($file);
             $this->info("  Deleted: {$file}");
         } else {
             // Set status
             $deleteCompleted = false;
             // Show error
             $this->error('Could not delete: ' . $file);
         }
     }
     // if the delete prccess finished successfully
     if ($deleteCompleted) {
         // Delete undo file
         $this->filesystem->delete($this->undoFilePath);
     }
 }

 /**
  * @param \Exolnet\Image\Imageable                    $image
  * @param \Symfony\Component\HttpFoundation\File\File $file
  * @return bool
  * @throws \Exolnet\Core\Exceptions\ServiceValidationException
  */
 public function store(Imageable $image, File $file)
 {
     if (!$image->getFilename()) {
         throw new ServiceValidationException('Could not store image with an empty filename.');
     }
     $path = dirname($image->getImagePath());
     $filename = basename($image->getImagePath());
     if (!$this->filesystem->exists($path)) {
         $this->filesystem->makeDirectory($path, 0755, true);
     }
     if (!$this->filesystem->isWritable($path)) {
         throw new ServiceValidationException('The image base path "' . $path . '" is not writable.');
     }
     $file->move($path, $filename);
     return true;
 }

 /**
  * Handle the command.
  *
  * @param Filesystem  $files
  * @param Application $application
  */
 public function handle(Filesystem $files, Application $application)
 {
     $paths = ['storage', $application->getStoragePath(), 'public/assets', $application->getAssetsPath()];
     foreach ($paths as $path) {
         if ($files->exists(base_path($path)) && !$files->isWritable(base_path($path))) {
             die('chmod -R 777 ' . base_path($path));
         }
     }
 }

 /**
  * Where in the /public directory should the files
  * be stored?
  * 
  * @return string $path
  */
 public function getStaticPathLocation()
 {
     $path = public_path() . $this->fileLocation;
     if (!$this->fs->isWritable($path)) {
         throw new PathNotWritableException();
     }
     if (!$this->fs->isDirectory($path)) {
         $this->fs->makeDirectory($path);
     }
     return $path;
 }

 /**
  * Erstellt die module.json Datei
  * 
  * @param string $module
  * @return void
  */
 private function createFile($module)
 {
     $module = $this->modules[$module];
     if($this->files->isWritable($module))
     {
         $this->files->copy(__DIR__.'/../templates/module.json', $module.'/module.json');
     }
     else
     {
         return App::abort('403', "Please set writable permissions to " . $module . "\n");
     }
 }

 protected function checkEnv($path, $name, $namespace, $title)
 {
     // check directory exists
     if ($this->files->exists($path)) {
         $this->error($this->type . ' already exists!');
         return false;
     }
     // check permission
     $pluginsDir = app('xe.plugin')->getPluginsDir();
     if (!$this->files->isWritable($pluginsDir)) {
         $this->error("Permission denied. Can not create plugin directory({$path}).");
         return false;
     }
 }

 protected function checkEnv($path, $name, $namespace, $title)
 {
     // check directory exists
     if ($this->files->exists($path)) {
         $this->error('Plugin already exists!');
         return false;
     }
     // check namespace
     if (!str_contains($namespace, '\\')) {
         $this->error('The namespace must have at least 1 delimiter(\\), use double backslash(\\\\) as delimiter');
         return false;
     }
     // check permission
     $pluginsDir = app('xe.plugin')->getPluginsDir();
     if (!$this->files->isWritable($pluginsDir)) {
         $this->error("Permission denied. Can not create plugin directory({$path}).");
         return false;
     }
 }

 /**
  * Determine if the given path is writable.
  *
  * @param string $path
  * @return bool 
  * @static 
  */
 public static function isWritable($path)
 {
     return \Illuminate\Filesystem\Filesystem::isWritable($path);
 }

 /**
  * Helper to ensure attachment folder
  */
 protected function ensureAttachmentFolder()
 {
     $file = new Filesystem();
     // Ensure base folder
     if (!$file->isDirectory($this->directory)) {
         $file->makeDirectory($this->directory, 0777, true);
     }
     // Ensure media folder
     if (!$file->isDirectory($this->media_directory)) {
         $file->makeDirectory($this->media_directory, 0777, true);
     }
     if (!$file->isWritable($this->directory) || !$file->isWritable($this->media_directory)) {
         throw new RuntimeException('Invalid attachment directory');
     }
 }