Psr16Adapter::deleteMultiple() - Code Metrics - Inspection of "Implemented Psr16, yay !" - PHPSocialNetwork/phpfastcache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — V6 ( cfd763...eaf7a5 )

by Georges

created 2017-01-16 22:52 UTC

Psr16Adapter::deleteMultiple() A

↳ Parent: Psr16Adapter

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	5

Duplication

Lines	8
Ratio	100 %

Importance

Changes

Metric	Value
cc	2
eloc	5
nc	2
nop	1
dl	8
loc	8
rs	9.4285
c	0
b	0
f	0

<?php
namespace phpFastCache\Helper;

use phpFastCache\CacheManager;
use phpFastCache\Core\Item\ExtendedCacheItemInterface;
use phpFastCache\Core\Pool\ExtendedCacheItemPoolInterface;
use phpFastCache\Exceptions\phpFastCacheDriverCheckException;
use phpFastCache\Exceptions\phpFastCacheInvalidArgumentException;
use phpFastCache\Exceptions\phpFastCacheRootException;
use phpFastCache\Exceptions\phpFastCacheSimpleCacheException;
use Psr\SimpleCache\CacheInterface;

/**
 * Class Psr16Adapter
 * @package phpFastCache\Helper
 */
class Psr16Adapter implements CacheInterface
{
    /**
     * @var ExtendedCacheItemPoolInterface
     */
    protected $internalCacheInstance;

    /**
     * Psr16Adapter constructor.
     * @param $driver
     * @param array $config
     * @throws phpFastCacheDriverCheckException
     */
    public function __construct($driver, array $config = [])
    {
        $this->internalCacheInstance = CacheManager::getInstance($driver, $config);
    }

    /**
     * @param string $key
     * @param null $default
     * @return mixed|null
     * @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
     */
    public function get($key, $default = null)
    {
        try {
            $cacheItemValue = $this->internalCacheInstance->getItem($key)->get();
            if ($cacheItemValue !== null) {
                return $cacheItemValue;
            } else {
                return $default;
            }
        } catch (phpFastCacheInvalidArgumentException $e) {
            throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
        }
    }

    /**
     * @param string $key
     * @param mixed $value
     * @param null $ttl
     * @return bool
     * @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
     */
    public function set($key, $value, $ttl = null)
    {
        try {
            $cacheItem = $this->internalCacheInstance
              ->getItem($key)
              ->set($value);
            if (is_int($ttl) || $ttl instanceof \DateInterval) {
                $cacheItem->expiresAfter($ttl);
            }
            return $this->internalCacheInstance->save($cacheItem);
        } catch (phpFastCacheInvalidArgumentException $e) {
            throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
        }
    }

    /**
     * @param string $key
     * @return bool
     * @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
     */
    public function delete($key)
    {
        try {
            return $this->internalCacheInstance->deleteItem($key);
        } catch (phpFastCacheInvalidArgumentException $e) {
            throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
        }
    }

    /**
     * @return bool
     * @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
     */
    public function clear()
    {
        try {
            return $this->internalCacheInstance->clear();
        } catch (phpFastCacheRootException $e) {
            throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
        }
    }

    /**
     * @param string[] $keys
     * @param null $default
     * @return array
     * @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
     */
    public function getMultiple($keys, $default = null)
    {
        try {
            return array_map(function (ExtendedCacheItemInterface $item) {
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 $item->get();
            }, $this->internalCacheInstance->getItems($keys));
        } catch (phpFastCacheInvalidArgumentException $e) {
            throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
        }
    }

    /**
     * @param string[] $values
     * @param null|int|\DateInterval $ttl
     * @return bool
     * @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
     */
    public function setMultiple($values, $ttl = null)
    {
        try {
            foreach ($values as $key => $value) {
                $cacheItem = $this->internalCacheInstance->getItem($key)->set($value);
                $this->internalCacheInstance->saveDeferred($cacheItem);
                unset($cacheItem);
            }
            return $this->internalCacheInstance->commit();
        } catch (phpFastCacheInvalidArgumentException $e) {
            throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
        }
    }

    /**
     * @param string[] $keys
     * @return bool
     * @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
     */
    public function deleteMultiple($keys)
    {
        try {
            return $this->internalCacheInstance->deleteItems($keys);
        } catch (phpFastCacheInvalidArgumentException $e) {
            throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
        }
    }

    /**
     * @param string $key
     * @return bool
     * @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
     */
    public function has($key)
    {
        try {
            return $this->internalCacheInstance->getItem($key)->isHit();
        } catch (phpFastCacheInvalidArgumentException $e) {
            throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
        }
    }
}

1		<?php
2		namespace phpFastCache\Helper;
3
4		use phpFastCache\CacheManager;
5		use phpFastCache\Core\Item\ExtendedCacheItemInterface;
6		use phpFastCache\Core\Pool\ExtendedCacheItemPoolInterface;
7		use phpFastCache\Exceptions\phpFastCacheDriverCheckException;
8		use phpFastCache\Exceptions\phpFastCacheInvalidArgumentException;
9		use phpFastCache\Exceptions\phpFastCacheRootException;
10		use phpFastCache\Exceptions\phpFastCacheSimpleCacheException;
11		use Psr\SimpleCache\CacheInterface;
12
13		/**
14		* Class Psr16Adapter
15		* @package phpFastCache\Helper
16		*/
17		class Psr16Adapter implements CacheInterface
18		{
19		/**
20		* @var ExtendedCacheItemPoolInterface
21		*/
22		protected $internalCacheInstance;
23
24		/**
25		* Psr16Adapter constructor.
26		* @param $driver
27		* @param array $config
28		* @throws phpFastCacheDriverCheckException
29		*/
30		public function __construct($driver, array $config = [])
31		{
32		$this->internalCacheInstance = CacheManager::getInstance($driver, $config);
33		}
34
35		/**
36		* @param string $key
37		* @param null $default
38		* @return mixed\|null
39		* @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
40		*/
41		public function get($key, $default = null)
42		{
43		try {
44		$cacheItemValue = $this->internalCacheInstance->getItem($key)->get();
45		if ($cacheItemValue !== null) {
46		return $cacheItemValue;
47		} else {
48		return $default;
49		}
50		} catch (phpFastCacheInvalidArgumentException $e) {
51		throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
52		}
53		}
54
55		/**
56		* @param string $key
57		* @param mixed $value
58		* @param null $ttl
59		* @return bool
60		* @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
61		*/
62		public function set($key, $value, $ttl = null)
63		{
64		try {
65		$cacheItem = $this->internalCacheInstance
66		->getItem($key)
67		->set($value);
68		if (is_int($ttl) \|\| $ttl instanceof \DateInterval) {
69		$cacheItem->expiresAfter($ttl);
70		}
71		return $this->internalCacheInstance->save($cacheItem);
72		} catch (phpFastCacheInvalidArgumentException $e) {
73		throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
74		}
75		}
76
77		/**
78		* @param string $key
79		* @return bool
80		* @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
81		*/
82	View Code Duplication	public function delete($key)
83		{
84		try {
85		return $this->internalCacheInstance->deleteItem($key);
86		} catch (phpFastCacheInvalidArgumentException $e) {
87		throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
88		}
89		}
90
91		/**
92		* @return bool
93		* @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
94		*/
95		public function clear()
96		{
97		try {
98		return $this->internalCacheInstance->clear();
99		} catch (phpFastCacheRootException $e) {
100		throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
101		}
102		}
103
104		/**
105		* @param string[] $keys
106		* @param null $default
107		* @return array
108		* @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
109		*/
110		public function getMultiple($keys, $default = null)
111		{
112		try {
113		return array_map(function (ExtendedCacheItemInterface $item) {
		0 ignored issues – show Bug Best Practice introduced 2017-01-16 22:54 UTC by Report Bug Copy Issue Report The return type of `return array_map(functio...ance->getItems($keys));` (`array`) is incompatible with the return type declared by the interface `Psr\SimpleCache\CacheInterface::getMultiple` of type `Psr\SimpleCache\iterable`. 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...
114		return $item->get();
115		}, $this->internalCacheInstance->getItems($keys));
116		} catch (phpFastCacheInvalidArgumentException $e) {
117		throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
118		}
119		}
120
121		/**
122		* @param string[] $values
123		* @param null\|int\|\DateInterval $ttl
124		* @return bool
125		* @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
126		*/
127		public function setMultiple($values, $ttl = null)
128		{
129		try {
130		foreach ($values as $key => $value) {
131		$cacheItem = $this->internalCacheInstance->getItem($key)->set($value);
132		$this->internalCacheInstance->saveDeferred($cacheItem);
133		unset($cacheItem);
134		}
135		return $this->internalCacheInstance->commit();
136		} catch (phpFastCacheInvalidArgumentException $e) {
137		throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
138		}
139		}
140
141		/**
142		* @param string[] $keys
143		* @return bool
144		* @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
145		*/
146	View Code Duplication	public function deleteMultiple($keys)
147		{
148		try {
149		return $this->internalCacheInstance->deleteItems($keys);
150		} catch (phpFastCacheInvalidArgumentException $e) {
151		throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
152		}
153		}
154
155		/**
156		* @param string $key
157		* @return bool
158		* @throws \phpFastCache\Exceptions\phpFastCacheSimpleCacheException
159		*/
160		public function has($key)
161		{
162		try {
163		return $this->internalCacheInstance->getItem($key)->isHit();
164		} catch (phpFastCacheInvalidArgumentException $e) {
165		throw new phpFastCacheSimpleCacheException($e->getMessage(), null, $e);
166		}
167		}
168		}

PHPSocialNetwork / phpfastcache

Push — V6 ( cfd763...eaf7a5 )

Psr16Adapter::deleteMultiple() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like