QiniuAdapter::getSize() - Code Metrics - Inspection of "修复七牛云上传大文件失败的bug" - overtrue/flysystem-qiniu - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#14)

unknown

created 2018-12-03 07:37 UTC

QiniuAdapter::getSize() A

↳ Parent: QiniuAdapter

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?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\Cdn\CdnManager;
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;

    /**
     * @var \Qiniu\Cdn\CdnManager
     */
    protected $cdnManager;

    /**
     * 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,
            $path
        );

        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 (false === $response) {
            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).ltrim($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 (isset($result[0]['items']) ? $result[0]['items'] : [] 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 private file download url.
     *
     * @param string $path
     * @param int    $expires
     *
     * @return string
     */
    public function privateDownloadUrl($path, $expires = 3600)
    {
        $url = $this->getUrl($path);

        return  $this->getAuthManager()->privateDownloadUrl($url, $expires);
    }

    /**
     * Refresh file cache.
     *
     * @param string|array $path
     *
     * @return array
     */
    public function refresh($path)
    {
        if (is_string($path)) {
            $path = [$path];
        }

        // 将 $path 变成完整的 url
        $urls = array_map([$this, 'getUrl'], $path);

        return $this->getCdnManager()->refreshUrls($urls);
    }

    /**
     * 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;
    }

    /**
     * @param CdnManager $manager
     *
     * @return $this
     */
    public function setCdnManager(CdnManager $manager)
    {
        $this->cdnManager = $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();
    }

    /**
     * @return \Qiniu\Cdn\CdnManager
     */
    public function getCdnManager()
    {
        return $this->cdnManager ?: $this->cdnManager = new CdnManager($this->getAuthManager());
    }

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

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

// Instead of
acceptsInteger($x);

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

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

overtrue / flysystem-qiniu

Pull Request — master (#14)

QiniuAdapter::getSize() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like