WebDAVAdapter - Code Metrics - Inspection of "Native copy and recursive directories creation" - thephpleague/flysystem-webdav - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#24)

unknown

created 2016-10-05 13:07 UTC

WebDAVAdapter B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	347
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

Metric	Value
wmc	47
lcom	1
cbo	7
dl	0
loc	347
rs	8.439
c	0
b	0
f	0

18 Methods

Rating	Name	Size	Complexity
A	__construct()	6	1
A	encodePath()	8	2
A	getMetadata()	19	3
A	has()	4	1
B	read()	22	4
A	write()	21	4
A	update()	4	1
A	rename()	19	4
A	copy()	8	2
A	delete()	12	2
C	createDir()	28	7
A	deleteDir()	4	1
B	listContents()	25	4
A	getSize()	4	1
A	getTimestamp()	4	1
A	getMimetype()	4	1
A	nativeCopy()	20	4
A	normalizeObject()	17	4

How to fix Complexity

<?php

namespace League\Flysystem\WebDAV;

use League\Flysystem\Adapter\AbstractAdapter;
use League\Flysystem\Adapter\Polyfill\NotSupportingVisibilityTrait;
use League\Flysystem\Adapter\Polyfill\StreamedCopyTrait;
use League\Flysystem\Adapter\Polyfill\StreamedTrait;
use League\Flysystem\Config;
use League\Flysystem\Util;
use LogicException;
use Sabre\DAV\Client;
use Sabre\DAV\Exception;
use Sabre\DAV\Exception\NotFound;
use Sabre\HTTP\ClientHttpException;
use Sabre\HTTP\HttpException;

class WebDAVAdapter extends AbstractAdapter
{
    use StreamedTrait;
    use StreamedCopyTrait {
        StreamedCopyTrait::copy as streamedCopy;
    }
    use NotSupportingVisibilityTrait;

    /**
     * @var array
     */
    protected static $resultMap = [
        '{DAV:}getcontentlength' => 'size',
        '{DAV:}getcontenttype' => 'mimetype',
        'content-length' => 'size',
        'content-type' => 'mimetype',
    ];

    /**
     * @var Client
     */
    protected $client;

    /**
     * @var bool
     */
    protected $useStreamedCopy = true;

    /**
     * Constructor.
     *
     * @param Client $client
     * @param string $prefix
     * @param bool $useStreamedCopy
     */
    public function __construct(Client $client, $prefix = null, $useStreamedCopy = true)
    {
        $this->client = $client;
        $this->setPathPrefix($prefix);
        $this->useStreamedCopy = $useStreamedCopy === true;
    }

    /**
     * url encode a path
     *
     * @param string $path
     *
     * @return string
     */
    protected function encodePath($path)
	{
		$a = explode('/', $path);
		for ($i=0; $i<count($a); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
			$a[$i] = rawurlencode($a[$i]);
		}
		return implode('/', $a);
	}

    /**
     * {@inheritdoc}
     */
    public function getMetadata($path)
    {
        $location = $this->applyPathPrefix($this->encodePath($path));

        try {
            $result = $this->client->propFind($location, [
                '{DAV:}displayname',
                '{DAV:}getcontentlength',
                '{DAV:}getcontenttype',
                '{DAV:}getlastmodified',
            ]);

            return $this->normalizeObject($result, $path);
        } catch (Exception $e) {
            return false;
        } catch (HttpException $e) {
            return false;
        }
    }

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

    /**
     * {@inheritdoc}
     */
    public function read($path)
    {
        $location = $this->applyPathPrefix($this->encodePath($path));

        try {
            $response = $this->client->request('GET', $location);

            if ($response['statusCode'] !== 200) {
                return false;
            }

            return array_merge([
                'contents' => $response['body'],
                'timestamp' => strtotime(is_array($response['headers']['last-modified'])
                    ? current($response['headers']['last-modified'])
                    : $response['headers']['last-modified']),
                'path' => $path,
            ], Util::map($response['headers'], static::$resultMap));
        } catch (Exception $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function write($path, $contents, Config $config)
    {
        if (!$this->createDir(dirname($path), $config)) {
            return false;
        }

        $location = $this->applyPathPrefix($this->encodePath($path));
        $response = $this->client->request('PUT', $location, $contents);

        if ($response['statusCode'] >= 400) {
            return false;
        }

        $result = compact('path', 'contents');

        if ($config->get('visibility')) {
            throw new LogicException(__CLASS__.' does not support visibility settings.');
        }

        return $result;
    }

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

    /**
     * {@inheritdoc}
     */
    public function rename($path, $newpath)
    {
        $location = $this->applyPathPrefix($this->encodePath($path));
        $newLocation = $this->applyPathPrefix($this->encodePath($newpath));

        try {
            $response = $this->client->request('MOVE', '/'.ltrim($location, '/'), null, [
                'Destination' => '/'.ltrim($newLocation, '/'),
            ]);

            if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
                return true;
            }
        } catch (NotFound $e) {
            // Would have returned false here, but would be redundant
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function copy($path, $newpath)
    {
        if ($this->useStreamedCopy === true) {
            return $this->streamedCopy($path, $newpath);
        } else {
            return $this->nativeCopy($path, $newpath);
        }
    }

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

        try {
            $this->client->request('DELETE', $location);

            return true;
        } catch (NotFound $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function createDir($path, Config $config)
    {
        $encodedPath = $this->encodePath($path);
        $path = trim($path, '/');

        $result = compact('path') + ['type' => 'dir'];

        if ($path === '' || $path === '.' || $this->has($path)) {
            return $result;
        }

        $directories = explode('/', $path);
        if (count($directories) > 1) {
            $parentDirectories = array_splice($directories, 0, count($directories) - 1);
            if (!$this->createDir(implode('/', $parentDirectories), $config)) {
                return false;
            }
        }

        $location = $this->applyPathPrefix($encodedPath);
        $response = $this->client->request('MKCOL', $location);

        if ($response['statusCode'] !== 201) {
            return false;
        }

        return $result;
    }

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

    /**
     * {@inheritdoc}
     */
    public function listContents($directory = '', $recursive = false)
    {
        $location = $this->applyPathPrefix($this->encodePath($directory));
        $response = $this->client->propFind($location . '/', [
            '{DAV:}displayname',
            '{DAV:}getcontentlength',
            '{DAV:}getcontenttype',
            '{DAV:}getlastmodified',
        ], 1);

        array_shift($response);
        $result = [];

        foreach ($response as $path => $object) {
            $path = urldecode($this->removePathPrefix($path));
            $object = $this->normalizeObject($object, $path);
            $result[] = $object;

            if ($recursive && $object['type'] === 'dir') {
                $result = array_merge($result, $this->listContents($object['path'], true));
            }
        }

        return $result;
    }

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

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

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

    /**
     * Copy a file through WebDav COPY method.
     *
     * @param string $path
     * @param string $newPath
     *
     * @return bool
     */
    protected function nativeCopy($path, $newPath)
    {
        $location = $this->applyPathPrefix($this->encodePath($path));
        $newLocation = $this->applyPathPrefix($this->encodePath($newPath));

        try {
            $destination = $this->client->getAbsoluteUrl($newLocation);
            $response = $this->client->request('COPY', '/'.ltrim($location, '/'), null, [
                'Destination' => $destination,
            ]);

            if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
                return true;
            }
        } catch (NotFound $e) {
            // Would have returned false here, but would be redundant
        }

        return false;
    }

    /**
     * Normalise a WebDAV repsonse object.
     *
     * @param array  $object
     * @param string $path
     *
     * @return array
     */
    protected function normalizeObject(array $object, $path)
    {
        if (! isset($object['{DAV:}getcontentlength']) or $object['{DAV:}getcontentlength'] == "") {
            return ['type' => 'dir', 'path' => trim($path, '/')];
        }

        $result = Util::map($object, static::$resultMap);

        if (isset($object['{DAV:}getlastmodified'])) {
            $result['timestamp'] = strtotime($object['{DAV:}getlastmodified']);
        }

        $result['type'] = 'file';
        $result['path'] = trim($path, '/');

        return $result;
    }
}


1			<?php
2
3			namespace League\Flysystem\WebDAV;
4
5			use League\Flysystem\Adapter\AbstractAdapter;
6			use League\Flysystem\Adapter\Polyfill\NotSupportingVisibilityTrait;
7			use League\Flysystem\Adapter\Polyfill\StreamedCopyTrait;
8			use League\Flysystem\Adapter\Polyfill\StreamedTrait;
9			use League\Flysystem\Config;
10			use League\Flysystem\Util;
11			use LogicException;
12			use Sabre\DAV\Client;
13			use Sabre\DAV\Exception;
14			use Sabre\DAV\Exception\NotFound;
15			use Sabre\HTTP\ClientHttpException;
16			use Sabre\HTTP\HttpException;
17
18			class WebDAVAdapter extends AbstractAdapter
19			{
20			use StreamedTrait;
21			use StreamedCopyTrait {
22			StreamedCopyTrait::copy as streamedCopy;
23			}
24			use NotSupportingVisibilityTrait;
25
26			/**
27			* @var array
28			*/
29			protected static $resultMap = [
30			'{DAV:}getcontentlength' => 'size',
31			'{DAV:}getcontenttype' => 'mimetype',
32			'content-length' => 'size',
33			'content-type' => 'mimetype',
34			];
35
36			/**
37			* @var Client
38			*/
39			protected $client;
40
41			/**
42			* @var bool
43			*/
44			protected $useStreamedCopy = true;
45
46			/**
47			* Constructor.
48			*
49			* @param Client $client
50			* @param string $prefix
51			* @param bool $useStreamedCopy
52			*/
53			public function __construct(Client $client, $prefix = null, $useStreamedCopy = true)
54			{
55			$this->client = $client;
56			$this->setPathPrefix($prefix);
57			$this->useStreamedCopy = $useStreamedCopy === true;
58			}
59
60			/**
61			* url encode a path
62			*
63			* @param string $path
64			*
65			* @return string
66			*/
67			protected function encodePath($path)
68			{
69			$a = explode('/', $path);
70			for ($i=0; $i<count($a); $i++) {
			0 ignored issues – show Performance Best Practice introduced 2016-05-22 16:06 UTC by Report Bug Copy Issue Report It seems like you are calling the size function `count()` as part of the test condition. You might want to compute the size beforehand, and not on each iteration. If the size of the collection does not change during the iteration, it is generally a good practice to compute it beforehand, and not on each iteration: for ($i=0; $i<count($array); $i++) { // calls count() on each iteration } // Better for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once } Loading history...
71			$a[$i] = rawurlencode($a[$i]);
72			}
73			return implode('/', $a);
74			}
75
76			/**
77			* {@inheritdoc}
78			*/
79			public function getMetadata($path)
80			{
81			$location = $this->applyPathPrefix($this->encodePath($path));
82
83			try {
84			$result = $this->client->propFind($location, [
85			'{DAV:}displayname',
86			'{DAV:}getcontentlength',
87			'{DAV:}getcontenttype',
88			'{DAV:}getlastmodified',
89			]);
90
91			return $this->normalizeObject($result, $path);
92			} catch (Exception $e) {
93			return false;
94			} catch (HttpException $e) {
95			return false;
96			}
97			}
98
99			/**
100			* {@inheritdoc}
101			*/
102			public function has($path)
103			{
104			return $this->getMetadata($path);
105			}
106
107			/**
108			* {@inheritdoc}
109			*/
110			public function read($path)
111			{
112			$location = $this->applyPathPrefix($this->encodePath($path));
113
114			try {
115			$response = $this->client->request('GET', $location);
116
117			if ($response['statusCode'] !== 200) {
118			return false;
119			}
120
121			return array_merge([
122			'contents' => $response['body'],
123			'timestamp' => strtotime(is_array($response['headers']['last-modified'])
124			? current($response['headers']['last-modified'])
125			: $response['headers']['last-modified']),
126			'path' => $path,
127			], Util::map($response['headers'], static::$resultMap));
128			} catch (Exception $e) {
129			return false;
130			}
131			}
132
133			/**
134			* {@inheritdoc}
135			*/
136			public function write($path, $contents, Config $config)
137			{
138			if (!$this->createDir(dirname($path), $config)) {
139			return false;
140			}
141
142			$location = $this->applyPathPrefix($this->encodePath($path));
143			$response = $this->client->request('PUT', $location, $contents);
144
145			if ($response['statusCode'] >= 400) {
146			return false;
147			}
148
149			$result = compact('path', 'contents');
150
151			if ($config->get('visibility')) {
152			throw new LogicException(__CLASS__.' does not support visibility settings.');
153			}
154
155			return $result;
156			}
157
158			/**
159			* {@inheritdoc}
160			*/
161			public function update($path, $contents, Config $config)
162			{
163			return $this->write($path, $contents, $config);
164			}
165
166			/**
167			* {@inheritdoc}
168			*/
169			public function rename($path, $newpath)
170			{
171			$location = $this->applyPathPrefix($this->encodePath($path));
172			$newLocation = $this->applyPathPrefix($this->encodePath($newpath));
173
174			try {
175			$response = $this->client->request('MOVE', '/'.ltrim($location, '/'), null, [
176			'Destination' => '/'.ltrim($newLocation, '/'),
177			]);
178
179			if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
180			return true;
181			}
182			} catch (NotFound $e) {
183			// Would have returned false here, but would be redundant
184			}
185
186			return false;
187			}
188
189			/**
190			* {@inheritdoc}
191			*/
192			public function copy($path, $newpath)
193			{
194			if ($this->useStreamedCopy === true) {
195			return $this->streamedCopy($path, $newpath);
196			} else {
197			return $this->nativeCopy($path, $newpath);
198			}
199			}
200
201			/**
202			* {@inheritdoc}
203			*/
204			public function delete($path)
205			{
206			$location = $this->applyPathPrefix($this->encodePath($path));
207
208			try {
209			$this->client->request('DELETE', $location);
210
211			return true;
212			} catch (NotFound $e) {
213			return false;
214			}
215			}
216
217			/**
218			* {@inheritdoc}
219			*/
220			public function createDir($path, Config $config)
221			{
222			$encodedPath = $this->encodePath($path);
223			$path = trim($path, '/');
224
225			$result = compact('path') + ['type' => 'dir'];
226
227			if ($path === '' \|\| $path === '.' \|\| $this->has($path)) {
228			return $result;
229			}
230
231			$directories = explode('/', $path);
232			if (count($directories) > 1) {
233			$parentDirectories = array_splice($directories, 0, count($directories) - 1);
234			if (!$this->createDir(implode('/', $parentDirectories), $config)) {
235			return false;
236			}
237			}
238
239			$location = $this->applyPathPrefix($encodedPath);
240			$response = $this->client->request('MKCOL', $location);
241
242			if ($response['statusCode'] !== 201) {
243			return false;
244			}
245
246			return $result;
247			}
248
249			/**
250			* {@inheritdoc}
251			*/
252			public function deleteDir($dirname)
253			{
254			return $this->delete($dirname);
255			}
256
257			/**
258			* {@inheritdoc}
259			*/
260			public function listContents($directory = '', $recursive = false)
261			{
262			$location = $this->applyPathPrefix($this->encodePath($directory));
263			$response = $this->client->propFind($location . '/', [
264			'{DAV:}displayname',
265			'{DAV:}getcontentlength',
266			'{DAV:}getcontenttype',
267			'{DAV:}getlastmodified',
268			], 1);
269
270			array_shift($response);
271			$result = [];
272
273			foreach ($response as $path => $object) {
274			$path = urldecode($this->removePathPrefix($path));
275			$object = $this->normalizeObject($object, $path);
276			$result[] = $object;
277
278			if ($recursive && $object['type'] === 'dir') {
279			$result = array_merge($result, $this->listContents($object['path'], true));
280			}
281			}
282
283			return $result;
284			}
285
286			/**
287			* {@inheritdoc}
288			*/
289			public function getSize($path)
290			{
291			return $this->getMetadata($path);
292			}
293
294			/**
295			* {@inheritdoc}
296			*/
297			public function getTimestamp($path)
298			{
299			return $this->getMetadata($path);
300			}
301
302			/**
303			* {@inheritdoc}
304			*/
305			public function getMimetype($path)
306			{
307			return $this->getMetadata($path);
308			}
309
310			/**
311			* Copy a file through WebDav COPY method.
312			*
313			* @param string $path
314			* @param string $newPath
315			*
316			* @return bool
317			*/
318			protected function nativeCopy($path, $newPath)
319			{
320			$location = $this->applyPathPrefix($this->encodePath($path));
321			$newLocation = $this->applyPathPrefix($this->encodePath($newPath));
322
323			try {
324			$destination = $this->client->getAbsoluteUrl($newLocation);
325			$response = $this->client->request('COPY', '/'.ltrim($location, '/'), null, [
326			'Destination' => $destination,
327			]);
328
329			if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
330			return true;
331			}
332			} catch (NotFound $e) {
333			// Would have returned false here, but would be redundant
334			}
335
336			return false;
337			}
338
339			/**
340			* Normalise a WebDAV repsonse object.
341			*
342			* @param array $object
343			* @param string $path
344			*
345			* @return array
346			*/
347			protected function normalizeObject(array $object, $path)
348			{
349			if (! isset($object['{DAV:}getcontentlength']) or $object['{DAV:}getcontentlength'] == "") {
350			return ['type' => 'dir', 'path' => trim($path, '/')];
351			}
352
353			$result = Util::map($object, static::$resultMap);
354
355			if (isset($object['{DAV:}getlastmodified'])) {
356			$result['timestamp'] = strtotime($object['{DAV:}getlastmodified']);
357			}
358
359			$result['type'] = 'file';
360			$result['path'] = trim($path, '/');
361
362			return $result;
363			}
364			}
365

thephpleague / flysystem-webdav

Pull Request — master (#24)

WebDAVAdapter B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

18 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like