GoogleCloudClientStorage - Code Metrics - Inspection of "Adds adapter for Google Cloud Client Library" - KnpLabs/Gaufrette - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#427)

unknown

created 2017-06-02 11:26 UTC

GoogleCloudClientStorage B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	325
Duplicated Lines	10.46 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	4
Bugs	1	Features	1

Metric	Value
wmc	40
c	4
b	1
f	1
lcom	1
cbo	0
dl	34
loc	325
rs	8.2608

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	getOptions()	0	4	1
A	setOptions()	0	4	1
A	computePath()	0	12	3
A	isBucket()	0	11	3
A	setBucket()	0	6	1
A	getBucket()	0	4	1
A	read()	8	8	1
B	write()	0	26	2
A	exists()	10	10	2
A	isDirectory()	0	8	2
A	listKeys()	0	17	3
A	keys()	0	4	1
A	mtime()	8	8	1
A	delete()	8	8	1
A	setResources()	0	4	1
A	getResources()	0	4	2
A	getResourceByName()	0	4	2
B	updateKeyProperties()	0	28	3
B	rename()	0	32	2
A	setMetadata()	0	4	1
B	getMetadata()	0	12	5

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 GoogleCloudClientStorage 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 GoogleCloudClientStorage, and based on these observations, apply Extract Interface, too.

<?php
namespace Gaufrette\Adapter;

use Gaufrette\Adapter;
use Gaufrette\Adapter\MetadataSupporter;
use Gaufrette\Adapter\ResourcesSupporter;
use Gaufrette\Adapter\ListKeysAware;

/**
 * Google Cloud Storage adapter using the Google Cloud Client Library for PHP
 * http://googlecloudplatform.github.io/google-cloud-php/
 *
 * @package Gaufrette
 * @author  Lech Buszczynski <[email protected]>
 */
class GoogleCloudClientStorage implements Adapter, MetadataSupporter, ResourcesSupporter, ListKeysAware
{
    protected $storageClient;
    protected $bucket;
    protected $bucketValidated;
    protected $options      = array();
    protected $metadata     = array();
    protected $resources    = array();

    /**
     * @param Google\Cloud\Storage\StorageClient    $service    Authenticated storage client class
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string                                $bucketName Name of the bucket
     * @param array                                 $options    Options are: "directory" and "acl" (see https://cloud.google.com/storage/docs/access-control/lists)
     */
    public function __construct(\Google\Cloud\Storage\StorageClient $storageClient, $bucketName, $options = array())
    {
        $this->storageClient = $storageClient;
        $this->setBucket($bucketName);
        $this->options = array_replace_recursive(
            array(
                'directory' => '',
                'acl'       => array()
            ),
            $options
        );
    }
    
    /**
     * Get adapter options
     * 
     * @return  array
     */
    public function getOptions()
    {
        return $this->options;
    }

    /**
     * Set adapter options
     * 
     * @param   array   $options
     */
    public function setOptions($options)
    {
        $this->options = array_replace($this->options, $options);
    }
    
    protected function computePath($key)
    {
        if (strlen($this->options['directory']))
        {
            if (strcmp(substr($this->options['directory'], -1), '/') == 0)
            {
                return $this->options['directory'].$key;
            }
            return $this->options['directory'].'/'.$key;
        }
        return $key;
    }
    
    protected function isBucket()
    {
        if ($this->bucketValidated === true)
        {
            return true;
        } elseif (!$this->bucket->exists()) {
            throw new \RuntimeException(sprintf('Bucket %s does not exist.', $this->bucket->name()));
        }
        $this->bucketValidated = true;
        return true;
    }
    
    public function setBucket($name)
    {
        $this->bucketValidated = null;
        $this->bucket = $this->storageClient->bucket($name);       
        $this->isBucket();
    }
    
    public function getBucket()
    {
        return $this->bucket;
    }
    
    /**
     * {@inheritdoc}
     */
    public function read($key)

    {   
        $this->isBucket();     
        $object = $this->bucket->object($this->computePath($key));
        $info = $object->info();
        $this->setResources($key, $info);
        return $object->downloadAsString();
    }
    
    /**
     * {@inheritdoc}
     */
    public function write($key, $content)
    {
        $this->isBucket();
        
        $options = array(
            'resumable'     => true,
            'name'          => $this->computePath($key),
            'metadata'      => $this->getMetadata($key),
        );

        $this->bucket->upload(
            $content,
            $options
        );
        
        $this->updateKeyProperties($key,
            array(
                'acl'       => $this->options['acl'],
                'metadata'  => $this->getMetadata($key)
            )
        );
        
        $size = $this->getResourceByName($key, 'size');
        
        return $size === null ? false : $size;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }
    
    /**
     * {@inheritdoc}
     */
    public function exists($key)

    {
        $this->isBucket();
        $object = $this->bucket->object($this->computePath($key));
        if ($object->exists())
        {
            return true;
        }
        return false;
    }
    
    /**
     * {@inheritdoc}
     */
    public function isDirectory($key)
    {
        if ($this->exists($key . '/'))
        {
            return true;
        }
        return false;
    }
    
    /**
     * {@inheritdoc}
     */
    public function listKeys($prefix = null)
    {
        $this->isBucket();        
        $keys = array();        
        if ($prefix === null)
        {
            $prefix = $this->options['directory'];
        } else {
            $prefix = $this->computePath($prefix);
        }
        foreach ($this->bucket->objects(array('prefix' => $prefix)) as $e)
        {
            $keys[] = $e->name();
        }
        sort($keys);
        return $keys;
    }
    
    /**
     * {@inheritdoc}
     */
    public function keys()
    {
        return $this->listKeys();
    }

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

    {
        $this->isBucket();
        $object = $object = $this->bucket->object($this->computePath($key));
        $info = $object->info();
        $this->setResources($key, $info);
        return strtotime($info['updated']);
    }
    
    /**
     * {@inheritdoc}
     */
    public function delete($key)

    {
        $this->isBucket();
        $object = $this->bucket->object($this->computePath($key));
        $object->delete();
        $this->setMetadata($key, null);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        return true;
    }
    
    /**
     * {@inheritdoc}
     */
    public function rename($sourceKey, $targetKey)
    {
        $this->isBucket();
        
        $metadata = $this->getMetadata($sourceKey);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        
        $sourceKey = $this->computePath($sourceKey);
        $targetKey = $this->computePath($targetKey);
        
        $object = $this->bucket->object($sourceKey);
        
        $copiedObject = $object->copy($this->bucket,
            array(
                'name' => $targetKey
            )
        );
        
        if ($copiedObject->exists())
        {
            $this->updateKeyProperties($targetKey,
                array(
                    'acl'       => $this->options['acl'],
                    'metadata'  => $this->getMetadata($sourceKey)
                )
            );
            $this->setMetadata($targetKey, $this->getMetadata($sourceKey));
            $this->setMetadata($sourceKey, null);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $object->delete();
            return true;
        }
        return false;
    }
    
    /**
     * {@inheritdoc}
     */
    public function setMetadata($key, $metadata)
    {
        $this->metadata[$key] = $metadata;
    }

    /**
     * {@inheritdoc}
     */
    public function getMetadata($key)
    {
        if (!isset($this->metadata[$key]) && $this->exists($key))
        {
            $data = $this->bucket->object($key)->info();
            if (isset($data['metadata']))
            {
                $this->metadata[$key] = $data['metadata'];
            }
        }
        return isset($this->metadata[$key]) ? $this->metadata[$key] : array();
    }
    
    /**
     * {@inheritdoc}
     */
    public function setResources($key, $data)
    {
        $this->resources[$key] = $data;
    }
    
    /**
     * {@inheritdoc}
     */
    public function getResources($key)
    {
        return isset($this->resources[$key]) ? $this->resources[$key] : array();
    }
    
    /**
     * {@inheritdoc}
     */
    public function getResourceByName($key, $resourceName)
    {
        return isset($this->resources[$key][$resourceName]) ? $this->resources[$key][$resourceName] : null;
    }
    
    /**
     * Sets ACL and metadata information.
     * 
     * @param   string  $key
     * @param   array   $options    Can contain "acl" and/or "metadata" arrays.
     * @return  boolean
     */
    protected function updateKeyProperties($key, $options = array())
    {
        if ($this->exists($key) === false)
        {
            return false;
        }
        
        $object = $this->bucket->object($this->computePath($key));
        
        $properties = array_replace_recursive(
            array(
                'acl'       => array(),
                'metadata'  => array()
            ), $options
        );

        $acl = $object->acl();
        foreach ($properties['acl'] as $k => $v)
        {
            $acl->add($k, $v);
        }
        $object->update(array('metadata' => $properties['metadata']));

        $info = $object->info();

        $this->setResources($key, $info);
        return true;
    }
}


1		<?php
2		namespace Gaufrette\Adapter;
3
4		use Gaufrette\Adapter;
5		use Gaufrette\Adapter\MetadataSupporter;
6		use Gaufrette\Adapter\ResourcesSupporter;
7		use Gaufrette\Adapter\ListKeysAware;
8
9		/**
10		* Google Cloud Storage adapter using the Google Cloud Client Library for PHP
11		* http://googlecloudplatform.github.io/google-cloud-php/
12		*
13		* @package Gaufrette
14		* @author Lech Buszczynski <[email protected]>
15		*/
16		class GoogleCloudClientStorage implements Adapter, MetadataSupporter, ResourcesSupporter, ListKeysAware
17		{
18		protected $storageClient;
19		protected $bucket;
20		protected $bucketValidated;
21		protected $options = array();
22		protected $metadata = array();
23		protected $resources = array();
24
25		/**
26		* @param Google\Cloud\Storage\StorageClient $service Authenticated storage client class
		0 ignored issues – show Bug introduced 2016-09-09 12:17 UTC by Report Bug Copy Issue Report There is no parameter named `$service`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
27		* @param string $bucketName Name of the bucket
28		* @param array $options Options are: "directory" and "acl" (see https://cloud.google.com/storage/docs/access-control/lists)
29		*/
30		public function __construct(\Google\Cloud\Storage\StorageClient $storageClient, $bucketName, $options = array())
31		{
32		$this->storageClient = $storageClient;
33		$this->setBucket($bucketName);
34		$this->options = array_replace_recursive(
35		array(
36		'directory' => '',
37		'acl' => array()
38		),
39		$options
40		);
41		}
42
43		/**
44		* Get adapter options
45		*
46		* @return array
47		*/
48		public function getOptions()
49		{
50		return $this->options;
51		}
52
53		/**
54		* Set adapter options
55		*
56		* @param array $options
57		*/
58		public function setOptions($options)
59		{
60		$this->options = array_replace($this->options, $options);
61		}
62
63		protected function computePath($key)
64		{
65		if (strlen($this->options['directory']))
66		{
67		if (strcmp(substr($this->options['directory'], -1), '/') == 0)
68		{
69		return $this->options['directory'].$key;
70		}
71		return $this->options['directory'].'/'.$key;
72		}
73		return $key;
74		}
75
76		protected function isBucket()
77		{
78		if ($this->bucketValidated === true)
79		{
80		return true;
81		} elseif (!$this->bucket->exists()) {
82		throw new \RuntimeException(sprintf('Bucket %s does not exist.', $this->bucket->name()));
83		}
84		$this->bucketValidated = true;
85		return true;
86		}
87
88		public function setBucket($name)
89		{
90		$this->bucketValidated = null;
91		$this->bucket = $this->storageClient->bucket($name);
92		$this->isBucket();
93		}
94
95		public function getBucket()
96		{
97		return $this->bucket;
98		}
99
100		/**
101		* {@inheritdoc}
102		*/
103	View Code Duplication	public function read($key)
		0 ignored issues – show Duplication introduced 2016-09-09 12:17 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...
104		{
105		$this->isBucket();
106		$object = $this->bucket->object($this->computePath($key));
107		$info = $object->info();
108		$this->setResources($key, $info);
109		return $object->downloadAsString();
110		}
111
112		/**
113		* {@inheritdoc}
114		*/
115		public function write($key, $content)
116		{
117		$this->isBucket();
118
119		$options = array(
120		'resumable' => true,
121		'name' => $this->computePath($key),
122		'metadata' => $this->getMetadata($key),
123		);
124
125		$this->bucket->upload(
126		$content,
127		$options
128		);
129
130		$this->updateKeyProperties($key,
131		array(
132		'acl' => $this->options['acl'],
133		'metadata' => $this->getMetadata($key)
134		)
135		);
136
137		$size = $this->getResourceByName($key, 'size');
138
139		return $size === null ? false : $size;
		0 ignored issues – show Bug Best Practice introduced 2016-09-10 10:54 UTC by Report Bug Copy Issue Report The return type of `return $size === null ? false : $size;` (`array\|string`) is incompatible with the return type declared by the interface `Gaufrette\Adapter::write` of type `integer\|boolean`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
140		}
141
142		/**
143		* {@inheritdoc}
144		*/
145	View Code Duplication	public function exists($key)
		0 ignored issues – show Duplication introduced 2016-09-10 10:58 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...
146		{
147		$this->isBucket();
148		$object = $this->bucket->object($this->computePath($key));
149		if ($object->exists())
150		{
151		return true;
152		}
153		return false;
154		}
155
156		/**
157		* {@inheritdoc}
158		*/
159		public function isDirectory($key)
160		{
161		if ($this->exists($key . '/'))
162		{
163		return true;
164		}
165		return false;
166		}
167
168		/**
169		* {@inheritdoc}
170		*/
171		public function listKeys($prefix = null)
172		{
173		$this->isBucket();
174		$keys = array();
175		if ($prefix === null)
176		{
177		$prefix = $this->options['directory'];
178		} else {
179		$prefix = $this->computePath($prefix);
180		}
181		foreach ($this->bucket->objects(array('prefix' => $prefix)) as $e)
182		{
183		$keys[] = $e->name();
184		}
185		sort($keys);
186		return $keys;
187		}
188
189		/**
190		* {@inheritdoc}
191		*/
192		public function keys()
193		{
194		return $this->listKeys();
195		}
196
197		/**
198		* {@inheritdoc}
199		*/
200	View Code Duplication	public function mtime($key)
		0 ignored issues – show Duplication introduced 2016-09-10 10:58 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...
201		{
202		$this->isBucket();
203		$object = $object = $this->bucket->object($this->computePath($key));
204		$info = $object->info();
205		$this->setResources($key, $info);
206		return strtotime($info['updated']);
207		}
208
209		/**
210		* {@inheritdoc}
211		*/
212	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...
213		{
214		$this->isBucket();
215		$object = $this->bucket->object($this->computePath($key));
216		$object->delete();
217		$this->setMetadata($key, null);
		0 ignored issues – show Documentation introduced 2016-09-10 10:58 UTC by Report Bug Copy Issue Report `null` is of type `null`, 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...
218		return true;
219		}
220
221		/**
222		* {@inheritdoc}
223		*/
224		public function rename($sourceKey, $targetKey)
225		{
226		$this->isBucket();
227
228		$metadata = $this->getMetadata($sourceKey);
		0 ignored issues – show Unused Code introduced 2016-09-10 10:54 UTC by Report Bug Copy Issue Report `$metadata` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
229
230		$sourceKey = $this->computePath($sourceKey);
231		$targetKey = $this->computePath($targetKey);
232
233		$object = $this->bucket->object($sourceKey);
234
235		$copiedObject = $object->copy($this->bucket,
236		array(
237		'name' => $targetKey
238		)
239		);
240
241		if ($copiedObject->exists())
242		{
243		$this->updateKeyProperties($targetKey,
244		array(
245		'acl' => $this->options['acl'],
246		'metadata' => $this->getMetadata($sourceKey)
247		)
248		);
249		$this->setMetadata($targetKey, $this->getMetadata($sourceKey));
250		$this->setMetadata($sourceKey, null);
		0 ignored issues – show Documentation introduced 2016-09-10 10:54 UTC by Report Bug Copy Issue Report `null` is of type `null`, 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...
251		$object->delete();
252		return true;
253		}
254		return false;
255		}
256
257		/**
258		* {@inheritdoc}
259		*/
260		public function setMetadata($key, $metadata)
261		{
262		$this->metadata[$key] = $metadata;
263		}
264
265		/**
266		* {@inheritdoc}
267		*/
268		public function getMetadata($key)
269		{
270		if (!isset($this->metadata[$key]) && $this->exists($key))
271		{
272		$data = $this->bucket->object($key)->info();
273		if (isset($data['metadata']))
274		{
275		$this->metadata[$key] = $data['metadata'];
276		}
277		}
278		return isset($this->metadata[$key]) ? $this->metadata[$key] : array();
279		}
280
281		/**
282		* {@inheritdoc}
283		*/
284		public function setResources($key, $data)
285		{
286		$this->resources[$key] = $data;
287		}
288
289		/**
290		* {@inheritdoc}
291		*/
292		public function getResources($key)
293		{
294		return isset($this->resources[$key]) ? $this->resources[$key] : array();
295		}
296
297		/**
298		* {@inheritdoc}
299		*/
300		public function getResourceByName($key, $resourceName)
301		{
302		return isset($this->resources[$key][$resourceName]) ? $this->resources[$key][$resourceName] : null;
303		}
304
305		/**
306		* Sets ACL and metadata information.
307		*
308		* @param string $key
309		* @param array $options Can contain "acl" and/or "metadata" arrays.
310		* @return boolean
311		*/
312		protected function updateKeyProperties($key, $options = array())
313		{
314		if ($this->exists($key) === false)
315		{
316		return false;
317		}
318
319		$object = $this->bucket->object($this->computePath($key));
320
321		$properties = array_replace_recursive(
322		array(
323		'acl' => array(),
324		'metadata' => array()
325		), $options
326		);
327
328		$acl = $object->acl();
329		foreach ($properties['acl'] as $k => $v)
330		{
331		$acl->add($k, $v);
332		}
333		$object->update(array('metadata' => $properties['metadata']));
334
335		$info = $object->info();
336
337		$this->setResources($key, $info);
338		return true;
339		}
340		}
341

KnpLabs / Gaufrette