/** * @param $filePath * @param $toBeDownloadedFileName * * @return int */ public function downloadAttachment($filePath, $toBeDownloadedFileName = '') { if (!is_readable($this->currentPath . $filePath)) { $this->setError(self::ERROR_ATTACHMENT_FILE_DOES_NOT_EXIST); } if (empty($toBeDownloadedFileName)) { $toBeDownloadedFileName = basename($filePath); if (empty($toBeDownloadedFileName)) { $this->setError(self::ERROR_ATTACHMENT_DOES_NOT_EXIST); } } if ($this->hasError()) { return $this->errors; } $this->setHeadersForAttachmentDownload($toBeDownloadedFileName); if ($this->fileSystem->getSize($filePath) > DirectoryStructure::FS_DOWNLOAD_STREAM_AFTER_SIZE) { header('Content-Length: ' . $this->fileSystem->getSize($filePath)); $stream = $this->fileSystem->readStream($filePath); while (!feof($stream)) { print fgets($stream, 1024); flush(); } fclose($stream); exit; } else { ob_start(); ob_start("ob_gzhandler"); echo $this->fileSystem->get($filePath)->read(); ob_end_flush(); $gzippedContent = ob_get_contents(); // store gzipped content to get size header('Content-Length: ' . strlen($gzippedContent)); ob_end_flush(); exit; } }
protected function execute(InputInterface $input, OutputInterface $output) { $file = $input->getArgument("file"); $list = array_filter($this->filesystem->listContents($file, true), function ($file) { return isset($file['type']) and ($file['type'] === "file" and isset($file['extension']) and $file['extension'] === "php"); }); // If the file argument is not directory, the listContents will return empty array. // In this case the user has specified a file if (empty($list)) { $list = [["path" => $this->filesystem->get($file)->getPath()]]; } $dump = array_map(function ($file) use($output) { $output->writeln("Indexing " . $file['path'] . "..."); return Indexer::index($this->filesystem->get($file['path'])); }, $list); $table = new Table($output); $outputs = []; foreach ($dump as $a) { foreach ($a["functions"] as $val) { $outputs[] = [$val['file']->getPath(), $val['function'], implode(", ", array_map(function ($param) { return implode('|', $param['type']) . " " . $param['name']; }, $val['arguments'])), implode(", ", $val['return']), (string) $val['scope']]; } } $output->writeln("Indexing complete!"); $output->writeln("Scanned " . count($list) . " files."); $output->writeln("Detected " . count($outputs) . " functions."); $output->writeln("Rendering Table..."); $table->setHeaders(['File', 'Function', 'Arguments', 'Return', 'Scope'])->setRows($outputs); $table->render(); }
public function retrieveVersion(Versionable $versionable, Version $version) { $ret = $this->filesystem->get($this->getVersionPathName($versionable, $version)); if (!$ret) { throw new FileIOException(sprintf("Failed to retrieve version '%s' of versionable %s;%s", $version->toString(), get_class($versionable), $versionable->getId())); } return new Retrieved($this->tempFiles->add($ret->read())); }
/** * Returns file handle from OC * @param $path * * @return bool|File */ public function getFile($path) { $file = $this->fs->get($path); if ($file instanceof File) { return $file; } return false; }
public function load() { $composer = json_decode($this->filesystem->get('composer.json')->read(), true); if (!isset($composer['autoload']['psr-4']) || empty($composer['autoload']['psr-4'])) { throw new RuntimeException('Unable to detect namespace. Ensure you have PSR4 autoloading setup in your composer.json'); } $namespace = array_keys($composer['autoload']['psr-4'])[0]; $path = $composer['autoload']['psr-4'][$namespace]; $this->namespace = Utils::removeTrailingSlashes($namespace); $this->path = Utils::removeTrailingSlashes($path); }
/** * Checks if the underlying flysystem contains a file of the given name. * * @param string $name * * @return \League\Flysystem\File|\League\Flysystem\Handler * @throws Twig_Error_Loader */ protected function getFileOrFail($name) { if (!$this->filesystem->has($this->resolveTemplateName($name))) { throw new Twig_Error_Loader('Template could not be found on the given filesystem'); } $fileObject = $this->filesystem->get($this->resolveTemplateName($name)); if ($fileObject->isDir()) { throw new Twig_Error_Loader('Cannot use directory as template'); } return $fileObject; }
/** * @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 testGetDirectory() { $path = 'path'; $this->prophecy->has($path)->willReturn(true); $this->prophecy->getMetadata($path)->willReturn(['path' => $path, 'type' => 'dir']); $output = $this->filesystem->get($path); $this->assertInstanceOf('League\\Flysystem\\Directory', $output); }
public function upload(FileInterface $file, $name, $path = null) { $path = is_null($path) ? $name : sprintf('%s/%s', $path, $name); if ($file instanceof FlysystemFile) { if ($file->getFilesystem() == $this->filesystem) { $file->getFilesystem()->rename($file->getPath(), $path); return new FlysystemFile($this->filesystem->get($path), $this->filesystem, $this->streamWrapperPrefix); } } $this->filesystem->put($name, file_get_contents($file)); if ($file instanceof FlysystemFile) { $file->delete(); } else { $filesystem = new LocalFilesystem(); $filesystem->remove($file->getPathname()); } return new FlysystemFile($this->filesystem->get($path), $this->filesystem, $this->streamWrapperPrefix); }
public function upload(FileInterface $file, $name, $path = null) { $path = is_null($path) ? $name : sprintf('%s/%s', $path, $name); if ($file instanceof FlysystemFile) { if ($file->getFilesystem() == $this->filesystem) { $file->getFilesystem()->rename($file->getPath(), $path); return new FlysystemFile($this->filesystem->get($path), $this->filesystem, $this->streamWrapperPrefix); } } $stream = fopen($file->getPathname(), 'r+'); $this->filesystem->putStream($name, $stream); if (is_resource($stream)) { fclose($stream); } if ($file instanceof FlysystemFile) { $file->delete(); } else { $filesystem = new LocalFilesystem(); $filesystem->remove($file->getPathname()); } return new FlysystemFile($this->filesystem->get($path), $this->filesystem, $this->streamWrapperPrefix); }
public function assembleChunks($chunks, $removeChunk, $renameChunk) { // the index is only added to be in sync with the filesystem storage $path = $this->prefix . '/' . $this->unhandledChunk['uuid'] . '/'; $filename = $this->unhandledChunk['index'] . '_' . $this->unhandledChunk['original']; if (empty($chunks)) { $target = $filename; } else { sort($chunks, SORT_STRING | SORT_FLAG_CASE); $target = pathinfo($chunks[0], PATHINFO_BASENAME); } if ($this->unhandledChunk['index'] === 0) { // if it's the first chunk overwrite the already existing part // to avoid appending to earlier failed uploads $handle = fopen($path . '/' . $target, 'w'); } else { $handle = fopen($path . '/' . $target, 'a'); } $this->filesystem->putStream($path . $target, $handle); if ($renameChunk) { $name = preg_replace('/^(\\d+)_/', '', $target); /* The name can only match if the same user in the same session is * trying to upload a file under the same name AND the previous upload failed, * somewhere between this function, and the cleanup call. If that happened * the previous file is unaccessible by the user, but if it is not removed * it will block the user from trying to re-upload it. */ if ($this->filesystem->has($path . $name)) { $this->filesystem->delete($path . $name); } $this->filesystem->rename($path . $target, $path . $name); $target = $name; } $uploaded = $this->filesystem->get($path . $target); if (!$renameChunk) { return $uploaded; } return new FlysystemFile($uploaded, $this->filesystem, $this->streamWrapperPrefix); }
/** * {@inheritDoc} */ public function get($path, Handler $handler = null) { return parent::get($path, new File($this, $path)); }
/** @inheritDoc */ public function isFile($path) { $path = $this->getInternalPath($path); return $this->fs->has($path) && $this->fs->get($path)->isFile(); }
/** * @inheritdoc */ public function get($path, Handler $handler = null) { return $this->fileSystem->get($this->getInnerPath($path), $handler); }
<?php require __DIR__ . "/vendor/autoload.php"; use Elphp\Component\DocTypeParser\DocParamTypeParser; use Elphp\Component\Indexer\BasicFunctionIndexer; use Elphp\Component\Indexer\BasicVariableIndexer; use Elphp\Component\Indexer\ScopeResolvedNodes; use Elphp\Component\ScopeResolver\NodeVisitor\ScopeResolver; use PhpParser\Comment; use PhpParser\Error; use PhpParser\Node; use phpDocumentor\Reflection\DocBlock; use PhpParser\Node\FunctionLike; use PhpParser\NodeTraverser; use PhpParser\ParserFactory; use League\Flysystem\Filesystem; use League\Flysystem\Adapter\Local; $adapter = new Local(__DIR__ . '/'); $filesystem = new Filesystem($adapter); $lexer = new PhpParser\Lexer(array('usedAttributes' => array('comments', 'startLine', 'endLine', 'startFilePos', 'endFilePos'))); $parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7, $lexer); $traverser = new NodeTraverser(); $traverser->addVisitor(new ScopeResolver()); $file = $filesystem->get("code.php"); $code = $file->read(); $stmts = $parser->parse($code); $stmts = $traverser->traverse($stmts); var_dump((new BasicVariableIndexer($file, new ScopeResolvedNodes($stmts)))->index()->getArrayCopy());
public function prepare($template, $data = []) { $template = $this->internal->get($template)->read(); return $this->engine->render($template, $data); }
/** * @test */ public function it_creates_the_license_file() { $this->generator->make(); $result = $this->file->get('LICENSE.txt')->exists(); $this->assertTrue($result); }