/**
* @dataProvider filesystemProvider
*/
public function testWrite(Filesystem $filesystem, $adapter, $cache)
{
$this->assertTrue($filesystem->write('some_file.txt', 'some content'));
$this->assertTrue($filesystem->has('some_file.txt'));
$this->assertTrue($cache->has('some_file.txt'));
$this->assertTrue($adapter->has('some_file.txt'));
$this->assertCount(1, $filesystem->listContents());
$this->assertCount(1, $cache->listContents('', false));
$this->assertCount(1, $adapter->listContents('', false));
$filesystem->rename('some_file.txt', 'other_name.txt');
$this->assertFalse($filesystem->has('some_file.txt'));
$this->assertFalse($cache->has('some_file.txt'));
$this->assertFalse($adapter->has('some_file.txt'));
$this->assertTrue($filesystem->has('other_name.txt'));
$this->assertTrue($cache->has('other_name.txt'));
$this->assertTrue($adapter->has('other_name.txt'));
$this->assertCount(1, $filesystem->listContents());
$this->assertCount(1, $cache->listContents('', false));
$this->assertCount(1, $adapter->listContents('', false));
$filesystem->delete('other_name.txt');
$this->assertFalse($filesystem->has('other_name.txt'));
$this->assertFalse($cache->has('other_name.txt'));
$this->assertFalse($adapter->has('other_name.txt'));
$this->assertCount(0, $filesystem->listContents());
$this->assertCount(0, $cache->listContents('', false));
$this->assertCount(0, $adapter->listContents('', false));
}
/**
* {@inheritdoc}
*/
public function rename($source, $target)
{
if ($this->file_exists($target)) {
$this->unlink($target);
}
return $this->flysystem->rename($this->buildPath($source), $this->buildPath($target));
}
/**
* @inheritdoc
*/
protected function _move($source, $target, $name)
{
$path = $this->_joinPath($target, $name);
if ($this->fs->rename($source, $path)) {
return $path;
}
return false;
}
/**
* @param $sourceFile
* @param $repoFile
*
* @return bool
*
*/
public function moveToRepo($sourceFile, $repoFile)
{
$filesystem = new Filesystem(new Adapter('/'));
if ($filesystem->has($repoFile)) {
$filesystem->delete($repoFile);
}
$result = $filesystem->rename($sourceFile, $repoFile);
unset($filesystem);
return $result;
}
public function testRename()
{
$old = 'old.txt';
$new = 'new.txt';
$this->prophecy->has($old)->willReturn(true);
$this->prophecy->has($new)->willReturn(false);
$this->prophecy->rename($old, $new)->willReturn(true);
$response = $this->filesystem->rename($old, $new);
$this->assertTrue($response);
}
/**
* @inheritdoc
*/
public function rename($path, $newPath)
{
$innerPath = $this->getInnerPath($path);
$newInnerPath = $this->getInnerPath($newPath);
try {
$return = $this->fileSystem->rename($innerPath, $newInnerPath);
} catch (FileNotFoundException $e) {
throw $this->exceptionWrapper($e, $path);
} catch (FileExistsException $e) {
throw $this->exceptionWrapper($e, $path);
}
if ($return !== false) {
$this->invokePlugin("addPathToIndex", [$newPath, $newInnerPath], $this);
$this->invokePlugin("removePathFromIndex", [$path, $innerPath], $this);
}
return $return;
}
/**
* Rename lessons, adding 0 padding to the number.
*/
public function renameLessonsWithRightPadding()
{
$list = $this->system->listContents(LESSONS_FOLDER);
foreach ($list as $entry) {
if ($entry['type'] != 'file') {
continue;
}
$originalName = $entry['basename'];
$oldNumber = substr($originalName, 0, strpos($originalName, '-'));
if (strlen($oldNumber) == 4) {
continue;
}
// already correct
$newNumber = sprintf("%04d", $oldNumber);
$nameWithoutNumber = substr($originalName, strpos($originalName, '-') + 1);
$newName = $newNumber . '-' . $nameWithoutNumber;
$this->system->rename(LESSONS_FOLDER . '/' . $originalName, LESSONS_FOLDER . '/' . $newName);
}
}
/**
* @param File[] $files
*
* @throws CanNotSavedException
*
* @return File[]
*/
public function save($files)
{
$fileSystemAdapter = $this->getAdapter();
$fileSystem = new Filesystem($fileSystemAdapter);
$savedFiles = [];
$i = 0;
foreach ($files as $file) {
$i++;
$filePath = $this->fileNameResolver->resolve(new \DateTime('now', new \DateTimeZone('UTC')), 'database', $file->getExtension());
$newBackupLocation = $this->backupFolder . '/' . $filePath;
$currBackupLocation = $file->getPath();
if ($fileSystem->has($newBackupLocation)) {
$fileSystem->delete($newBackupLocation);
}
if (!$fileSystem->rename($currBackupLocation, $newBackupLocation)) {
throw new CanNotSavedException();
}
$savedFiles[] = new File($fileSystemAdapter->applyPathPrefix($newBackupLocation));
}
return $savedFiles;
}
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);
}
/**
* Renames the object for a given path.
*
* @param string $path
* @param string $newpath
*
* @return bool `true` on success, `false` on failure.
*/
public function rename($path, $newpath)
{
$baseAdapter = $this->getBaseAdapter();
if ($baseAdapter instanceof EmulateRenameDirectoryInterface && $this->hasDirectory($path)) {
return $baseAdapter->renameDirectory($path, $newpath);
}
return parent::rename($path, $newpath);
}
/**
* Move a file to a new location.
*
* @param string $from
* @param string $to
* @return bool
*/
public function move($from, $to)
{
return parent::rename($from, $to);
}
/**
* @param string $path
* @param string $newPath
*
* @return bool
*/
public function rename($path, $newPath)
{
return $this->filesystem->rename($path, $newPath);
}
/**
* 3.txt
* 2.txt.
*/
public function testRename()
{
$this->assertTrue($this->filesystem->rename('1.txt', '3.txt'));
$this->assertFalse($this->filesystem->has('1.txt'));
$this->assertTrue($this->filesystem->has('3.txt'));
}
/**
* @param Payload $payload
* @param Messenger $messenger
* @return PromiseInterface
*/
public function rename(Payload $payload, Messenger $messenger)
{
return \React\Promise\resolve(['renamed' => $this->flysystem->rename($payload['from'], $payload['to'])]);
}
/**
* @inheritdoc
*/
public function rename($path, $newpath)
{
try {
return parent::rename($path, $newpath);
} catch (\Exception $e) {
$this->errors[] = $e->getMessage();
}
return false;
}
