bytic / filesystem

src/FilesystemManager.php

<?php

namespace Nip\Filesystem;

use InvalidArgumentException;
use League\Flysystem\Local\LocalFilesystemAdapter as LocalAdapter;
use League\Flysystem\FilesystemAdapter;
use League\Flysystem\FilesystemOperator;
use Nip\Config\Config;

/**
 * Class FilesystemManager
 * @package Nip\Filesystem
 */
class FilesystemManager
{
    use FilesystemManager\HasCloudDriverTrait;
    use FilesystemManager\HasDisksTrait;

    /**
     * The application instance.
     *
     * @var \Nip\Application

The type Nip\Application was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected $app;

    /**
     * The registered custom driver creators.
     *
     * @var array
     */
    protected $customCreators = [];


    /**
     * Create a new filesystem manager instance.
     *
     * @param  \Nip\Application $app
     */
    public function __construct($app = null)
    {
        if ($app) {
            $this->app = $app;
        }
    }

    /**
     * Resolve the given disk.
     *
     * @param  string $name
     * @return FileDisk
     *
     * @throws \InvalidArgumentException
     */
    protected function resolve($name)
    {
        $config = $this->getConfig($name);
        if (empty($config)) {
            throw new InvalidArgumentException("No configuration found for Disk [{$name}].");
        }

        if (is_string($config)) {

The condition is_string($config) is always false.

            return $this->get($config);
        }

        if (isset($this->customCreators[$config['driver']])) {
            return $this->callCustomCreator($config);
        }
        $driverMethod = 'create'.ucfirst($config['driver']).'Driver';
        if (method_exists($this, $driverMethod)) {
            return $this->{$driverMethod}($config);
        } else {
            throw new InvalidArgumentException("Driver [{$config['driver']}] is not supported.");
        }
    }

    /**
     * Get the filesystem connection configuration.
     *
     * @param  string $name
     * @return array
     */
    protected function getConfig($name)
    {
        if (!function_exists('config')) {
            return null;
        }
        $config = config();
        $configName = "filesystems.disks.{$name}";
        if (!$config->has($configName)) {
            return null;
        }

        $value = $config->get($configName);

        return $value instanceof Config ? $value->toArray() : $value;

The expression return $value instanceof Nip\Config\Config ? $value->toArray() : $value also could return the type string which is incompatible with the documented return type array.

    }

    /**
     * Call a custom driver creator.
     *
     * @param  array $config
     * @return FileDisk
     */
    protected function callCustomCreator(array $config)
    {
        $driver = $this->customCreators[$config['driver']]($this->app, $config);
        if ($driver instanceof FilesystemOperator) {
            return $this->adapt($driver);
        }

        return $driver;
    }

    /**
     * Adapt the filesystem implementation.
     *
     * @param  \League\Flysystem\FilesystemOperator $filesystem
     * @return \League\Flysystem\FilesystemOperator|FileDisk
     */
    protected function adapt(FilesystemOperator $filesystem)
    {
        return $filesystem;
//        return new FlysystemAdapter($filesystem);
    }

    /**
     * Create an instance of the local driver.
     *
     * @param  array $config
     * @return \League\Flysystem\FilesystemOperator
     */
    public function createLocalDriver($config)
    {
        $permissions = $config['permissions'] ?? [];

The assignment to $permissions is dead and can be removed.

        $links = [];

The assignment to $links is dead and can be removed.

//        $links = Arr::get($config, 'links') === 'skip'
//            ? LocalAdapter::SKIP_LINKS
//            : LocalAdapter::DISALLOW_LINKS;

        return $this->adapt(
            $this->createDisk(
                new LocalAdapter(
                    $config['root'],
                    null,
                    LOCK_EX
//                    $links,
//                    $permissions
                ),
                $config
            )
        );
    }

    /**
     * Create a Flysystem instance with the given adapter.
     *
     * @param  \League\Flysystem\FilesystemAdapter $adapter
     * @param  array $config
     * @return FileDisk
     */
    protected function createDisk(FilesystemAdapter $adapter, $config)
    {
//        $config = Arr::only($config, ['visibility', 'disable_asserts', 'url']);
//        $this->checkForCacheNeeded($adapter, $config);

        return new FileDisk($adapter, count($config) > 0 ? $config : null);

It seems like count($config) > 0 ? $config : null can also be of type null; however, parameter $config of Nip\Filesystem\FileDisk::__construct() does only seem to accept array, maybe add an additional type check?

    }


    /**
     * Set the given disk instance.
     *
     * @param  string $name
     * @param  FileDisk $disk
     * @return void
     */
    public function set($name, $disk)
    {
        $this->disks[$name] = $disk;
    }

    /**
     * Get the default cloud driver name.
     *
     * @return string
     */
    public function getDefaultCloudDriver()
    {
        return config('filesystems.cloud');

The expression return config('filesystems.cloud') also could return the type Nip\Config\Config which is incompatible with the documented return type string.

    }
}