WebDAVAdapter - Code Metrics - Inspection of "Merge pull request #36 from crhg/streamed_writing" - thephpleague/flysystem-webdav - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5fb6f5...d13e3c )

by Frank

created 2018-01-17 18:09 UTC

WebDAVAdapter B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	383
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

Metric	Value
wmc	51
lcom	1
cbo	7
dl	0
loc	383
rs	8.3206
c	0
b	0
f	0

22 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	writeStream()	4	1
A	update()	4	1
A	updateStream()	4	1
A	rename()	19	4
A	copy()	8	2
A	delete()	12	2
B	createDir()	28	6
A	deleteDir()	4	1
B	listContents()	25	4
A	getSize()	4	1
A	getTimestamp()	4	1
A	getMimetype()	4	1
A	getUseStreamedCopy()	4	1
A	setUseStreamedCopy()	4	1
B	nativeCopy()	24	5
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\StreamedReadingTrait;
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 StreamedReadingTrait;
    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->setUseStreamedCopy($useStreamedCopy);
    }

    /**
     * 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(Util::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 writeStream($path, $resource, Config $config)
    {
        return $this->write($path, $resource, $config);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

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

    /**
     * {@inheritdoc}
     */
    public function updateStream($path, $resource, Config $config)
    {
        return $this->update($path, $resource, $config);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * {@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 (Util::normalizeDirname($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);
    }

    /**
     * @return boolean
     */
    public function getUseStreamedCopy()
    {
        return $this->useStreamedCopy;
    }

    /**
     * @param boolean $useStreamedCopy
     */
    public function setUseStreamedCopy($useStreamedCopy)
    {
        $this->useStreamedCopy = (bool)$useStreamedCopy;
    }

    /**
     * Copy a file through WebDav COPY method.
     *
     * @param string $path
     * @param string $newPath
     *
     * @return bool
     */
    protected function nativeCopy($path, $newPath)
    {
        if (!$this->createDir(Util::dirname($newPath), new Config())) {
            return false;
        }

        $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\StreamedReadingTrait;
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 StreamedReadingTrait;
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->setUseStreamedCopy($useStreamedCopy);
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(Util::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 writeStream($path, $resource, Config $config)
162			{
163			return $this->write($path, $resource, $config);
			0 ignored issues – show Documentation introduced 2017-11-07 01:09 UTC by Report Bug Copy Issue Report `$resource` is of type `resource`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
164			}
165
166			/**
167			* {@inheritdoc}
168			*/
169			public function update($path, $contents, Config $config)
170			{
171			return $this->write($path, $contents, $config);
172			}
173
174			/**
175			* {@inheritdoc}
176			*/
177			public function updateStream($path, $resource, Config $config)
178			{
179			return $this->update($path, $resource, $config);
			0 ignored issues – show Documentation introduced 2017-11-07 01:09 UTC by Report Bug Copy Issue Report `$resource` is of type `resource`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
180			}
181
182			/**
183			* {@inheritdoc}
184			*/
185			public function rename($path, $newpath)
186			{
187			$location = $this->applyPathPrefix($this->encodePath($path));
188			$newLocation = $this->applyPathPrefix($this->encodePath($newpath));
189
190			try {
191			$response = $this->client->request('MOVE', '/'.ltrim($location, '/'), null, [
192			'Destination' => '/'.ltrim($newLocation, '/'),
193			]);
194
195			if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
196			return true;
197			}
198			} catch (NotFound $e) {
199			// Would have returned false here, but would be redundant
200			}
201
202			return false;
203			}
204
205			/**
206			* {@inheritdoc}
207			*/
208			public function copy($path, $newpath)
209			{
210			if ($this->useStreamedCopy === true) {
211			return $this->streamedCopy($path, $newpath);
212			} else {
213			return $this->nativeCopy($path, $newpath);
214			}
215			}
216
217			/**
218			* {@inheritdoc}
219			*/
220			public function delete($path)
221			{
222			$location = $this->applyPathPrefix($this->encodePath($path));
223
224			try {
225			$this->client->request('DELETE', $location);
226
227			return true;
228			} catch (NotFound $e) {
229			return false;
230			}
231			}
232
233			/**
234			* {@inheritdoc}
235			*/
236			public function createDir($path, Config $config)
237			{
238			$encodedPath = $this->encodePath($path);
239			$path = trim($path, '/');
240
241			$result = compact('path') + ['type' => 'dir'];
242
243			if (Util::normalizeDirname($path) === '' \|\| $this->has($path)) {
244			return $result;
245			}
246
247			$directories = explode('/', $path);
248			if (count($directories) > 1) {
249			$parentDirectories = array_splice($directories, 0, count($directories) - 1);
250			if (!$this->createDir(implode('/', $parentDirectories), $config)) {
251			return false;
252			}
253			}
254
255			$location = $this->applyPathPrefix($encodedPath);
256			$response = $this->client->request('MKCOL', $location);
257
258			if ($response['statusCode'] !== 201) {
259			return false;
260			}
261
262			return $result;
263			}
264
265			/**
266			* {@inheritdoc}
267			*/
268			public function deleteDir($dirname)
269			{
270			return $this->delete($dirname);
271			}
272
273			/**
274			* {@inheritdoc}
275			*/
276			public function listContents($directory = '', $recursive = false)
277			{
278			$location = $this->applyPathPrefix($this->encodePath($directory));
279			$response = $this->client->propFind($location . '/', [
280			'{DAV:}displayname',
281			'{DAV:}getcontentlength',
282			'{DAV:}getcontenttype',
283			'{DAV:}getlastmodified',
284			], 1);
285
286			array_shift($response);
287			$result = [];
288
289			foreach ($response as $path => $object) {
290			$path = urldecode($this->removePathPrefix($path));
291			$object = $this->normalizeObject($object, $path);
292			$result[] = $object;
293
294			if ($recursive && $object['type'] === 'dir') {
295			$result = array_merge($result, $this->listContents($object['path'], true));
296			}
297			}
298
299			return $result;
300			}
301
302			/**
303			* {@inheritdoc}
304			*/
305			public function getSize($path)
306			{
307			return $this->getMetadata($path);
308			}
309
310			/**
311			* {@inheritdoc}
312			*/
313			public function getTimestamp($path)
314			{
315			return $this->getMetadata($path);
316			}
317
318			/**
319			* {@inheritdoc}
320			*/
321			public function getMimetype($path)
322			{
323			return $this->getMetadata($path);
324			}
325
326			/**
327			* @return boolean
328			*/
329			public function getUseStreamedCopy()
330			{
331			return $this->useStreamedCopy;
332			}
333
334			/**
335			* @param boolean $useStreamedCopy
336			*/
337			public function setUseStreamedCopy($useStreamedCopy)
338			{
339			$this->useStreamedCopy = (bool)$useStreamedCopy;
340			}
341
342			/**
343			* Copy a file through WebDav COPY method.
344			*
345			* @param string $path
346			* @param string $newPath
347			*
348			* @return bool
349			*/
350			protected function nativeCopy($path, $newPath)
351			{
352			if (!$this->createDir(Util::dirname($newPath), new Config())) {
353			return false;
354			}
355
356			$location = $this->applyPathPrefix($this->encodePath($path));
357			$newLocation = $this->applyPathPrefix($this->encodePath($newPath));
358
359			try {
360			$destination = $this->client->getAbsoluteUrl($newLocation);
361			$response = $this->client->request('COPY', '/'.ltrim($location, '/'), null, [
362			'Destination' => $destination,
363			]);
364
365			if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
366			return true;
367			}
368			} catch (NotFound $e) {
369			// Would have returned false here, but would be redundant
370			}
371
372			return false;
373			}
374
375			/**
376			* Normalise a WebDAV repsonse object.
377			*
378			* @param array $object
379			* @param string $path
380			*
381			* @return array
382			*/
383			protected function normalizeObject(array $object, $path)
384			{
385			if (! isset($object['{DAV:}getcontentlength']) or $object['{DAV:}getcontentlength'] == "") {
386			return ['type' => 'dir', 'path' => trim($path, '/')];
387			}
388
389			$result = Util::map($object, static::$resultMap);
390
391			if (isset($object['{DAV:}getlastmodified'])) {
392			$result['timestamp'] = strtotime($object['{DAV:}getlastmodified']);
393			}
394
395			$result['type'] = 'file';
396			$result['path'] = trim($path, '/');
397
398			return $result;
399			}
400			}
401

thephpleague / flysystem-webdav

Push — master ( 5fb6f5...d13e3c )

WebDAVAdapter B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

22 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like