AmazonS3Resolver::setObjectUrlOption() - Code Metrics - Inspection of "add @Event annotation to let IDEs known event name..." - liip/LiipImagineBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#732)

by 12345

created 2016-05-05 10:14 UTC

AmazonS3Resolver::setObjectUrlOption() A

↳ Parent: AmazonS3Resolver

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	6
rs	9.4285
cc	1
eloc	3
nc	1
nop	2

<?php

namespace Liip\ImagineBundle\Imagine\Cache\Resolver;

use Liip\ImagineBundle\Binary\BinaryInterface;
use Liip\ImagineBundle\Exception\Imagine\Cache\Resolver\NotStorableException;
use Psr\Log\LoggerInterface;

class AmazonS3Resolver implements ResolverInterface
{
    /**
     * @var \AmazonS3
     */
    protected $storage;

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

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

    /**
     * @var array
     */
    protected $objUrlOptions;

    /**
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * Constructs a cache resolver storing images on Amazon S3.
     *
     * @param \AmazonS3 $storage       The Amazon S3 storage API. It's required to know authentication information.
     * @param string    $bucket        The bucket name to operate on.
     * @param string    $acl           The ACL to use when storing new objects. Default: owner read/write, public read
     * @param array     $objUrlOptions A list of options to be passed when retrieving the object url from Amazon S3.
     */
    public function __construct(\AmazonS3 $storage, $bucket, $acl = \AmazonS3::ACL_PUBLIC, array $objUrlOptions = array())
    {
        $this->storage = $storage;
        $this->bucket = $bucket;
        $this->acl = $acl;
        $this->objUrlOptions = $objUrlOptions;
    }

    /**
     * @param LoggerInterface $logger
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    /**
     * {@inheritdoc}
     */
    public function isStored($path, $filter)
    {
        return $this->objectExists($this->getObjectPath($path, $filter));
    }

    /**
     * {@inheritdoc}
     */
    public function resolve($path, $filter)
    {
        return $this->getObjectUrl($this->getObjectPath($path, $filter));
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 store(BinaryInterface $binary, $path, $filter)
    {
        $objectPath = $this->getObjectPath($path, $filter);

        $storageResponse = $this->storage->create_object($this->bucket, $objectPath, array(
            'body' => $binary->getContent(),
            'contentType' => $binary->getMimeType(),
            'length' => strlen($binary->getContent()),
            'acl' => $this->acl,
        ));

        if (!$storageResponse->isOK()) {
            $this->logError('The object could not be created on Amazon S3.', array(
                'objectPath' => $objectPath,
                'filter' => $filter,
                's3_response' => $storageResponse,
            ));

            throw new NotStorableException('The object could not be created on Amazon S3.');
        }
    }

    /**
     * {@inheritdoc}
     */
    public function remove(array $paths, array $filters)
    {
        if (empty($paths) && empty($filters)) {
            return;
        }

        if (empty($paths)) {
            if (!$this->storage->delete_all_objects($this->bucket, sprintf('/%s/i', implode('|', $filters)))) {
                $this->logError('The objects could not be deleted from Amazon S3.', array(
                    'filters' => implode(', ', $filters),
                    'bucket' => $this->bucket,
                ));
            }

            return;
        }

        foreach ($filters as $filter) {
            foreach ($paths as $path) {
                $objectPath = $this->getObjectPath($path, $filter);
                if (!$this->objectExists($objectPath)) {
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
                    continue;
                }

                if (!$this->storage->delete_object($this->bucket, $objectPath)->isOK()) {
                    $this->logError('The objects could not be deleted from Amazon S3.', array(
                        'filter' => $filter,
                        'bucket' => $this->bucket,
                        'path' => $path,
                    ));
                }
            }
        }
    }

    /**
     * Sets a single option to be passed when retrieving an objects URL.
     *
     * If the option is already set, it will be overwritten.
     *
     * @see \AmazonS3::get_object_url() for available options.
     *
     * @param string $key   The name of the option.
     * @param mixed  $value The value to be set.
     *
     * @return AmazonS3Resolver $this
     */
    public function setObjectUrlOption($key, $value)
    {
        $this->objUrlOptions[$key] = $value;

        return $this;
    }

    /**
     * Returns the object path within the bucket.
     *
     * @param string $path   The base path of the resource.
     * @param string $filter The name of the imagine filter in effect.
     *
     * @return string The path of the object on S3.
     */
    protected function getObjectPath($path, $filter)
    {
        return str_replace('//', '/', $filter.'/'.$path);
    }

    /**
     * Returns the URL for an object saved on Amazon S3.
     *
     * @param string $path
     *
     * @return string
     */
    protected function getObjectUrl($path)
    {
        return $this->storage->get_object_url($this->bucket, $path, 0, $this->objUrlOptions);
    }

    /**
     * Checks whether an object exists.
     *
     * @param string $objectPath
     *
     * @return bool
     */
    protected function objectExists($objectPath)
    {
        return $this->storage->if_object_exists($this->bucket, $objectPath);
    }

    /**
     * @param mixed $message
     * @param array $context
     */
    protected function logError($message, array $context = array())
    {
        if ($this->logger) {
            $this->logger->error($message, $context);
        }
    }
}


1			<?php
2
3			namespace Liip\ImagineBundle\Imagine\Cache\Resolver;
4
5			use Liip\ImagineBundle\Binary\BinaryInterface;
6			use Liip\ImagineBundle\Exception\Imagine\Cache\Resolver\NotStorableException;
7			use Psr\Log\LoggerInterface;
8
9			class AmazonS3Resolver implements ResolverInterface
10			{
11			/**
12			* @var \AmazonS3
13			*/
14			protected $storage;
15
16			/**
17			* @var string
18			*/
19			protected $bucket;
20
21			/**
22			* @var string
23			*/
24			protected $acl;
25
26			/**
27			* @var array
28			*/
29			protected $objUrlOptions;
30
31			/**
32			* @var LoggerInterface
33			*/
34			protected $logger;
35
36			/**
37			* Constructs a cache resolver storing images on Amazon S3.
38			*
39			* @param \AmazonS3 $storage The Amazon S3 storage API. It's required to know authentication information.
40			* @param string $bucket The bucket name to operate on.
41			* @param string $acl The ACL to use when storing new objects. Default: owner read/write, public read
42			* @param array $objUrlOptions A list of options to be passed when retrieving the object url from Amazon S3.
43			*/
44			public function __construct(\AmazonS3 $storage, $bucket, $acl = \AmazonS3::ACL_PUBLIC, array $objUrlOptions = array())
45			{
46			$this->storage = $storage;
47			$this->bucket = $bucket;
48			$this->acl = $acl;
49			$this->objUrlOptions = $objUrlOptions;
50			}
51
52			/**
53			* @param LoggerInterface $logger
54			*/
55			public function setLogger(LoggerInterface $logger)
56			{
57			$this->logger = $logger;
58			}
59
60			/**
61			* {@inheritdoc}
62			*/
63			public function isStored($path, $filter)
64			{
65			return $this->objectExists($this->getObjectPath($path, $filter));
66			}
67
68			/**
69			* {@inheritdoc}
70			*/
71			public function resolve($path, $filter)
72			{
73			return $this->getObjectUrl($this->getObjectPath($path, $filter));
			0 ignored issues – show Bug Best Practice introduced 2015-11-24 10:50 UTC by Report Bug Copy Issue Report The return type of `return $this->getObjectU...tPath($path, $filter));` (`CFResponse`) is incompatible with the return type declared by the interface `Liip\ImagineBundle\Imagi...olverInterface::resolve` 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...
74			}
75
76			/**
77			* {@inheritdoc}
78			*/
79			public function store(BinaryInterface $binary, $path, $filter)
80			{
81			$objectPath = $this->getObjectPath($path, $filter);
82
83			$storageResponse = $this->storage->create_object($this->bucket, $objectPath, array(
84			'body' => $binary->getContent(),
85			'contentType' => $binary->getMimeType(),
86			'length' => strlen($binary->getContent()),
87			'acl' => $this->acl,
88			));
89
90			if (!$storageResponse->isOK()) {
91			$this->logError('The object could not be created on Amazon S3.', array(
92			'objectPath' => $objectPath,
93			'filter' => $filter,
94			's3_response' => $storageResponse,
95			));
96
97			throw new NotStorableException('The object could not be created on Amazon S3.');
98			}
99			}
100
101			/**
102			* {@inheritdoc}
103			*/
104			public function remove(array $paths, array $filters)
105			{
106			if (empty($paths) && empty($filters)) {
107			return;
108			}
109
110			if (empty($paths)) {
111			if (!$this->storage->delete_all_objects($this->bucket, sprintf('/%s/i', implode('\|', $filters)))) {
112			$this->logError('The objects could not be deleted from Amazon S3.', array(
113			'filters' => implode(', ', $filters),
114			'bucket' => $this->bucket,
115			));
116			}
117
118			return;
119			}
120
121			foreach ($filters as $filter) {
122			foreach ($paths as $path) {
123			$objectPath = $this->getObjectPath($path, $filter);
124			if (!$this->objectExists($objectPath)) {
			0 ignored issues – show Bug Best Practice introduced 2015-11-24 10:50 UTC by Report Bug Copy Issue Report The expression `$this->objectExists($objectPath)` of type `boolean\|null` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
125			continue;
126			}
127
128			if (!$this->storage->delete_object($this->bucket, $objectPath)->isOK()) {
129			$this->logError('The objects could not be deleted from Amazon S3.', array(
130			'filter' => $filter,
131			'bucket' => $this->bucket,
132			'path' => $path,
133			));
134			}
135			}
136			}
137			}
138
139			/**
140			* Sets a single option to be passed when retrieving an objects URL.
141			*
142			* If the option is already set, it will be overwritten.
143			*
144			* @see \AmazonS3::get_object_url() for available options.
145			*
146			* @param string $key The name of the option.
147			* @param mixed $value The value to be set.
148			*
149			* @return AmazonS3Resolver $this
150			*/
151			public function setObjectUrlOption($key, $value)
152			{
153			$this->objUrlOptions[$key] = $value;
154
155			return $this;
156			}
157
158			/**
159			* Returns the object path within the bucket.
160			*
161			* @param string $path The base path of the resource.
162			* @param string $filter The name of the imagine filter in effect.
163			*
164			* @return string The path of the object on S3.
165			*/
166			protected function getObjectPath($path, $filter)
167			{
168			return str_replace('//', '/', $filter.'/'.$path);
169			}
170
171			/**
172			* Returns the URL for an object saved on Amazon S3.
173			*
174			* @param string $path
175			*
176			* @return string
177			*/
178			protected function getObjectUrl($path)
179			{
180			return $this->storage->get_object_url($this->bucket, $path, 0, $this->objUrlOptions);
181			}
182
183			/**
184			* Checks whether an object exists.
185			*
186			* @param string $objectPath
187			*
188			* @return bool
189			*/
190			protected function objectExists($objectPath)
191			{
192			return $this->storage->if_object_exists($this->bucket, $objectPath);
193			}
194
195			/**
196			* @param mixed $message
197			* @param array $context
198			*/
199			protected function logError($message, array $context = array())
200			{
201			if ($this->logger) {
202			$this->logger->error($message, $context);
203			}
204			}
205			}
206

liip / LiipImagineBundle

Pull Request — master (#732)

AmazonS3Resolver::setObjectUrlOption() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like