WebDAVAdapter::isDirectory() - Code Metrics - Inspection of "Merge pull request #29 from miklcct/directory-fix" - thephpleague/flysystem-webdav - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d13e3c...db85f8 )

by Frank

created 2018-01-17 18:10 UTC

WebDAVAdapter::isDirectory() A

↳ Parent: WebDAVAdapter

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	2
eloc	2
nc	2
nop	1

<?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\HttpException;

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

    private static $metadataFields = [
        '{DAV:}displayname',
        '{DAV:}getcontentlength',
        '{DAV:}getcontenttype',
        '{DAV:}getlastmodified',
        '{DAV:}iscollection',
    ];

    /**
     * @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, self::$metadataFields);

            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 . '/', self::$metadataFields, 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 ($this->isDirectory($object)) {
            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;
    }

    private function isDirectory(array $object)
    {
        return isset($object['{DAV:}iscollection']) && $object['{DAV:}iscollection'] === '1';
    }
}


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\HttpException;
16
17			class WebDAVAdapter extends AbstractAdapter
18			{
19			use StreamedReadingTrait;
20			use StreamedCopyTrait {
21			StreamedCopyTrait::copy as streamedCopy;
22			}
23			use NotSupportingVisibilityTrait;
24
25			private static $metadataFields = [
26			'{DAV:}displayname',
27			'{DAV:}getcontentlength',
28			'{DAV:}getcontenttype',
29			'{DAV:}getlastmodified',
30			'{DAV:}iscollection',
31			];
32
33			/**
34			* @var array
35			*/
36			protected static $resultMap = [
37			'{DAV:}getcontentlength' => 'size',
38			'{DAV:}getcontenttype' => 'mimetype',
39			'content-length' => 'size',
40			'content-type' => 'mimetype',
41			];
42
43			/**
44			* @var Client
45			*/
46			protected $client;
47
48			/**
49			* @var bool
50			*/
51			protected $useStreamedCopy = true;
52
53			/**
54			* Constructor.
55			*
56			* @param Client $client
57			* @param string $prefix
58			* @param bool $useStreamedCopy
59			*/
60			public function __construct(Client $client, $prefix = null, $useStreamedCopy = true)
61			{
62			$this->client = $client;
63			$this->setPathPrefix($prefix);
64			$this->setUseStreamedCopy($useStreamedCopy);
65			}
66
67			/**
68			* url encode a path
69			*
70			* @param string $path
71			*
72			* @return string
73			*/
74			protected function encodePath($path)
75			{
76			$a = explode('/', $path);
77			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...
78			$a[$i] = rawurlencode($a[$i]);
79			}
80			return implode('/', $a);
81			}
82
83			/**
84			* {@inheritdoc}
85			*/
86			public function getMetadata($path)
87			{
88			$location = $this->applyPathPrefix($this->encodePath($path));
89
90			try {
91			$result = $this->client->propFind($location, self::$metadataFields);
92
93			return $this->normalizeObject($result, $path);
94			} catch (Exception $e) {
95			return false;
96			} catch (HttpException $e) {
97			return false;
98			}
99			}
100
101			/**
102			* {@inheritdoc}
103			*/
104			public function has($path)
105			{
106			return $this->getMetadata($path);
107			}
108
109			/**
110			* {@inheritdoc}
111			*/
112			public function read($path)
113			{
114			$location = $this->applyPathPrefix($this->encodePath($path));
115
116			try {
117			$response = $this->client->request('GET', $location);
118
119			if ($response['statusCode'] !== 200) {
120			return false;
121			}
122
123			return array_merge([
124			'contents' => $response['body'],
125			'timestamp' => strtotime(is_array($response['headers']['last-modified'])
126			? current($response['headers']['last-modified'])
127			: $response['headers']['last-modified']),
128			'path' => $path,
129			], Util::map($response['headers'], static::$resultMap));
130			} catch (Exception $e) {
131			return false;
132			}
133			}
134
135			/**
136			* {@inheritdoc}
137			*/
138			public function write($path, $contents, Config $config)
139			{
140			if (!$this->createDir(Util::dirname($path), $config)) {
141			return false;
142			}
143
144			$location = $this->applyPathPrefix($this->encodePath($path));
145			$response = $this->client->request('PUT', $location, $contents);
146
147			if ($response['statusCode'] >= 400) {
148			return false;
149			}
150
151			$result = compact('path', 'contents');
152
153			if ($config->get('visibility')) {
154			throw new LogicException(__CLASS__.' does not support visibility settings.');
155			}
156
157			return $result;
158			}
159
160			/**
161			* {@inheritdoc}
162			*/
163			public function writeStream($path, $resource, Config $config)
164			{
165			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...
166			}
167
168			/**
169			* {@inheritdoc}
170			*/
171			public function update($path, $contents, Config $config)
172			{
173			return $this->write($path, $contents, $config);
174			}
175
176			/**
177			* {@inheritdoc}
178			*/
179			public function updateStream($path, $resource, Config $config)
180			{
181			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...
182			}
183
184			/**
185			* {@inheritdoc}
186			*/
187			public function rename($path, $newpath)
188			{
189			$location = $this->applyPathPrefix($this->encodePath($path));
190			$newLocation = $this->applyPathPrefix($this->encodePath($newpath));
191
192			try {
193			$response = $this->client->request('MOVE', '/'.ltrim($location, '/'), null, [
194			'Destination' => '/'.ltrim($newLocation, '/'),
195			]);
196
197			if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
198			return true;
199			}
200			} catch (NotFound $e) {
201			// Would have returned false here, but would be redundant
202			}
203
204			return false;
205			}
206
207			/**
208			* {@inheritdoc}
209			*/
210			public function copy($path, $newpath)
211			{
212			if ($this->useStreamedCopy === true) {
213			return $this->streamedCopy($path, $newpath);
214			} else {
215			return $this->nativeCopy($path, $newpath);
216			}
217			}
218
219			/**
220			* {@inheritdoc}
221			*/
222			public function delete($path)
223			{
224			$location = $this->applyPathPrefix($this->encodePath($path));
225
226			try {
227			$this->client->request('DELETE', $location);
228
229			return true;
230			} catch (NotFound $e) {
231			return false;
232			}
233			}
234
235			/**
236			* {@inheritdoc}
237			*/
238			public function createDir($path, Config $config)
239			{
240			$encodedPath = $this->encodePath($path);
241			$path = trim($path, '/');
242
243			$result = compact('path') + ['type' => 'dir'];
244
245			if (Util::normalizeDirname($path) === '' \|\| $this->has($path)) {
246			return $result;
247			}
248
249			$directories = explode('/', $path);
250			if (count($directories) > 1) {
251			$parentDirectories = array_splice($directories, 0, count($directories) - 1);
252			if (!$this->createDir(implode('/', $parentDirectories), $config)) {
253			return false;
254			}
255			}
256
257			$location = $this->applyPathPrefix($encodedPath);
258			$response = $this->client->request('MKCOL', $location);
259
260			if ($response['statusCode'] !== 201) {
261			return false;
262			}
263
264			return $result;
265			}
266
267			/**
268			* {@inheritdoc}
269			*/
270			public function deleteDir($dirname)
271			{
272			return $this->delete($dirname);
273			}
274
275			/**
276			* {@inheritdoc}
277			*/
278			public function listContents($directory = '', $recursive = false)
279			{
280			$location = $this->applyPathPrefix($this->encodePath($directory));
281			$response = $this->client->propFind($location . '/', self::$metadataFields, 1);
282
283			array_shift($response);
284			$result = [];
285
286			foreach ($response as $path => $object) {
287			$path = urldecode($this->removePathPrefix($path));
288			$object = $this->normalizeObject($object, $path);
289			$result[] = $object;
290
291			if ($recursive && $object['type'] === 'dir') {
292			$result = array_merge($result, $this->listContents($object['path'], true));
293			}
294			}
295
296			return $result;
297			}
298
299			/**
300			* {@inheritdoc}
301			*/
302			public function getSize($path)
303			{
304			return $this->getMetadata($path);
305			}
306
307			/**
308			* {@inheritdoc}
309			*/
310			public function getTimestamp($path)
311			{
312			return $this->getMetadata($path);
313			}
314
315			/**
316			* {@inheritdoc}
317			*/
318			public function getMimetype($path)
319			{
320			return $this->getMetadata($path);
321			}
322
323			/**
324			* @return boolean
325			*/
326			public function getUseStreamedCopy()
327			{
328			return $this->useStreamedCopy;
329			}
330
331			/**
332			* @param boolean $useStreamedCopy
333			*/
334			public function setUseStreamedCopy($useStreamedCopy)
335			{
336			$this->useStreamedCopy = (bool)$useStreamedCopy;
337			}
338
339			/**
340			* Copy a file through WebDav COPY method.
341			*
342			* @param string $path
343			* @param string $newPath
344			*
345			* @return bool
346			*/
347			protected function nativeCopy($path, $newPath)
348			{
349			if (!$this->createDir(Util::dirname($newPath), new Config())) {
350			return false;
351			}
352
353			$location = $this->applyPathPrefix($this->encodePath($path));
354			$newLocation = $this->applyPathPrefix($this->encodePath($newPath));
355
356			try {
357			$destination = $this->client->getAbsoluteUrl($newLocation);
358			$response = $this->client->request('COPY', '/'.ltrim($location, '/'), null, [
359			'Destination' => $destination,
360			]);
361
362			if ($response['statusCode'] >= 200 && $response['statusCode'] < 300) {
363			return true;
364			}
365			} catch (NotFound $e) {
366			// Would have returned false here, but would be redundant
367			}
368
369			return false;
370			}
371
372			/**
373			* Normalise a WebDAV repsonse object.
374			*
375			* @param array $object
376			* @param string $path
377			*
378			* @return array
379			*/
380			protected function normalizeObject(array $object, $path)
381			{
382			if ($this->isDirectory($object)) {
383			return ['type' => 'dir', 'path' => trim($path, '/')];
384			}
385
386			$result = Util::map($object, static::$resultMap);
387
388			if (isset($object['{DAV:}getlastmodified'])) {
389			$result['timestamp'] = strtotime($object['{DAV:}getlastmodified']);
390			}
391
392			$result['type'] = 'file';
393			$result['path'] = trim($path, '/');
394
395			return $result;
396			}
397
398			private function isDirectory(array $object)
399			{
400			return isset($object['{DAV:}iscollection']) && $object['{DAV:}iscollection'] === '1';
401			}
402			}
403

thephpleague / flysystem-webdav

Push — master ( d13e3c...db85f8 )

WebDAVAdapter::isDirectory() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like