PHP Filesystem::write方法代码示例

 /**
  * Write content into file. If file exists it will be overwritten.
  *
  * @param $path
  * @param $contents
  */
 public function write($path, $contents)
 {
     if ($this->filesystem->has($path)) {
         $this->remove($path);
     }
     $this->filesystem->write($path, $contents);
 }

 protected function write($data)
 {
     $destination = $this->composer->getClassPath($this->data['name']);
     if ($this->force && $this->external->has($destination)) {
         $this->external->delete($destination);
     }
     return $this->external->write($destination, $data);
 }

 protected function installParts()
 {
     $config = new \stdClass();
     foreach ($this->parts as $part) {
         $part->setupPackage($config, $this->filesystem);
     }
     $this->filesystem->write('composer.json', json_encode($config, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
 }

 /**
  * @return false|string
  */
 private function loadFile()
 {
     if (!$this->filesystem->has($this->getFile())) {
         $this->filesystem->write($this->getFile(), '');
     }
     if (!$this->sites) {
         $this->sites = $this->filesystem->read($this->file);
     }
     return $this->sites;
 }

 /**
  * @param File $file
  * @param Version $version
  * @param VersionProvider $versionProvider
  * @param Linker $linker
  * @return bool
  */
 public function publish(File $file, Version $version, VersionProvider $versionProvider, Linker $linker)
 {
     $path = $linker->getLink($file, $version, $versionProvider->getExtension($file, $version));
     $tmp = $this->storage->retrieveVersion($versionProvider->getApplicableVersionable($file), $version);
     if ($this->filesystem->has($path)) {
         return false;
     }
     $this->filesystem->write($path, file_get_contents($tmp), ['visibility' => AdapterInterface::VISIBILITY_PUBLIC]);
     return true;
 }

 /**
  * @param string $content
  * @param string $path
  * @return bool
  * @throws \InvalidArgumentException
  * @throws \League\Flysystem\FileNotFoundException
  */
 public function publish($content, $path = '')
 {
     if (empty($path)) {
         throw new \InvalidArgumentException('Path is mandatory!');
     }
     $config = new Config();
     try {
         return $this->storage->write($path, $content, $config);
     } catch (FileExistsException $e) {
         return $this->storage->update($path, $content, $config);
     }
 }

 public function convert($filePathIn, $filePathOut)
 {
     $replace = [];
     $replace['js_app'] = file_get_contents(__DIR__ . "/../../templates/{$this->usedTemplate}/" . "{$this->usedTemplate}.js");
     $replace['js_bootstrap'] = file_get_contents(self::PATH_DIST_BOOTSTRAP_JS);
     $replace['css_app'] = file_get_contents(__DIR__ . "/../../templates/{$this->usedTemplate}/" . "{$this->usedTemplate}.css");
     $replace['css_bootstrap'] = file_get_contents(self::PATH_DIST_BOOTSTRAP_CSS);
     $replace['content'] = $this->mdParser->parse(file_get_contents($filePathIn));
     $output['html'] = $this->latte->renderToString(__DIR__ . "/../../templates/{$this->usedTemplate}/" . "{$this->usedTemplate}.latte", $replace);
     $output['pdf'] = "@todo :)";
     $this->fs->write("{$filePathOut}.html", $output['html']);
     $this->fs->write("{$filePathOut}.pdf", $output['pdf']);
 }

 /**
  * @return bool
  */
 private function writeToFile()
 {
     $this->filesystem->write($this->file, $this->template);
     $this->out->writeln("Written endpoint wrapper to :" . $this->filesystem->get($this->file)->getPath());
     $this->out->writeln("Class " . $this->className . " is generated");
     return $this;
 }

    public function run()
    {
        $log = new Stream('php://stdout');
        /** @var Config $config */
        $config = Di::getDefault()->getShared('config');
        $expireDate = new DateTime('now', new DateTimeZone('UTC'));
        $expireDate->modify('+1 month');
        $baseUrl = rtrim($config->get('site')->url, '/');
        $content = <<<EOL
User-agent: *
Allow: /
Sitemap: {$baseUrl}/sitemap.xml
EOL;
        $adapter = new Local(dirname(dirname(__FILE__)) . '/public');
        $filesystem = new Filesystem($adapter);
        if ($filesystem->has('robots.txt')) {
            $result = $filesystem->update('robots.txt', $content);
        } else {
            $result = $filesystem->write('robots.txt', $content);
        }
        if ($result) {
            $log->info('The robots.txt was successfully updated');
        } else {
            $log->error('Failed to update the robots.txt file');
        }
    }

 public function write($path, $contents, array $config = [])
 {
     if (parent::write($path, $contents, $config)) {
         return $this->getAdapter()->getModel();
     } else {
         return false;
     }
 }

 /**
  * Write a new file.
  *
  * @param string $path     The path of the new file.
  * @param string $contents The file contents.
  * @param array  $config   An optional configuration array.
  *
  * @throws FileExistsException
  *
  * @return bool True on success, false on failure.
  */
 public function write($path, $contents, array $config = [])
 {
     $result = parent::write($path, $contents, $config);
     if ($result && ($resource = $this->get($path))) {
         return $this->dispatch(new SyncFile($resource));
     }
     return $result;
 }

 /**
  * Write a new file from File.
  *
  * @param File $file File object
  *
  * @throws FileExistsException
  *
  * @return bool True on success, false on failure.
  */
 public function writeFile(File $file)
 {
     try {
         return $this->filesystem->write($file->getDirectories() . $file->getFileName(), $file->getResource(), []);
     } catch (FlysystemFileExistsException $e) {
         FileExistsException::fileExists();
     }
 }

 /**
  * @inheritdoc
  */
 protected function _mkfile($path, $name)
 {
     $path = $this->_joinPath($path, $name);
     if ($this->fs->write($path, '')) {
         return $path;
     }
     return false;
 }

 protected function copyTo($file, Filesystem $target, $targetName = null, Closure $handler = null)
 {
     $targetName = $targetName ?: basename($file);
     $content = file_get_contents($file);
     if ($handler) {
         $content = $handler($content);
     }
     $target->write($targetName, $content);
 }

 /**
  * Create skip file to lessons
  */
 public function writeSkipSeries()
 {
     $file = SERIES_FOLDER . '/.skip';
     $series = serialize($this->getSeries());
     if ($this->system->has($file)) {
         $this->system->delete($file);
     }
     $this->system->write($file, $series);
 }