ProtoneMedia\LaravelFFMpeg\Filesystem\Disk

Complexity

Total Complexity

22

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	isLocalDisk()	0	3	1
A	makeMedia()	0	3	1
A	getFilesystemAdapter()	0	11	3
A	getFlysystemDriver()	0	3	1
A	getName()	0	7	2
A	getFlysystemAdapter()	0	3	1
A	make()	0	7	2
A	getTemporaryDirectory()	0	7	2
A	makeTemporaryDisk()	0	7	1
A	clone()	0	3	1
A	__construct()	0	3	1
A	normalizePath()	0	12	3
A	__call()	0	3	1
A	path()	0	5	2

<?php

namespace ProtoneMedia\LaravelFFMpeg\Filesystem;

use Illuminate\Contracts\Filesystem\Filesystem;
use Illuminate\Filesystem\FilesystemAdapter;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Illuminate\Support\Traits\ForwardsCalls;
use League\Flysystem\Adapter\Local;
use League\Flysystem\AdapterInterface;
use League\Flysystem\Filesystem as LeagueFilesystem;
use League\Flysystem\Util;

/**
 * @mixin \Illuminate\Filesystem\FilesystemAdapter
 */
class Disk
{
    use ForwardsCalls;

    /**
     * @var string|\Illuminate\Contracts\Filesystem\Filesystem
     */
    private $disk;

    /**
     * @var string
     */
    private $temporaryDirectory;

    /**
     * @var \Illuminate\Filesystem\FilesystemAdapter
     */
    private $filesystemAdapter;

    public function __construct($disk)
    {
        $this->disk = $disk;
    }

    /**
     * Little helper method to instantiate this class.
     */
    public static function make($disk): self
    {
        if ($disk instanceof self) {
            return $disk;
        }

        return new static($disk);
    }

    public static function makeTemporaryDisk(): self
    {
        $filesystemAdapter = app('filesystem')->createLocalDriver([
            'root' => app(TemporaryDirectories::class)->create(),
        ]);

        return new static($filesystemAdapter);
    }

    /**
     * Creates a fresh instance, mostly used to force a new TemporaryDirectory.
     */
    public function clone(): self
    {
        return new Disk($this->disk);
    }

    /**
     * Creates a new TemporaryDirectory instance if none is set, otherwise
     * it returns the current one.
     */
    public function getTemporaryDirectory(): string
    {
        if ($this->temporaryDirectory) {
            return $this->temporaryDirectory;
        }

        return $this->temporaryDirectory = app(TemporaryDirectories::class)->create();
    }

    public function makeMedia(string $path): Media
    {
        return Media::make($this, $path);
    }

    /**
     * Returns the name of the disk. It generates a name if the disk
     * is an instance of Flysystem.
     */
    public function getName(): string
    {
        if (is_string($this->disk)) {
            return $this->disk;
        }

        return get_class($this->getFlysystemAdapter()) . "_" . md5(json_encode(serialize($this->getFlysystemAdapter())));
    }

    public function getFilesystemAdapter(): FilesystemAdapter
    {
        if ($this->filesystemAdapter) {
            return $this->filesystemAdapter;
        }

        if ($this->disk instanceof Filesystem) {
            return $this->filesystemAdapter = $this->disk;

$this->disk is of type Illuminate\Contracts\Filesystem\Filesystem, but the property $filesystemAdapter was declared to be of type Illuminate\Filesystem\FilesystemAdapter. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        }

        return $this->filesystemAdapter = Storage::disk($this->disk);
    }

    private function getFlysystemDriver(): LeagueFilesystem
    {
        return $this->getFilesystemAdapter()->getDriver();
    }

    private function getFlysystemAdapter(): AdapterInterface
    {
        return $this->getFlysystemDriver()->getAdapter();
    }

    public function isLocalDisk(): bool
    {
        return $this->getFlysystemAdapter() instanceof Local;
    }

    public static function normalizePath($path): string
    {
        return str_replace('\\', '/', $path);

        $normalizedPath = Util::normalizePath($path);

$normalizedPath = League\Flysystem\Util::normalizePath($path) is not reachable.

        // reapply the starting slash
        if (Str::startsWith($path, '/') && !Str::startsWith($normalizedPath, '/')) {
            return "/{$normalizedPath}";
        }

        return $normalizedPath;
    }

    /**
     * Get the full path for the file at the given "short" path.
     *
     * @param  string  $path
     * @return string
     */
    public function path(string $path): string
    {
        $path = $this->getFilesystemAdapter()->path($path);

        return $this->isLocalDisk() ? static::normalizePath($path) : $path;
    }

    /**
     * Forwards all calls to Laravel's FilesystemAdapter which will pass
     * dynamic methods call onto Flysystem.
     */
    public function __call($method, $parameters)
    {
        return $this->forwardCallTo($this->getFilesystemAdapter(), $method, $parameters);
    }
}