QiniuAdapter::fetch() - Code Metrics - Inspection of "Merge pull request #8 from RobberPhex/fetch-and-30..." - overtrue/flysystem-qiniu - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( da854f...7450e6 )

by Carlos

created 2017-08-23 02:39 UTC

QiniuAdapter::fetch() A

↳ Parent: QiniuAdapter

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	10
ccs	0
cts	5
cp	0
rs	9.4285
cc	2
eloc	5
nc	2
nop	2
crap	6

<?php

/*
 * This file is part of the overtrue/flysystem-qiniu.
 * (c) overtrue <[email protected]>
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Overtrue\Flysystem\Qiniu;

use League\Flysystem\Adapter\AbstractAdapter;
use League\Flysystem\Adapter\Polyfill\NotSupportingVisibilityTrait;
use League\Flysystem\Config;
use Qiniu\Auth;
use Qiniu\Storage\BucketManager;
use Qiniu\Storage\UploadManager;

/**
 * Class QiniuAdapter.
 *
 * @author overtrue <[email protected]>
 */
class QiniuAdapter extends AbstractAdapter
{
    use NotSupportingVisibilityTrait;

    /**
     * @var string
     */
    protected $accessKey;

    /**
     * @var string
     */
    protected $secretKey;

    /**
     * @var string
     */
    protected $bucket;

    /**
     * @var string
     */
    protected $domain;

    /**
     * @var \Qiniu\Auth
     */
    protected $authManager;

    /**
     * @var \Qiniu\Storage\UploadManager
     */
    protected $uploadManager;

    /**
     * @var \Qiniu\Storage\BucketManager
     */
    protected $bucketManager;

    /**
     * QiniuAdapter constructor.
     *
     * @param string $accessKey
     * @param string $secretKey
     * @param string $bucket
     * @param string $domain
     */
    public function __construct($accessKey, $secretKey, $bucket, $domain)
    {
        $this->accessKey = $accessKey;
        $this->secretKey = $secretKey;
        $this->bucket = $bucket;
        $this->domain = $domain;
    }

    /**
     * Write a new file.
     *
     * @param string $path
     * @param string $contents
     * @param Config $config   Config object
     *
     * @return array|false false on failure file meta data on success
     */
    public function write($path, $contents, Config $config)
    {
        $mime = 'application/octet-stream';

        if ($config->has('mime')) {
            $mime = $config->get('mime');
        }

        list($response, $error) = $this->getUploadManager()->put(
            $this->getAuthManager()->uploadToken($this->bucket),
            $path,
            $contents,
            null,
            $mime
        );

        if ($error) {
            return false;
        }

        return $response;
    }

    /**
     * Write a new file using a stream.
     *
     * @param string   $path
     * @param resource $resource
     * @param Config   $config   Config object
     *
     * @return array|false false on failure file meta data on success
     */
    public function writeStream($path, $resource, Config $config)
    {
        $contents = '';

        while (!feof($resource)) {
            $contents .= fread($resource, 1024);
        }

        $response = $this->write($path, $contents, $config);

        if ($response === false) {
            return $response;
        }

        return compact('path');
    }

    /**
     * Update a file.
     *
     * @param string $path
     * @param string $contents
     * @param Config $config   Config object
     *
     * @return array|false false on failure file meta data on success
     */
    public function update($path, $contents, Config $config)
    {
        $this->delete($path);

        return $this->write($path, $contents, $config);
    }

    /**
     * Update a file using a stream.
     *
     * @param string   $path
     * @param resource $resource
     * @param Config   $config   Config object
     *
     * @return array|false false on failure file meta data on success
     */
    public function updateStream($path, $resource, Config $config)
    {
        $this->delete($path);

        return $this->writeStream($path, $resource, $config);
    }

    /**
     * Rename a file.
     *
     * @param string $path
     * @param string $newPath
     *
     * @return bool
     */
    public function rename($path, $newPath)
    {
        $response = $this->getBucketManager()->rename($this->bucket, $path, $newPath);

        return is_null($response);
    }

    /**
     * Copy a file.
     *
     * @param string $path
     * @param string $newPath
     *
     * @return bool
     */
    public function copy($path, $newPath)
    {
        $response = $this->getBucketManager()->copy($this->bucket, $path, $this->bucket, $newPath);

        return is_null($response);
    }

    /**
     * Delete a file.
     *
     * @param string $path
     *
     * @return bool
     */
    public function delete($path)
    {
        $response = $this->getBucketManager()->delete($this->bucket, $path);

        return is_null($response);
    }

    /**
     * Delete a directory.
     *
     * @param string $directory
     *
     * @return bool
     */
    public function deleteDir($directory)
    {
        return true;
    }

    /**
     * Create a directory.
     *
     * @param string $directory directory name
     * @param Config $config
     *
     * @return array|false
     */
    public function createDir($directory, Config $config)
    {
        return ['path' => $directory, 'type' => 'dir'];
    }

    /**
     * Check whether a file exists.
     *
     * @param string $path
     *
     * @return array|bool|null
     */
    public function has($path)
    {
        list($response, $error) = $this->getBucketManager()->stat($this->bucket, $path);

        return !$error || is_array($response);
    }

    /**
     * Get resource url.
     *
     * @param string $path
     *
     * @return string
     */
    public function getUrl($path)
    {
        return $this->normalizeHost($this->domain).$path;
    }

    /**
     * Read a file.
     *
     * @param string $path
     *
     * @return array|false
     */
    public function read($path)
    {
        $contents = file_get_contents($this->getUrl($path));

        return compact('contents', 'path');
    }

    /**
     * Read a file as a stream.
     *
     * @param string $path
     *
     * @return array|false
     */
    public function readStream($path)
    {
        if (ini_get('allow_url_fopen')) {
            $stream = fopen($this->normalizeHost($this->domain).$path, 'r');

            return compact('stream', 'path');
        }

        return false;
    }

    /**
     * List contents of a directory.
     *
     * @param string $directory
     * @param bool   $recursive
     *
     * @return array
     */
    public function listContents($directory = '', $recursive = false)
    {
        $list = [];

        $result = $this->getBucketManager()->listFiles($this->bucket, $directory);

        foreach ($result[0] as $files) {
            $list[] = $this->normalizeFileInfo($files);
        }

        return $list;
    }

    /**
     * Get all the meta data of a file or directory.
     *
     * @param string $path
     *
     * @return array|false
     */
    public function getMetadata($path)
    {
        $result = $this->getBucketManager()->stat($this->bucket, $path);
        $result[0]['key'] = $path;

        return $this->normalizeFileInfo($result[0]);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    /**
     * Get the size of a file.
     *
     * @param string $path
     *
     * @return array|false
     */
    public function getSize($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * Fetch url to bucket.
     *
     * @param string $path
     * @param string $url
     *
     * @return array|false
     */
    public function fetch($path, $url)
    {
        list($response, $error) = $this->getBucketManager()->fetch($url, $this->bucket, $path);

        if ($error) {
            return false;
        }

        return $response;
    }

    /**
     * Get the mime-type of a file.
     *
     * @param string $path
     *
     * @return array|false
     */
    public function getMimeType($path)
    {
        $response = $this->getBucketManager()->stat($this->bucket, $path);

        if (empty($response[0]['mimeType'])) {
            return false;
        }

        return ['mimetype' => $response[0]['mimeType']];
    }

    /**
     * Get the timestamp of a file.
     *
     * @param string $path
     *
     * @return array|false
     */
    public function getTimestamp($path)
    {
        return $this->getMetadata($path);
    }

    /**
     * @param \Qiniu\Storage\BucketManager $manager
     *
     * @return $this
     */
    public function setBucketManager(BucketManager $manager)
    {
        $this->bucketManager = $manager;

        return $this;
    }

    /**
     * @param \Qiniu\Storage\UploadManager $manager
     *
     * @return $this
     */
    public function setUploadManager(UploadManager $manager)
    {
        $this->uploadManager = $manager;

        return $this;
    }

    /**
     * @param \Qiniu\Auth $manager
     *
     * @return $this
     */
    public function setAuthManager(Auth $manager)
    {
        $this->authManager = $manager;

        return $this;
    }

    /**
     * @return \Qiniu\Storage\BucketManager
     */
    public function getBucketManager()
    {
        return $this->bucketManager ?: $this->bucketManager = new BucketManager($this->getAuthManager());
    }

    /**
     * @return \Qiniu\Auth
     */
    public function getAuthManager()
    {
        return $this->authManager ?: $this->authManager = new Auth($this->accessKey, $this->secretKey);
    }

    /**
     * @return \Qiniu\Storage\UploadManager
     */
    public function getUploadManager()
    {
        return $this->uploadManager ?: $this->uploadManager = new UploadManager();
    }

    /**
     * Get the upload token.
     *
     * @param string|null $key
     * @param int         $expires
     * @param bool        $policy
     *
     * @return string
     */
    public function getUploadToken($key = null, $expires = 3600, $policy = true)
    {
        return $this->getAuthManager()->uploadToken($this->bucket, $key, $expires, $policy);
    }

    /**
     * @param array $stats
     *
     * @return array
     */
    protected function normalizeFileInfo(array $stats)
    {
        return [
            'type' => 'file',
            'path' => $stats['key'],
            'timestamp' => floor($stats['putTime'] / 10000000),
            'size' => $stats['fsize'],
        ];
    }

    /**
     * @param string $domain
     *
     * @return string
     */
    protected function normalizeHost($domain)
    {
        if (0 !== stripos($domain, 'https://') && 0 !== stripos($domain, 'http://')) {
            $domain = "http://{$domain}";
        }

        return rtrim($domain, '/').'/';
    }
}


1		<?php
2
3		/*
4		* This file is part of the overtrue/flysystem-qiniu.
5		* (c) overtrue <[email protected]>
6		* This source file is subject to the MIT license that is bundled
7		* with this source code in the file LICENSE.
8		*/
9
10		namespace Overtrue\Flysystem\Qiniu;
11
12		use League\Flysystem\Adapter\AbstractAdapter;
13		use League\Flysystem\Adapter\Polyfill\NotSupportingVisibilityTrait;
14		use League\Flysystem\Config;
15		use Qiniu\Auth;
16		use Qiniu\Storage\BucketManager;
17		use Qiniu\Storage\UploadManager;
18
19		/**
20		* Class QiniuAdapter.
21		*
22		* @author overtrue <[email protected]>
23		*/
24		class QiniuAdapter extends AbstractAdapter
25		{
26		use NotSupportingVisibilityTrait;
27
28		/**
29		* @var string
30		*/
31		protected $accessKey;
32
33		/**
34		* @var string
35		*/
36		protected $secretKey;
37
38		/**
39		* @var string
40		*/
41		protected $bucket;
42
43		/**
44		* @var string
45		*/
46		protected $domain;
47
48		/**
49		* @var \Qiniu\Auth
50		*/
51		protected $authManager;
52
53		/**
54		* @var \Qiniu\Storage\UploadManager
55		*/
56		protected $uploadManager;
57
58		/**
59		* @var \Qiniu\Storage\BucketManager
60		*/
61		protected $bucketManager;
62
63		/**
64		* QiniuAdapter constructor.
65		*
66		* @param string $accessKey
67		* @param string $secretKey
68		* @param string $bucket
69		* @param string $domain
70		*/
71	1	public function __construct($accessKey, $secretKey, $bucket, $domain)
72		{
73	1	$this->accessKey = $accessKey;
74	1	$this->secretKey = $secretKey;
75	1	$this->bucket = $bucket;
76	1	$this->domain = $domain;
77	1	}
78
79		/**
80		* Write a new file.
81		*
82		* @param string $path
83		* @param string $contents
84		* @param Config $config Config object
85		*
86		* @return array\|false false on failure file meta data on success
87		*/
88	2	public function write($path, $contents, Config $config)
89		{
90	2	$mime = 'application/octet-stream';
91
92	2	if ($config->has('mime')) {
93	1	$mime = $config->get('mime');
94	1	}
95
96	2	list($response, $error) = $this->getUploadManager()->put(
97	2	$this->getAuthManager()->uploadToken($this->bucket),
98	2	$path,
99	2	$contents,
100	2	null,
101		$mime
102	2	);
103
104	2	if ($error) {
105	2	return false;
106		}
107
108	2	return $response;
109		}
110
111		/**
112		* Write a new file using a stream.
113		*
114		* @param string $path
115		* @param resource $resource
116		* @param Config $config Config object
117		*
118		* @return array\|false false on failure file meta data on success
119		*/
120	1	public function writeStream($path, $resource, Config $config)
121		{
122	1	$contents = '';
123
124	1	while (!feof($resource)) {
125	1	$contents .= fread($resource, 1024);
126	1	}
127
128	1	$response = $this->write($path, $contents, $config);
129
130	1	if ($response === false) {
131	1	return $response;
132		}
133
134	1	return compact('path');
135		}
136
137		/**
138		* Update a file.
139		*
140		* @param string $path
141		* @param string $contents
142		* @param Config $config Config object
143		*
144		* @return array\|false false on failure file meta data on success
145		*/
146	1	public function update($path, $contents, Config $config)
147		{
148	1	$this->delete($path);
149
150	1	return $this->write($path, $contents, $config);
151		}
152
153		/**
154		* Update a file using a stream.
155		*
156		* @param string $path
157		* @param resource $resource
158		* @param Config $config Config object
159		*
160		* @return array\|false false on failure file meta data on success
161		*/
162	1	public function updateStream($path, $resource, Config $config)
163		{
164	1	$this->delete($path);
165
166	1	return $this->writeStream($path, $resource, $config);
167		}
168
169		/**
170		* Rename a file.
171		*
172		* @param string $path
173		* @param string $newPath
174		*
175		* @return bool
176		*/
177	1	public function rename($path, $newPath)
178		{
179	1	$response = $this->getBucketManager()->rename($this->bucket, $path, $newPath);
180
181	1	return is_null($response);
182		}
183
184		/**
185		* Copy a file.
186		*
187		* @param string $path
188		* @param string $newPath
189		*
190		* @return bool
191		*/
192	1	public function copy($path, $newPath)
193		{
194	1	$response = $this->getBucketManager()->copy($this->bucket, $path, $this->bucket, $newPath);
195
196	1	return is_null($response);
197		}
198
199		/**
200		* Delete a file.
201		*
202		* @param string $path
203		*
204		* @return bool
205		*/
206	1	public function delete($path)
207		{
208	1	$response = $this->getBucketManager()->delete($this->bucket, $path);
209
210	1	return is_null($response);
211		}
212
213		/**
214		* Delete a directory.
215		*
216		* @param string $directory
217		*
218		* @return bool
219		*/
220	1	public function deleteDir($directory)
221		{
222	1	return true;
223		}
224
225		/**
226		* Create a directory.
227		*
228		* @param string $directory directory name
229		* @param Config $config
230		*
231		* @return array\|false
232		*/
233	1	public function createDir($directory, Config $config)
234		{
235	1	return ['path' => $directory, 'type' => 'dir'];
236		}
237
238		/**
239		* Check whether a file exists.
240		*
241		* @param string $path
242		*
243		* @return array\|bool\|null
244		*/
245	1	public function has($path)
246		{
247	1	list($response, $error) = $this->getBucketManager()->stat($this->bucket, $path);
248
249	1	return !$error \|\| is_array($response);
250		}
251
252		/**
253		* Get resource url.
254		*
255		* @param string $path
256		*
257		* @return string
258		*/
259	1	public function getUrl($path)
260		{
261	1	return $this->normalizeHost($this->domain).$path;
262		}
263
264		/**
265		* Read a file.
266		*
267		* @param string $path
268		*
269		* @return array\|false
270		*/
271	1	public function read($path)
272		{
273	1	$contents = file_get_contents($this->getUrl($path));
274
275	1	return compact('contents', 'path');
276		}
277
278		/**
279		* Read a file as a stream.
280		*
281		* @param string $path
282		*
283		* @return array\|false
284		*/
285	1	public function readStream($path)
286		{
287	1	if (ini_get('allow_url_fopen')) {
288	1	$stream = fopen($this->normalizeHost($this->domain).$path, 'r');
289
290	1	return compact('stream', 'path');
291		}
292
293	1	return false;
294		}
295
296		/**
297		* List contents of a directory.
298		*
299		* @param string $directory
300		* @param bool $recursive
301		*
302		* @return array
303		*/
304	1	public function listContents($directory = '', $recursive = false)
305		{
306	1	$list = [];
307
308	1	$result = $this->getBucketManager()->listFiles($this->bucket, $directory);
309
310	1	foreach ($result[0] as $files) {
311	1	$list[] = $this->normalizeFileInfo($files);
312	1	}
313
314	1	return $list;
315		}
316
317		/**
318		* Get all the meta data of a file or directory.
319		*
320		* @param string $path
321		*
322		* @return array\|false
323		*/
324	1	public function getMetadata($path)
325		{
326	1	$result = $this->getBucketManager()->stat($this->bucket, $path);
327	1	$result[0]['key'] = $path;
328
329	1	return $this->normalizeFileInfo($result[0]);
		0 ignored issues – show Documentation introduced 2017-07-17 09:23 UTC by Report Bug Copy Issue Report `$result[0]` is of type `null\|object<Qiniu\Http\Error>`, but the function expects a `array`. 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...
330		}
331
332		/**
333		* Get the size of a file.
334		*
335		* @param string $path
336		*
337		* @return array\|false
338		*/
339	1	public function getSize($path)
340		{
341	1	return $this->getMetadata($path);
342		}
343
344		/**
345		* Fetch url to bucket.
346		*
347		* @param string $path
348		* @param string $url
349		*
350		* @return array\|false
351		*/
352		public function fetch($path, $url)
353		{
354		list($response, $error) = $this->getBucketManager()->fetch($url, $this->bucket, $path);
355
356		if ($error) {
357		return false;
358		}
359
360		return $response;
361		}
362
363		/**
364		* Get the mime-type of a file.
365		*
366		* @param string $path
367		*
368		* @return array\|false
369		*/
370	1	public function getMimeType($path)
371		{
372	1	$response = $this->getBucketManager()->stat($this->bucket, $path);
373
374	1	if (empty($response[0]['mimeType'])) {
375	1	return false;
376		}
377
378	1	return ['mimetype' => $response[0]['mimeType']];
379		}
380
381		/**
382		* Get the timestamp of a file.
383		*
384		* @param string $path
385		*
386		* @return array\|false
387		*/
388	1	public function getTimestamp($path)
389		{
390	1	return $this->getMetadata($path);
391		}
392
393		/**
394		* @param \Qiniu\Storage\BucketManager $manager
395		*
396		* @return $this
397		*/
398	1	public function setBucketManager(BucketManager $manager)
399		{
400	1	$this->bucketManager = $manager;
401
402	1	return $this;
403		}
404
405		/**
406		* @param \Qiniu\Storage\UploadManager $manager
407		*
408		* @return $this
409		*/
410	1	public function setUploadManager(UploadManager $manager)
411		{
412	1	$this->uploadManager = $manager;
413
414	1	return $this;
415		}
416
417		/**
418		* @param \Qiniu\Auth $manager
419		*
420		* @return $this
421		*/
422	1	public function setAuthManager(Auth $manager)
423		{
424	1	$this->authManager = $manager;
425
426	1	return $this;
427		}
428
429		/**
430		* @return \Qiniu\Storage\BucketManager
431		*/
432	1	public function getBucketManager()
433		{
434	1	return $this->bucketManager ?: $this->bucketManager = new BucketManager($this->getAuthManager());
435		}
436
437		/**
438		* @return \Qiniu\Auth
439		*/
440	1	public function getAuthManager()
441		{
442	1	return $this->authManager ?: $this->authManager = new Auth($this->accessKey, $this->secretKey);
443		}
444
445		/**
446		* @return \Qiniu\Storage\UploadManager
447		*/
448	1	public function getUploadManager()
449		{
450	1	return $this->uploadManager ?: $this->uploadManager = new UploadManager();
451		}
452
453		/**
454		* Get the upload token.
455		*
456		* @param string\|null $key
457		* @param int $expires
458		* @param bool $policy
459		*
460		* @return string
461		*/
462	1	public function getUploadToken($key = null, $expires = 3600, $policy = true)
463		{
464	1	return $this->getAuthManager()->uploadToken($this->bucket, $key, $expires, $policy);
465		}
466
467		/**
468		* @param array $stats
469		*
470		* @return array
471		*/
472	2	protected function normalizeFileInfo(array $stats)
473		{
474		return [
475	2	'type' => 'file',
476	2	'path' => $stats['key'],
477	2	'timestamp' => floor($stats['putTime'] / 10000000),
478	2	'size' => $stats['fsize'],
479	2	];
480		}
481
482		/**
483		* @param string $domain
484		*
485		* @return string
486		*/
487	2	protected function normalizeHost($domain)
488		{
489	2	if (0 !== stripos($domain, 'https://') && 0 !== stripos($domain, 'http://')) {
490	2	$domain = "http://{$domain}";
491	2	}
492
493	2	return rtrim($domain, '/').'/';
494		}
495		}
496

overtrue / flysystem-qiniu

Push — master ( da854f...7450e6 )

QiniuAdapter::fetch() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like