Spatie\FlysystemDropbox\DropboxAdapter

Complexity

Total Complexity

41

Size/Duplication

Total Lines	313
Duplicated Lines	19.49 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	write()	0	4	1
A	writeStream()	0	4	1
A	update()	0	4	1
A	updateStream()	0	4	1
A	rename()	0	13	2
A	copy()	13	13	2
A	delete()	0	12	2
A	deleteDir()	0	4	1
A	has()	0	4	1
A	read()	0	12	2
A	__construct()	0	6	1
A	createDir()	12	12	2
A	readStream()	12	12	2
C	listContents()	0	44	7
A	getMetadata()	12	12	2
A	getSize()	0	4	1
A	getMimetype()	0	4	1
A	getTimestamp()	0	4	1
A	getTemporaryLink()	0	4	1
A	getThumbnail()	0	4	1
A	applyPathPrefix()	0	6	1
A	getClient()	0	4	1
A	upload()	12	12	2
A	normalizeResponse()	0	19	4

<?php

namespace Spatie\FlysystemDropbox;

use LogicException;
use Spatie\Dropbox\Client;
use League\Flysystem\Config;
use Spatie\Dropbox\Exceptions\BadRequest;
use League\Flysystem\Adapter\AbstractAdapter;
use League\Flysystem\Adapter\Polyfill\NotSupportingVisibilityTrait;

class DropboxAdapter extends AbstractAdapter
{
    use NotSupportingVisibilityTrait;

    /** @var \Spatie\FlysystemDropbox\DropboxClient */
    protected $client;

    public function __construct(Client $client, string $prefix = '')
    {
        $this->client = $client;

It seems like $client of type object<Spatie\Dropbox\Client> is incompatible with the declared type object<Spatie\FlysystemDropbox\DropboxClient> of property $client.

        $this->setPathPrefix($prefix);
    }

    /**
     * {@inheritdoc}
     */
    public function write($path, $contents, Config $config)
    {
        return $this->upload($path, $contents, 'add');
    }

    /**
     * {@inheritdoc}
     */
    public function writeStream($path, $resource, Config $config)
    {
        return $this->upload($path, $resource, 'add');
    }

    /**
     * {@inheritdoc}
     */
    public function update($path, $contents, Config $config)
    {
        return $this->upload($path, $contents, 'overwrite');
    }

    /**
     * {@inheritdoc}
     */
    public function updateStream($path, $resource, Config $config)
    {
        return $this->upload($path, $resource, 'overwrite');
    }

    /**
     * {@inheritdoc}
     */
    public function rename($path, $newPath): bool
    {
        $path = $this->applyPathPrefix($path);
        $newPath = $this->applyPathPrefix($newPath);

        try {
            $this->client->move($path, $newPath);
        } catch (BadRequest $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function copy($path, $newpath): bool

This method seems to be duplicated in your project.

    {
        $path = $this->applyPathPrefix($path);
        $newpath = $this->applyPathPrefix($newpath);

        try {
            $this->client->copy($path, $newpath);
        } catch (BadRequest $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function delete($path): bool
    {
        $location = $this->applyPathPrefix($path);

        try {
            $this->client->delete($location);
        } catch (BadRequest $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function deleteDir($dirname): bool
    {
        return $this->delete($dirname);
    }

    /**
     * {@inheritdoc}
     */
    public function createDir($dirname, Config $config)

This method seems to be duplicated in your project.

    {
        $path = $this->applyPathPrefix($dirname);

        try {
            $object = $this->client->createFolder($path);
        } catch (BadRequest $e) {
            return false;
        }

        return $this->normalizeResponse($object);
    }

    /**
     * {@inheritdoc}
     */
    public function has($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * {@inheritdoc}
     */
    public function read($path)
    {
        if (! $object = $this->readStream($path)) {
            return false;
        }

        $object['contents'] = stream_get_contents($object['stream']);
        fclose($object['stream']);
        unset($object['stream']);

        return $object;
    }

    /**
     * {@inheritdoc}
     */
    public function readStream($path)

This method seems to be duplicated in your project.

    {
        $path = $this->applyPathPrefix($path);

        try {
            $stream = $this->client->download($path);
        } catch (BadRequest $e) {
            return false;
        }

        return compact('stream');
    }

    /**
     * {@inheritdoc}
     */
    public function listContents($directory = '', $recursive = false): array
    {
        $location = $this->applyPathPrefix($directory);

        $result = $this->client->listFolder($location, $recursive);

        if (! count($result['entries'])) {
            return [];
        }

        $cleanedPathDisplay = [];
        foreach ($result['entries'] as $item) {
            if ($item['.tag'] === 'folder') {
                $cleanedPathDisplay[$item['path_lower']] = $item['path_display'];

                $pathParts = explode('/', $item['path_lower']);
                do {
                    array_pop($pathParts);
                    $parentPathLower = implode('/', $pathParts);
                    if (!array_key_exists($parentPathLower, $cleanedPathDisplay)) {
                        $prefixedPath = $this->applyPathPrefix($parentPathLower);
                        $metadata = $this->client->getMetadata($prefixedPath);
                        $cleanedPathDisplay = [$metadata['path_lower'] => $metadata['path_display']] + $cleanedPathDisplay;
                    }
                } while (count($pathParts) > 2);
            }
        }

        $cleanedPathDisplay = array_reverse($cleanedPathDisplay);

        $result = array_map(function ($entry) use ($cleanedPathDisplay) {
            $path = $this->removePathPrefix($entry['path_display']);

            foreach ($cleanedPathDisplay as $pathLower => $pathDisplay) {
                $path = preg_replace('/^' . preg_quote($pathLower, '/') . '/i', $pathDisplay, $path);
            }

            $entry['path_display'] = $path;

            return $this->normalizeResponse($entry);
        }, $result['entries']);

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function getMetadata($path)

This method seems to be duplicated in your project.

    {
        $path = $this->applyPathPrefix($path);

        try {
            $object = $this->client->getMetadata($path);
        } catch (BadRequest $e) {
            return false;
        }

        return $this->normalizeResponse($object);
    }

    /**
     * {@inheritdoc}
     */
    public function getSize($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * {@inheritdoc}
     */
    public function getMimetype($path)
    {
        throw new LogicException("The Dropbox API v2 does not support mimetypes. Given path: `{$path}`.");
    }

    /**
     * {@inheritdoc}
     */
    public function getTimestamp($path)
    {
        return $this->getMetadata($path);
    }

    public function getTemporaryLink(string $path): string
    {
        return $this->client->getTemporaryLink($path);
    }

    public function getThumbnail(string $path, string $format = 'jpeg', string $size = 'w64h64')
    {
        return $this->client->getThumbnail($path, $format, $size);
    }

    /**
     * {@inheritdoc}
     */
    public function applyPathPrefix($path): string
    {
        $path = parent::applyPathPrefix($path);

        return '/'.trim($path, '/');
    }

    public function getClient(): Client
    {
        return $this->client;
    }

    /**
     * @param string $path
     * @param resource|string $contents
     * @param string $mode
     *
     * @return array|false file metadata
     */
    protected function upload(string $path, $contents, string $mode)

This method seems to be duplicated in your project.

    {
        $path = $this->applyPathPrefix($path);

        try {
            $object = $this->client->upload($path, $contents, $mode);
        } catch (BadRequest $e) {
            return false;
        }

        return $this->normalizeResponse($object);
    }

    protected function normalizeResponse(array $response): array
    {
        $normalizedPath = ltrim($this->removePathPrefix($response['path_display']), '/');

        $normalizedResponse = ['path' => $normalizedPath];

        if (isset($response['server_modified'])) {
            $normalizedResponse['timestamp'] = strtotime($response['server_modified']);
        }

        if (isset($response['size'])) {
            $normalizedResponse['bytes'] = $response['size'];
        }

        $type = ($response['.tag'] === 'folder' ? 'dir' : 'file');
        $normalizedResponse['type'] = $type;

        return $normalizedResponse;
    }
}