Fly.php

Go to the documentation of this file.

<?php

namespace Elgg\Filesystem\Directory;

use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Exceptions\RuntimeException;
use Elgg\Filesystem\Directory;
use Elgg\Filesystem\File;
use Elgg\Structs\Collection;
use League\Flysystem\Local\LocalFilesystemAdapter as LocalAdapter;
use League\Flysystem\Filesystem;
use League\Flysystem\InMemory\InMemoryFilesystemAdapter;

final class Fly implements Directory {

    private $fs;

    private $local_path;

    private $chroot;

    public function __construct(Filesystem $filesystem, $local_path = '', $chroot = '') {
        $this->fs = $filesystem;
        $this->local_path = rtrim(strtr($local_path, '\\', '/'), '/\\');
        $this->chroot = $this->normalize($chroot);
    }

    public function chroot($path) {
        return new self($this->fs, $this->local_path, $path);
    }

    private function isDirectory($path) {
        $path = $this->getInternalPath($path);
        return !empty($this->fs->listContents($path)->toArray());
    }

    public function isFile($path) {
        return $this->fs->fileExists($this->getInternalPath($path));
    }

    public function getContents($path) {
        return (string) $this->fs->read($this->getInternalPath($path));
    }

    public function getFile($path) {
        if ($this->isDirectory($path)) {
            throw new RuntimeException("There is already a directory at that location: {$path}");
        }

        return new File($this, $path);
    }

    public function getFiles($path = '', $recursive = true) {
        return $this->getEntries($path, $recursive, ['file']);
    }

    public function getDirectories($path = '', $recursive = true) {
        return $this->getEntries($path, $recursive, ['dir']);
    }

    protected function getEntries($path = '', $recursive = true, $types = ['file', 'dir']) {
        $contents = $this->fs->listContents($this->getInternalPath($path), $recursive)->toArray();
        if (empty($contents)) {
            $contents = [];
        }

        $contents = array_filter($contents, function ($metadata) use ($types) {
            return in_array($metadata['type'], $types);
        });

        return Collection\InMemory::fromArray(array_map(function ($metadata) {
            if ($metadata['type'] === 'file') {
                return new File($this, $metadata['path']);
            }

            return new self($this->fs, $this->local_path, $metadata['path']);
        }, $contents));
    }

    public function getPath($path = '') {
        $path = $this->normalize($this->getInternalPath($path));
        return "{$this->local_path}/$path";
    }

    private function getInternalPath($path) {
        $path = strtr($path, '\\', '//');
        return $this->normalize("{$this->chroot}/$path");
    }

    public function includeFile($path) {
        return include $this->getPath($path);
    }

    public function putContents($path, $content) {
        $this->fs->write($this->getInternalPath($path), $content);
    }

    public static function createLocal($path) {
        $fs = new Filesystem(new LocalAdapter($path));
        return new self($fs, $path);
    }

    public static function createInMemory() {
        $fs = new Filesystem(new InMemoryFilesystemAdapter());
        return new self($fs);
    }

    private function normalize($path) {
        $test_path = "/{$path}/";
        if (str_contains($test_path, '/./') || str_contains($test_path, '/../')) {
            throw new InvalidArgumentException('Paths cannot contain "." or ".."');
        }

        return trim(strtr($path, '\\', '/'), '/');
    }
}