Dazzle\Filesystem\Driver\DriverStandard

Complexity

Total Complexity

12

Size/Duplication

Total Lines	117
Duplicated Lines	13.68 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

0%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	stat()	0	11	2
A	chmod()	0	6	1
A	chown()	0	6	1
A	call()	0	15	3
A	getPath()	0	4	1
A	createConfiguration()	8	8	1
A	createInvoker()	8	8	2

<?php

namespace Dazzle\Filesystem\Driver;

use Dazzle\Filesystem\Invoker\InvokerInterface;
use Dazzle\Filesystem\Invoker\InvokerStandard;
use Dazzle\Loop\LoopInterface;
use Dazzle\Promise\Promise;
use Error;
use Exception;

class DriverStandard extends DriverAbstract implements DriverInterface
{
    /**
     * @var InvokerInterface
     */
    protected $invoker;

    /**
     * @param LoopInterface $loop
     * @param array $options
     */
    public function __construct(LoopInterface $loop, $options = [])
    {
        $this->loop = $loop;
        $this->options = $this->createConfiguration($options);
        $this->invoker = $this->createInvoker();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function stat($path)
    {
        return $this->invoker
            ->call('stat', [ $this->getPath($path) ])
            ->then(function($stat) {
                return $stat ? array_filter($stat, function($statKey) {
                    return !is_numeric($statKey);
                }, ARRAY_FILTER_USE_KEY) : $stat;
            })
            ->then([ $this, 'handleStat' ]);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function chmod($path, $mode)
    {
        return $this->invoker
            ->call('chmod', [ $this->getPath($path), decoct($mode) ])
            ->then([ $this, 'handleChmod' ]);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function chown($path, $uid = -1, $gid = -1)
    {
        return $this->invoker
            ->call('chown', [ $this->getPath($path), $uid, $gid ])
            ->then([ $this, 'handleChown' ]);
    }

    /**
     * @internal
     * @override
     * @inheritDoc
     */
    public function call($func, $args = [])
    {
        try
        {
            return Promise::doResolve(@$func(...$args));
        }
        catch (Error $ex)
        {
            return Promise::doReject($ex);
        }
        catch (Exception $ex)
        {
            return Promise::doReject($ex);
        }
    }

    /**
     * Get path.
     *
     * @param string $path
     * @return string
     */
    protected function getPath($path)
    {
        return $this->options['root'] . '/' . ltrim($path, '/');
    }

    /**
     * Create valid configuration for the driver.
     *
     * @param array $options
     * @return array
     */
    protected function createConfiguration($options = [])

This method seems to be duplicated in your project.

    {
        return array_merge([
            'root' => '',
            'invoker.class' => InvokerStandard::class,
            'output.control' => false,
        ], $options);
    }

    /**
     * Create invoker for the driver.
     *
     * @return InvokerInterface
     */
    protected function createInvoker()

This method seems to be duplicated in your project.

    {
        $invoker = class_exists($this->options['invoker.class'])
            ? $this->options['invoker.class']
            : InvokerStandard::class
        ;
        return new $invoker($this);
    }
}