GoogleCloudStorage - Code Metrics - Inspection of "Modify Google Cloud Storage Adapter to work with v..." - KnpLabs/Gaufrette - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 787bbd...13cd31 )

by Albin

created 2017-03-02 12:27 UTC

GoogleCloudStorage B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	372
Duplicated Lines	15.32 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

Metric	Value
wmc	46
lcom	1
cbo	9
dl	57
loc	372
rs	8.3999
c	0
b	0
f	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	18	18	1
A	getOptions()	0	4	1
A	setOptions()	0	4	1
A	getBucket()	0	4	1
A	setBucket()	0	4	1
B	read()	0	32	5
D	write()	0	65	10
A	exists()	13	13	2
A	keys()	0	4	1
A	mtime()	0	9	2
A	delete()	13	13	2
A	rename()	0	20	3
A	isDirectory()	0	8	2
B	listKeys()	5	29	4
A	setMetadata()	0	6	1
A	getMetadata()	0	6	2
A	ensureBucketExists()	0	22	3
A	computePath()	8	8	2
A	getObjectData()	0	8	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like GoogleCloudStorage often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use GoogleCloudStorage, and based on these observations, apply Extract Interface, too.

<?php

namespace Gaufrette\Adapter;

use Gaufrette\Adapter;
use GuzzleHttp;

/**
 * Google Cloud Storage adapter using the Google APIs Client Library for PHP.
 *
 * @author  Patrik Karisch <[email protected]>
 */
class GoogleCloudStorage implements Adapter,

                                    MetadataSupporter,

                                    ListKeysAware

{
    protected $service;
    protected $bucket;
    protected $options;
    protected $bucketExists;
    protected $metadata = array();
    protected $detectContentType;

    /**
     * @param \Google_Service_Storage $service           The storage service class with authenticated
     *                                                   client and full access scope
     * @param string                  $bucket            The bucket name
     * @param array                   $options           Options can be directory and acl
     * @param bool                    $detectContentType Whether to detect the content type or not
     */
    public function __construct(

        \Google_Service_Storage $service,
        $bucket,
        array $options = array(),
        $detectContentType = false
    ) {
        $this->service = $service;
        $this->bucket = $bucket;
        $this->options = array_replace(
            array(
                'directory' => '',
                'acl' => 'private',
            ),
            $options
        );

        $this->detectContentType = $detectContentType;
    }

    /**
     * @return array The actual options
     */
    public function getOptions()
    {
        return $this->options;
    }

    /**
     * @param array $options The new options
     */
    public function setOptions($options)
    {
        $this->options = array_replace($this->options, $options);
    }

    /**
     * @return string The current bucket name
     */
    public function getBucket()
    {
        return $this->bucket;
    }

    /**
     * Sets a new bucket name.
     *
     * @param string $bucket The new bucket name
     */
    public function setBucket($bucket)
    {
        $this->bucket = $bucket;
    }

    /**
     * {@inheritdoc}
     */
    public function read($key)
    {
        $this->ensureBucketExists();
        $path = $this->computePath($key);

        $object = $this->getObjectData($path);
        if ($object === false) {
            return false;
        }

        if (class_exists('Google_Http_Request')) {
            $request = new Google_Http_Request($object->getMediaLink());

            $this->service->getClient()->getAuth()->sign($request);
            $response = $this->service->getClient()->getIo()->executeRequest($request);
            if ($response[2] == 200) {
                $this->setMetadata($key, $object->getMetadata());


                return $response[0];
            }
        } else {
            $httpClient = new GuzzleHttp\Client();
            $httpClient = $this->service->getClient()->authorize($httpClient);

            $response = $httpClient->request('GET', $object->getMediaLink());

            if ($response->getStatusCode() == 200) {
                $this->setMetadata($key, $object->getMetadata());


                return $response->getBody();
            }
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function write($key, $content)
    {
        $this->ensureBucketExists();
        $path = $this->computePath($key);

        $metadata = $this->getMetadata($key);
        $options = array(
            'uploadType' => 'multipart',
            'data' => $content,
        );

        /*
         * If the ContentType was not already set in the metadata, then we autodetect
         * it to prevent everything being served up as application/octet-stream.
         */
        if (!isset($metadata['ContentType']) && $this->detectContentType) {
            $finfo = new \finfo(FILEINFO_MIME_TYPE);
            $options['mimeType'] = $finfo->buffer($content);
            unset($metadata['ContentType']);
        } elseif (isset($metadata['ContentType'])) {
            $options['mimeType'] = $metadata['ContentType'];
            unset($metadata['ContentType']);
        }

        $object = new \Google_Service_Storage_StorageObject();
        $object->name = $path;

        if (isset($metadata['ContentDisposition'])) {
            $object->setContentDisposition($metadata['ContentDisposition']);
            unset($metadata['ContentDisposition']);
        }

        if (isset($metadata['CacheControl'])) {
            $object->setCacheControl($metadata['CacheControl']);
            unset($metadata['CacheControl']);
        }

        if (isset($metadata['ContentLanguage'])) {
            $object->setContentLanguage($metadata['ContentLanguage']);
            unset($metadata['ContentLanguage']);
        }

        if (isset($metadata['ContentEncoding'])) {
            $object->setContentEncoding($metadata['ContentEncoding']);
            unset($metadata['ContentEncoding']);
        }

        $object->setMetadata($metadata);

        try {
            $object = $this->service->objects->insert($this->bucket, $object, $options);

            if ($this->options['acl'] == 'public') {
                $acl = new \Google_Service_Storage_ObjectAccessControl();
                $acl->setEntity('allUsers');
                $acl->setRole('READER');

                $this->service->objectAccessControls->insert($this->bucket, $path, $acl);
            }

            return $object->getSize();

        } catch (\Google_Service_Exception $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function exists($key)

    {
        $this->ensureBucketExists();
        $path = $this->computePath($key);

        try {
            $this->service->objects->get($this->bucket, $path);
        } catch (\Google_Service_Exception $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function keys()
    {
        return $this->listKeys();
    }

    /**
     * {@inheritdoc}
     */
    public function mtime($key)
    {
        $this->ensureBucketExists();
        $path = $this->computePath($key);

        $object = $this->getObjectData($path);

        return $object ? strtotime($object->getUpdated()) : false;

    }

    /**
     * {@inheritdoc}
     */
    public function delete($key)

    {
        $this->ensureBucketExists();
        $path = $this->computePath($key);

        try {
            $this->service->objects->delete($this->bucket, $path);
        } catch (\Google_Service_Exception $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function rename($sourceKey, $targetKey)
    {
        $this->ensureBucketExists();
        $sourcePath = $this->computePath($sourceKey);
        $targetPath = $this->computePath($targetKey);

        $object = $this->getObjectData($sourcePath);
        if ($object === false) {
            return false;
        }

        try {
            $this->service->objects->copy($this->bucket, $sourcePath, $this->bucket, $targetPath, $object);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $this->delete($sourcePath);
        } catch (\Google_Service_Exception $e) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function isDirectory($key)
    {
        if ($this->exists($key.'/')) {
            return true;
        }

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function listKeys($prefix = '')
    {
        $this->ensureBucketExists();

        $options = array();
        if ((string) $prefix != '') {

            $options['prefix'] = $this->computePath($prefix);
        } elseif (!empty($this->options['directory'])) {
            $options['prefix'] = $this->options['directory'];
        }

        $list = $this->service->objects->listObjects($this->bucket, $options);
        $keys = array();

        // FIXME: Temporary workaround for google/google-api-php-client#375
        $reflectionClass = new \ReflectionClass('Google_Service_Storage_Objects');
        $reflectionProperty = $reflectionClass->getProperty('collection_key');
        $reflectionProperty->setAccessible(true);
        $reflectionProperty->setValue($list, 'items');

        /** @var \Google_Service_Storage_StorageObject $object */
        foreach ($list as $object) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            $keys[] = $object->name;
        }

        sort($keys);

        return $keys;
    }

    /**
     * {@inheritdoc}
     */
    public function setMetadata($key, $content)
    {
        $path = $this->computePath($key);

        $this->metadata[$path] = $content;
    }

    /**
     * {@inheritdoc}
     */
    public function getMetadata($key)
    {
        $path = $this->computePath($key);

        return isset($this->metadata[$path]) ? $this->metadata[$path] : array();
    }

    /**
     * Ensures the specified bucket exists.
     *
     * @throws \RuntimeException if the bucket does not exists
     */
    protected function ensureBucketExists()
    {
        if ($this->bucketExists) {
            return;
        }

        try {
            $this->service->buckets->get($this->bucket);
            $this->bucketExists = true;

            return;
        } catch (\Google_Service_Exception $e) {
            $this->bucketExists = false;

            throw new \RuntimeException(
                sprintf(
                    'The configured bucket "%s" does not exist.',
                    $this->bucket
                )
            );
        }
    }

    protected function computePath($key)

    {
        if (empty($this->options['directory'])) {
            return $key;
        }

        return sprintf('%s/%s', $this->options['directory'], $key);
    }

    /**
     * @param string $path
     * @param array  $options
     *
     * @return bool|\Google_Service_Storage_StorageObject
     */
    private function getObjectData($path, $options = array())
    {
        try {
            return $this->service->objects->get($this->bucket, $path, $options);
        } catch (\Google_Service_Exception $e) {
            return false;
        }
    }
}


1		<?php
2
3		namespace Gaufrette\Adapter;
4
5		use Gaufrette\Adapter;
6		use GuzzleHttp;
7
8		/**
9		* Google Cloud Storage adapter using the Google APIs Client Library for PHP.
10		*
11		* @author Patrik Karisch <[email protected]>
12		*/
13		class GoogleCloudStorage implements Adapter,
		0 ignored issues – show Coding Style introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report The first item in a multi-line implements list must be on the line following the implements keyword Loading history...
14		MetadataSupporter,
		0 ignored issues – show Coding Style introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report Expected 4 spaces before interface name; 36 found Loading history...
15		ListKeysAware
		0 ignored issues – show Coding Style introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report Expected 4 spaces before interface name; 36 found Loading history...
16		{
17		protected $service;
18		protected $bucket;
19		protected $options;
20		protected $bucketExists;
21		protected $metadata = array();
22		protected $detectContentType;
23
24		/**
25		* @param \Google_Service_Storage $service The storage service class with authenticated
26		* client and full access scope
27		* @param string $bucket The bucket name
28		* @param array $options Options can be directory and acl
29		* @param bool $detectContentType Whether to detect the content type or not
30		*/
31	View Code Duplication	public function __construct(
		0 ignored issues – show Duplication introduced 2016-09-20 21:44 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
32		\Google_Service_Storage $service,
33		$bucket,
34		array $options = array(),
35		$detectContentType = false
36		) {
37		$this->service = $service;
38		$this->bucket = $bucket;
39		$this->options = array_replace(
40		array(
41		'directory' => '',
42		'acl' => 'private',
43		),
44		$options
45		);
46
47		$this->detectContentType = $detectContentType;
48		}
49
50		/**
51		* @return array The actual options
52		*/
53		public function getOptions()
54		{
55		return $this->options;
56		}
57
58		/**
59		* @param array $options The new options
60		*/
61		public function setOptions($options)
62		{
63		$this->options = array_replace($this->options, $options);
64		}
65
66		/**
67		* @return string The current bucket name
68		*/
69		public function getBucket()
70		{
71		return $this->bucket;
72		}
73
74		/**
75		* Sets a new bucket name.
76		*
77		* @param string $bucket The new bucket name
78		*/
79		public function setBucket($bucket)
80		{
81		$this->bucket = $bucket;
82		}
83
84		/**
85		* {@inheritdoc}
86		*/
87		public function read($key)
88		{
89		$this->ensureBucketExists();
90		$path = $this->computePath($key);
91
92		$object = $this->getObjectData($path);
93		if ($object === false) {
94		return false;
95		}
96
97		if (class_exists('Google_Http_Request')) {
98		$request = new Google_Http_Request($object->getMediaLink());
		0 ignored issues – show Bug introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report The method `getMediaLink()` does not seem to exist on `object<Google_Http_Request>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
99		$this->service->getClient()->getAuth()->sign($request);
100		$response = $this->service->getClient()->getIo()->executeRequest($request);
101		if ($response[2] == 200) {
102		$this->setMetadata($key, $object->getMetadata());
		0 ignored issues – show Bug introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report The method `getMetadata()` does not seem to exist on `object<Google_Http_Request>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
103
104		return $response[0];
105		}
106		} else {
107		$httpClient = new GuzzleHttp\Client();
108		$httpClient = $this->service->getClient()->authorize($httpClient);
		0 ignored issues – show Bug introduced 2016-09-20 21:44 UTC by Report Bug Copy Issue Report The method `authorize()` does not seem to exist on `object<Google_Client>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
109		$response = $httpClient->request('GET', $object->getMediaLink());
		0 ignored issues – show Bug introduced 2016-09-20 21:44 UTC by Report Bug Copy Issue Report The method `getMediaLink()` does not seem to exist on `object<Google_Http_Request>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
110		if ($response->getStatusCode() == 200) {
111		$this->setMetadata($key, $object->getMetadata());
		0 ignored issues – show Bug introduced 2016-09-20 21:44 UTC by Report Bug Copy Issue Report The method `getMetadata()` does not seem to exist on `object<Google_Http_Request>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
112
113		return $response->getBody();
114		}
115		}
116
117		return false;
118		}
119
120		/**
121		* {@inheritdoc}
122		*/
123		public function write($key, $content)
124		{
125		$this->ensureBucketExists();
126		$path = $this->computePath($key);
127
128		$metadata = $this->getMetadata($key);
129		$options = array(
130		'uploadType' => 'multipart',
131		'data' => $content,
132		);
133
134		/*
135		* If the ContentType was not already set in the metadata, then we autodetect
136		* it to prevent everything being served up as application/octet-stream.
137		*/
138		if (!isset($metadata['ContentType']) && $this->detectContentType) {
139		$finfo = new \finfo(FILEINFO_MIME_TYPE);
140		$options['mimeType'] = $finfo->buffer($content);
141		unset($metadata['ContentType']);
142		} elseif (isset($metadata['ContentType'])) {
143		$options['mimeType'] = $metadata['ContentType'];
144		unset($metadata['ContentType']);
145		}
146
147		$object = new \Google_Service_Storage_StorageObject();
148		$object->name = $path;
149
150		if (isset($metadata['ContentDisposition'])) {
151		$object->setContentDisposition($metadata['ContentDisposition']);
152		unset($metadata['ContentDisposition']);
153		}
154
155		if (isset($metadata['CacheControl'])) {
156		$object->setCacheControl($metadata['CacheControl']);
157		unset($metadata['CacheControl']);
158		}
159
160		if (isset($metadata['ContentLanguage'])) {
161		$object->setContentLanguage($metadata['ContentLanguage']);
162		unset($metadata['ContentLanguage']);
163		}
164
165		if (isset($metadata['ContentEncoding'])) {
166		$object->setContentEncoding($metadata['ContentEncoding']);
167		unset($metadata['ContentEncoding']);
168		}
169
170		$object->setMetadata($metadata);
171
172		try {
173		$object = $this->service->objects->insert($this->bucket, $object, $options);
174
175		if ($this->options['acl'] == 'public') {
176		$acl = new \Google_Service_Storage_ObjectAccessControl();
177		$acl->setEntity('allUsers');
178		$acl->setRole('READER');
179
180		$this->service->objectAccessControls->insert($this->bucket, $path, $acl);
181		}
182
183		return $object->getSize();
		0 ignored issues – show Bug introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report The method `getSize()` does not seem to exist on `object<Google_Http_Request>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
184		} catch (\Google_Service_Exception $e) {
185		return false;
186		}
187		}
188
189		/**
190		* {@inheritdoc}
191		*/
192	View Code Duplication	public function exists($key)
		0 ignored issues – show Duplication introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
193		{
194		$this->ensureBucketExists();
195		$path = $this->computePath($key);
196
197		try {
198		$this->service->objects->get($this->bucket, $path);
199		} catch (\Google_Service_Exception $e) {
200		return false;
201		}
202
203		return true;
204		}
205
206		/**
207		* {@inheritdoc}
208		*/
209		public function keys()
210		{
211		return $this->listKeys();
212		}
213
214		/**
215		* {@inheritdoc}
216		*/
217		public function mtime($key)
218		{
219		$this->ensureBucketExists();
220		$path = $this->computePath($key);
221
222		$object = $this->getObjectData($path);
223
224		return $object ? strtotime($object->getUpdated()) : false;
		0 ignored issues – show Bug introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report The method `getUpdated()` does not seem to exist on `object<Google_Http_Request>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
225		}
226
227		/**
228		* {@inheritdoc}
229		*/
230	View Code Duplication	public function delete($key)
		0 ignored issues – show Duplication introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
231		{
232		$this->ensureBucketExists();
233		$path = $this->computePath($key);
234
235		try {
236		$this->service->objects->delete($this->bucket, $path);
237		} catch (\Google_Service_Exception $e) {
238		return false;
239		}
240
241		return true;
242		}
243
244		/**
245		* {@inheritdoc}
246		*/
247		public function rename($sourceKey, $targetKey)
248		{
249		$this->ensureBucketExists();
250		$sourcePath = $this->computePath($sourceKey);
251		$targetPath = $this->computePath($targetKey);
252
253		$object = $this->getObjectData($sourcePath);
254		if ($object === false) {
255		return false;
256		}
257
258		try {
259		$this->service->objects->copy($this->bucket, $sourcePath, $this->bucket, $targetPath, $object);
		0 ignored issues – show Bug introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report It seems like `$object` defined by `$this->getObjectData($sourcePath)` on line `253` can also be of type `object<Google_Http_Request>`; however, `Google_Service_Storage_Objects_Resource::copy()` does only seem to accept `object<Google_Service_Storage_StorageObject>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
260		$this->delete($sourcePath);
261		} catch (\Google_Service_Exception $e) {
262		return false;
263		}
264
265		return true;
266		}
267
268		/**
269		* {@inheritdoc}
270		*/
271		public function isDirectory($key)
272		{
273		if ($this->exists($key.'/')) {
274		return true;
275		}
276
277		return false;
278		}
279
280		/**
281		* {@inheritdoc}
282		*/
283		public function listKeys($prefix = '')
284		{
285		$this->ensureBucketExists();
286
287		$options = array();
288	View Code Duplication	if ((string) $prefix != '') {
		0 ignored issues – show Duplication introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
289		$options['prefix'] = $this->computePath($prefix);
290		} elseif (!empty($this->options['directory'])) {
291		$options['prefix'] = $this->options['directory'];
292		}
293
294		$list = $this->service->objects->listObjects($this->bucket, $options);
295		$keys = array();
296
297		// FIXME: Temporary workaround for google/google-api-php-client#375
298		$reflectionClass = new \ReflectionClass('Google_Service_Storage_Objects');
299		$reflectionProperty = $reflectionClass->getProperty('collection_key');
300		$reflectionProperty->setAccessible(true);
301		$reflectionProperty->setValue($list, 'items');
302
303		/** @var \Google_Service_Storage_StorageObject $object */
304		foreach ($list as $object) {
		0 ignored issues – show Bug introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report The expression `$list` of type `object<Google_Http_Reque...\|object<expected_class>` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
305		$keys[] = $object->name;
306		}
307
308		sort($keys);
309
310		return $keys;
311		}
312
313		/**
314		* {@inheritdoc}
315		*/
316		public function setMetadata($key, $content)
317		{
318		$path = $this->computePath($key);
319
320		$this->metadata[$path] = $content;
321		}
322
323		/**
324		* {@inheritdoc}
325		*/
326		public function getMetadata($key)
327		{
328		$path = $this->computePath($key);
329
330		return isset($this->metadata[$path]) ? $this->metadata[$path] : array();
331		}
332
333		/**
334		* Ensures the specified bucket exists.
335		*
336		* @throws \RuntimeException if the bucket does not exists
337		*/
338		protected function ensureBucketExists()
339		{
340		if ($this->bucketExists) {
341		return;
342		}
343
344		try {
345		$this->service->buckets->get($this->bucket);
346		$this->bucketExists = true;
347
348		return;
349		} catch (\Google_Service_Exception $e) {
350		$this->bucketExists = false;
351
352		throw new \RuntimeException(
353		sprintf(
354		'The configured bucket "%s" does not exist.',
355		$this->bucket
356		)
357		);
358		}
359		}
360
361	View Code Duplication	protected function computePath($key)
		0 ignored issues – show Duplication introduced 2016-03-05 14:38 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
362		{
363		if (empty($this->options['directory'])) {
364		return $key;
365		}
366
367		return sprintf('%s/%s', $this->options['directory'], $key);
368		}
369
370		/**
371		* @param string $path
372		* @param array $options
373		*
374		* @return bool\|\Google_Service_Storage_StorageObject
375		*/
376		private function getObjectData($path, $options = array())
377		{
378		try {
379		return $this->service->objects->get($this->bucket, $path, $options);
380		} catch (\Google_Service_Exception $e) {
381		return false;
382		}
383		}
384		}
385

KnpLabs / Gaufrette