AwsS3 - Code Metrics - Inspection of "Provide mime type through AwsS3 adapter" - KnpLabs/Gaufrette - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#491)

by Albin

created 2017-05-21 20:36 UTC

AwsS3 B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	348
Duplicated Lines	14.37 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
wmc	43
lcom	1
cbo	3
dl	50
loc	348
rs	8.3157
c	0
b	0
f	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	1
A	getUrl()	0	9	2
A	setMetadata()	0	10	2
A	getMetadata()	0	4	2
A	read()	0	20	4
A	rename()	0	16	2
B	write()	0	25	5
A	exists()	0	4	1
A	mtime()	9	10	2
A	size()	9	10	2
A	keys()	0	4	1
A	listKeys()	5	17	4
A	delete()	0	10	2
A	isDirectory()	0	10	1
B	ensureBucketExists()	0	25	4
A	getOptions()	0	14	1
A	computePath()	8	8	2
A	computeKey()	0	4	1
A	guessContentType()	10	10	2
A	mimeType()	9	9	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 AwsS3 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 AwsS3, and based on these observations, apply Extract Interface, too.

<?php

namespace Gaufrette\Adapter;

use Gaufrette\Adapter;
use Aws\S3\S3Client;
use Gaufrette\Util;

/**
 * Amazon S3 adapter using the AWS SDK for PHP v2.x.
 *
 * @author  Michael Dowling <[email protected]>
 */
class AwsS3 implements Adapter,

                       MetadataSupporter,

                       ListKeysAware,

                       SizeCalculator,

                       MimeTypeProvider

{
    /** @var S3Client */
    protected $service;
    /** @var string */
    protected $bucket;
    /** @var array */
    protected $options;
    /** @var bool */
    protected $bucketExists;
    /** @var array */
    protected $metadata = [];
    /** @var bool */
    protected $detectContentType;

    /**
     * @param S3Client $service
     * @param string   $bucket
     * @param array    $options
     * @param bool     $detectContentType
     */
    public function __construct(S3Client $service, $bucket, array $options = [], $detectContentType = false)
    {
        $this->service = $service;
        $this->bucket = $bucket;
        $this->options = array_replace(
            [
                'create' => false,
                'directory' => '',
                'acl' => 'private',
            ],
            $options
        );

        $this->detectContentType = $detectContentType;
    }

    /**
     * Gets the publicly accessible URL of an Amazon S3 object.
     *
     * @param string $key     Object key
     * @param array  $options Associative array of options used to buld the URL
     *                        - expires: The time at which the URL should expire
     *                        represented as a UNIX timestamp
     *                        - Any options available in the Amazon S3 GetObject
     *                        operation may be specified.
     *
     * @return string
     */
    public function getUrl($key, array $options = [])
    {
        return $this->service->getObjectUrl(
            $this->bucket,
            $this->computePath($key),
            isset($options['expires']) ? $options['expires'] : null,

            $options
        );
    }

    /**
     * {@inheritdoc}
     */
    public function setMetadata($key, $metadata)
    {
        // BC with AmazonS3 adapter
        if (isset($metadata['contentType'])) {
            $metadata['ContentType'] = $metadata['contentType'];
            unset($metadata['contentType']);
        }

        $this->metadata[$key] = $metadata;
    }

    /**
     * {@inheritdoc}
     */
    public function getMetadata($key)
    {
        return isset($this->metadata[$key]) ? $this->metadata[$key] : [];
    }

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

        try {
            // Get remote object
            $object = $this->service->getObject($options);
            // If there's no metadata array set up for this object, set it up
            if (!array_key_exists($key, $this->metadata) || !is_array($this->metadata[$key])) {
                $this->metadata[$key] = [];
            }
            // Make remote ContentType metadata available locally
            $this->metadata[$key]['ContentType'] = $object->get('ContentType');

            return (string) $object->get('Body');
        } catch (\Exception $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function rename($sourceKey, $targetKey)
    {
        $this->ensureBucketExists();
        $options = $this->getOptions(
            $targetKey,
            ['CopySource' => $this->bucket.'/'.$this->computePath($sourceKey)]
        );

        try {
            $this->service->copyObject(array_merge($options, $this->getMetadata($targetKey)));

            return $this->delete($sourceKey);
        } catch (\Exception $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function write($key, $content)
    {
        $this->ensureBucketExists();
        $options = $this->getOptions($key, ['Body' => $content]);

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

        try {
            $this->service->putObject($options);

            if (is_resource($content)) {
                return Util\Size::fromResource($content);
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());
}
            }

            return Util\Size::fromContent($content);
        } catch (\Exception $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function exists($key)
    {
        return $this->service->doesObjectExist($this->bucket, $this->computePath($key));
    }

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

    {
        try {
            $result = $this->service->headObject($this->getOptions($key));

            return strtotime($result['LastModified']);
        } catch (\Exception $e) {
            return false;
        }
    }

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

    {
        try {
            $result = $this->service->headObject($this->getOptions($key));

            return $result['ContentLength'];
        } catch (\Exception $e) {
            return false;
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 keys()
    {
        return $this->listKeys();
    }

    /**
     * {@inheritdoc}
     */
    public function listKeys($prefix = '')
    {
        $options = ['Bucket' => $this->bucket];
        if ((string) $prefix != '') {

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

        $keys = [];
        $iter = $this->service->getIterator('ListObjects', $options);
        foreach ($iter as $file) {
            $keys[] = $this->computeKey($file['Key']);
        }

        return $keys;
    }

    /**
     * {@inheritdoc}
     */
    public function delete($key)
    {
        try {
            $this->service->deleteObject($this->getOptions($key));

            return true;
        } catch (\Exception $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function isDirectory($key)
    {
        $result = $this->service->listObjects([
            'Bucket' => $this->bucket,
            'Prefix' => rtrim($this->computePath($key), '/').'/',
            'MaxKeys' => 1,
        ]);

        return count($result['Contents']) > 0;
    }

    /**
     * Ensures the specified bucket exists. If the bucket does not exists
     * and the create option is set to true, it will try to create the
     * bucket. The bucket is created using the same region as the supplied
     * client object.
     *
     * @throws \RuntimeException if the bucket does not exists or could not be
     *                           created
     */
    protected function ensureBucketExists()
    {
        if ($this->bucketExists) {
            return true;
        }

        if ($this->bucketExists = $this->service->doesBucketExist($this->bucket)) {
            return true;
        }

        if (!$this->options['create']) {
            throw new \RuntimeException(sprintf(
                'The configured bucket "%s" does not exist.',
                $this->bucket
            ));
        }

        $this->service->createBucket([
            'Bucket' => $this->bucket,
            'LocationConstraint' => $this->service->getRegion()
        ]);
        $this->bucketExists = true;

        return true;
    }

    protected function getOptions($key, array $options = [])
    {
        $options['ACL'] = $this->options['acl'];
        $options['Bucket'] = $this->bucket;
        $options['Key'] = $this->computePath($key);

        /*
         * Merge global options for adapter, which are set in the constructor, with metadata.
         * Metadata will override global options.
         */
        $options = array_merge($this->options, $options, $this->getMetadata($key));

        return $options;
    }

    protected function computePath($key)

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

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

    /**
     * Computes the key from the specified path.
     *
     * @param string $path
     *
     * return string
     */
    protected function computeKey($path)
    {
        return ltrim(substr($path, strlen($this->options['directory'])), '/');
    }

    /**
     * @param string $content
     *
     * @return string
     */
    private function guessContentType($content)

    {
        $fileInfo = new \finfo(FILEINFO_MIME_TYPE);

        if (is_resource($content)) {
            return $fileInfo->file(stream_get_meta_data($content)['uri']);
        }

        return $fileInfo->buffer($content);
    }

    public function mimeType($key)

    {
        try {
            $result = $this->service->headObject($this->getOptions($key));
            return ($result['ContentType']);
        } catch (\Exception $e) {
            return false;
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());
}
        }
    }
}


1		<?php
2
3		namespace Gaufrette\Adapter;
4
5		use Gaufrette\Adapter;
6		use Aws\S3\S3Client;
7		use Gaufrette\Util;
8
9		/**
10		* Amazon S3 adapter using the AWS SDK for PHP v2.x.
11		*
12		* @author Michael Dowling <[email protected]>
13		*/
14		class AwsS3 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...
15		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; 23 found Loading history...
16		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; 23 found Loading history...
17		SizeCalculator,
		0 ignored issues – show Coding Style introduced 2017-05-21 20:39 UTC by Report Bug Copy Issue Report Expected 4 spaces before interface name; 23 found Loading history...
18		MimeTypeProvider
		0 ignored issues – show Coding Style introduced 2017-05-21 20:39 UTC by Report Bug Copy Issue Report Expected 4 spaces before interface name; 23 found Loading history...
19		{
20		/** @var S3Client */
21		protected $service;
22		/** @var string */
23		protected $bucket;
24		/** @var array */
25		protected $options;
26		/** @var bool */
27		protected $bucketExists;
28		/** @var array */
29		protected $metadata = [];
30		/** @var bool */
31		protected $detectContentType;
32
33		/**
34		* @param S3Client $service
35		* @param string $bucket
36		* @param array $options
37		* @param bool $detectContentType
38		*/
39		public function __construct(S3Client $service, $bucket, array $options = [], $detectContentType = false)
40		{
41		$this->service = $service;
42		$this->bucket = $bucket;
43		$this->options = array_replace(
44		[
45		'create' => false,
46		'directory' => '',
47		'acl' => 'private',
48		],
49		$options
50		);
51
52		$this->detectContentType = $detectContentType;
53		}
54
55		/**
56		* Gets the publicly accessible URL of an Amazon S3 object.
57		*
58		* @param string $key Object key
59		* @param array $options Associative array of options used to buld the URL
60		* - expires: The time at which the URL should expire
61		* represented as a UNIX timestamp
62		* - Any options available in the Amazon S3 GetObject
63		* operation may be specified.
64		*
65		* @return string
66		*/
67		public function getUrl($key, array $options = [])
68		{
69		return $this->service->getObjectUrl(
70		$this->bucket,
71		$this->computePath($key),
72		isset($options['expires']) ? $options['expires'] : null,
		0 ignored issues – show Unused Code introduced 2017-03-16 01:34 UTC by Report Bug Copy Issue Report The call to `S3Client::getObjectUrl()` has too many arguments starting with `isset($options['expires'...tions['expires'] : null`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
73		$options
74		);
75		}
76
77		/**
78		* {@inheritdoc}
79		*/
80		public function setMetadata($key, $metadata)
81		{
82		// BC with AmazonS3 adapter
83		if (isset($metadata['contentType'])) {
84		$metadata['ContentType'] = $metadata['contentType'];
85		unset($metadata['contentType']);
86		}
87
88		$this->metadata[$key] = $metadata;
89		}
90
91		/**
92		* {@inheritdoc}
93		*/
94		public function getMetadata($key)
95		{
96		return isset($this->metadata[$key]) ? $this->metadata[$key] : [];
97		}
98
99		/**
100		* {@inheritdoc}
101		*/
102		public function read($key)
103		{
104		$this->ensureBucketExists();
105		$options = $this->getOptions($key);
106
107		try {
108		// Get remote object
109		$object = $this->service->getObject($options);
110		// If there's no metadata array set up for this object, set it up
111		if (!array_key_exists($key, $this->metadata) \|\| !is_array($this->metadata[$key])) {
112		$this->metadata[$key] = [];
113		}
114		// Make remote ContentType metadata available locally
115		$this->metadata[$key]['ContentType'] = $object->get('ContentType');
116
117		return (string) $object->get('Body');
118		} catch (\Exception $e) {
119		return false;
120		}
121		}
122
123		/**
124		* {@inheritdoc}
125		*/
126		public function rename($sourceKey, $targetKey)
127		{
128		$this->ensureBucketExists();
129		$options = $this->getOptions(
130		$targetKey,
131		['CopySource' => $this->bucket.'/'.$this->computePath($sourceKey)]
132		);
133
134		try {
135		$this->service->copyObject(array_merge($options, $this->getMetadata($targetKey)));
136
137		return $this->delete($sourceKey);
138		} catch (\Exception $e) {
139		return false;
140		}
141		}
142
143		/**
144		* {@inheritdoc}
145		*/
146		public function write($key, $content)
147		{
148		$this->ensureBucketExists();
149		$options = $this->getOptions($key, ['Body' => $content]);
150
151		/*
152		* If the ContentType was not already set in the metadata, then we autodetect
153		* it to prevent everything being served up as binary/octet-stream.
154		*/
155		if (!isset($options['ContentType']) && $this->detectContentType) {
156		$options['ContentType'] = $this->guessContentType($content);
157		}
158
159		try {
160		$this->service->putObject($options);
161
162		if (is_resource($content)) {
163		return Util\Size::fromResource($content);
		0 ignored issues – show Bug Best Practice introduced 2016-05-22 14:30 UTC by Report Bug Copy Issue Report The return type of `return \Gaufrette\Util\S...fromResource($content);` (`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...
164		}
165
166		return Util\Size::fromContent($content);
167		} catch (\Exception $e) {
168		return false;
169		}
170		}
171
172		/**
173		* {@inheritdoc}
174		*/
175		public function exists($key)
176		{
177		return $this->service->doesObjectExist($this->bucket, $this->computePath($key));
178		}
179
180		/**
181		* {@inheritdoc}
182		*/
183	View Code Duplication	public function mtime($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...
184		{
185		try {
186		$result = $this->service->headObject($this->getOptions($key));
187
188		return strtotime($result['LastModified']);
189		} catch (\Exception $e) {
190		return false;
191		}
192		}
193
194		/**
195		* {@inheritdoc}
196		*/
197	View Code Duplication	public function size($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...
198		{
199		try {
200		$result = $this->service->headObject($this->getOptions($key));
201
202		return $result['ContentLength'];
203		} catch (\Exception $e) {
204		return false;
		0 ignored issues – show Bug Best Practice introduced 2016-12-14 20:44 UTC by Report Bug Copy Issue Report The return type of `return false;` (`false`) is incompatible with the return type declared by the interface `Gaufrette\Adapter\SizeCalculator::size` of type `integer`. 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...
205		}
206		}
207
208		/**
209		* {@inheritdoc}
210		*/
211		public function keys()
212		{
213		return $this->listKeys();
214		}
215
216		/**
217		* {@inheritdoc}
218		*/
219		public function listKeys($prefix = '')
220		{
221		$options = ['Bucket' => $this->bucket];
222	View Code Duplication	if ((string) $prefix != '') {
		0 ignored issues – show Duplication introduced 2017-03-19 17:27 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...
223		$options['Prefix'] = $this->computePath($prefix);
224		} elseif (!empty($this->options['directory'])) {
225		$options['Prefix'] = $this->options['directory'];
226		}
227
228		$keys = [];
229		$iter = $this->service->getIterator('ListObjects', $options);
230		foreach ($iter as $file) {
231		$keys[] = $this->computeKey($file['Key']);
232		}
233
234		return $keys;
235		}
236
237		/**
238		* {@inheritdoc}
239		*/
240		public function delete($key)
241		{
242		try {
243		$this->service->deleteObject($this->getOptions($key));
244
245		return true;
246		} catch (\Exception $e) {
247		return false;
248		}
249		}
250
251		/**
252		* {@inheritdoc}
253		*/
254		public function isDirectory($key)
255		{
256		$result = $this->service->listObjects([
257		'Bucket' => $this->bucket,
258		'Prefix' => rtrim($this->computePath($key), '/').'/',
259		'MaxKeys' => 1,
260		]);
261
262		return count($result['Contents']) > 0;
263		}
264
265		/**
266		* Ensures the specified bucket exists. If the bucket does not exists
267		* and the create option is set to true, it will try to create the
268		* bucket. The bucket is created using the same region as the supplied
269		* client object.
270		*
271		* @throws \RuntimeException if the bucket does not exists or could not be
272		* created
273		*/
274		protected function ensureBucketExists()
275		{
276		if ($this->bucketExists) {
277		return true;
278		}
279
280		if ($this->bucketExists = $this->service->doesBucketExist($this->bucket)) {
281		return true;
282		}
283
284		if (!$this->options['create']) {
285		throw new \RuntimeException(sprintf(
286		'The configured bucket "%s" does not exist.',
287		$this->bucket
288		));
289		}
290
291		$this->service->createBucket([
292		'Bucket' => $this->bucket,
293		'LocationConstraint' => $this->service->getRegion()
294		]);
295		$this->bucketExists = true;
296
297		return true;
298		}
299
300		protected function getOptions($key, array $options = [])
301		{
302		$options['ACL'] = $this->options['acl'];
303		$options['Bucket'] = $this->bucket;
304		$options['Key'] = $this->computePath($key);
305
306		/*
307		* Merge global options for adapter, which are set in the constructor, with metadata.
308		* Metadata will override global options.
309		*/
310		$options = array_merge($this->options, $options, $this->getMetadata($key));
311
312		return $options;
313		}
314
315	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...
316		{
317		if (empty($this->options['directory'])) {
318		return $key;
319		}
320
321		return sprintf('%s/%s', $this->options['directory'], $key);
322		}
323
324		/**
325		* Computes the key from the specified path.
326		*
327		* @param string $path
328		*
329		* return string
330		*/
331		protected function computeKey($path)
332		{
333		return ltrim(substr($path, strlen($this->options['directory'])), '/');
334		}
335
336		/**
337		* @param string $content
338		*
339		* @return string
340		*/
341	View Code Duplication	private function guessContentType($content)
		0 ignored issues – show Duplication introduced 2016-05-25 21:24 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...
342		{
343		$fileInfo = new \finfo(FILEINFO_MIME_TYPE);
344
345		if (is_resource($content)) {
346		return $fileInfo->file(stream_get_meta_data($content)['uri']);
347		}
348
349		return $fileInfo->buffer($content);
350		}
351
352	View Code Duplication	public function mimeType($key)
		0 ignored issues – show Duplication introduced 2017-05-21 20:39 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...
353		{
354		try {
355		$result = $this->service->headObject($this->getOptions($key));
356		return ($result['ContentType']);
357		} catch (\Exception $e) {
358		return false;
		0 ignored issues – show Bug Best Practice introduced 2017-05-21 20:39 UTC by Report Bug Copy Issue Report The return type of `return false;` (`false`) is incompatible with the return type declared by the interface `Gaufrette\Adapter\MimeTypeProvider::mimeType` of type `string`. 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...
359		}
360		}
361		}
362

KnpLabs / Gaufrette