CacheItemPool::__construct() - Code Metrics - kuzmichus/cache - Measure and Improve Code Quality continuously with Scrutinizer

CacheItemPool::__construct() A
last analyzed 2016-03-01 09:05 UTC

↳ Parent: CacheItemPool

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php
/**
 *
 * PHP version 5.5
 *
 * @package Cache
 * @author  Sergey V.Kuzin <[email protected]>
 * @license MIT
 */

namespace Cache;

//require_once '/www/smarty/vendor/kuzmich/cache/vendor/psr/cache-util/src/CachePoolDeferTrait.php';

//require_once '/www/smarty/vendor/kuzmich/cache/vendor/psr/cache-util/src/BasicPoolTrait.php';

use Fig\Cache\BasicPoolTrait;
use Psr\Cache\CacheItemInterface;
use Psr\Cache\CacheItemPoolInterface;
use Psr\Cache\InvalidArgumentException;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php

class CacheItemPool implements CacheItemPoolInterface
{
    use BasicPoolTrait;
    /** @var \Doctrine\Common\Cache\CacheProvider  */
    protected $provider;

    public function __construct(\Doctrine\Common\Cache\CacheProvider $provider)
    {
        $this->provider = $provider;
    }

    /**
     * @return \Doctrine\Common\Cache\CacheProvider
     */
    public function getProvider()
    {
        return $this->provider;
    }

    /**
     * Returns a Cache Item representing the specified key.
     *
     * This method must always return an ItemInterface object, even in case of
     * a cache miss. It MUST NOT return null.
     *
     * @param string $key
     *   The key for which to return the corresponding Cache Item.
     * @return \Psr\Cache\CacheItemInterface
     *   The corresponding Cache Item.
     * @throws \Psr\Cache\InvalidArgumentException
     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     */
    public function getItem($key)
    {
        if (isset($this->deferred[$key])) {
            return $this->deferred[$key];
        }

        if (false === $this->provider->contains($key)) {
            return new CacheItem($key);
        }

        $item = $this->provider->fetch($key);
        $item->setHit(true);

        return $item;
    }

    /**
     * Returns a traversable set of cache items.
     *
     * @param array $keys
     * An indexed array of keys of items to retrieve.
     * @return array|\Traversable
     * A traversable collection of Cache Items keyed by the cache keys of
     * each item. A Cache item will be returned for each key, even if that
     * key is not found. However, if no keys are specified then an empty
     * traversable MUST be returned instead.
     */
    public function getItems(array $keys = array())
    {
        if (true === empty($keys)) {
            return [];
        }

        /*$results = $this->provider->fetchMultiple($keys);

        $items= [];
        foreach($results as $key => $result) {
            $item = new CacheItem($key);
            $item->set($result);
            $item->setProvider($this->provider);
            $items[] = $item;
        }*/
        $items = [];
        foreach ($keys as $key) {
            $items[$key] = $this->getItem($key);
        }

        return $items;
    }

    /**
     * Deletes all items in the pool.
     *
     * @return boolean
     *   True if the pool was successfully cleared. False if there was an error.
     */
    public function clear()
    {
        return $this->provider->flushAll();
    }

    /**
     * Removes multiple items from the pool.
     *
     * @param array $keys
     * An array of keys that should be removed from the pool.
     * @return static
     * The invoked object.
     */
    public function deleteItems(array $keys)
    {
        foreach ($keys as $key) {
            if (true === $this->provider->contains($key)) {
                $this->provider->delete($key);
            }
        }
        return $this;
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());
}
    }

    /**
     * Persists a cache item immediately.
     *
     * @param CacheItemInterface $item
     *   The cache item to save.
     *
     * @return static
     *   The invoked object.
     */
    public function save(CacheItemInterface $item)
    {
        $this->doSave($item);

        return $this;
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());
}
    }

    /**
     * Sets a cache item to be persisted later.
     *
     * @param CacheItemInterface $item
     *   The cache item to save.
     * @return static
     *   The invoked object.
     */
    public function saveDeferred(CacheItemInterface $item)
    {
        $this->deferred[$item->getKey()] = $item;

        return $this;
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());
}
    }

    /**
     * Persists any deferred cache items.
     *
     * @return bool
     *   TRUE if all not-yet-saved items were successfully saved. FALSE otherwise.
     */
    public function commit()
    {
        $result = true;
        foreach ($this->deferred as $key => $deferred) {
            $saveResult = $this->doSave($deferred);
            if (true === $saveResult) {
                unset($this->deferred[$key]);
            }
            $result = $result && $saveResult;
        }
        return $result;
    }

    private function doSave(CacheItemInterface $item)
    {
        $now = new \DateTime();
        $ttl = $item->getExpiration()->format('U') - $now->format('U');
        if ($ttl < 0) {
            return false;
        }
        return $this->provider->save($item->getKey(), $item, $ttl);
    }

    /**
     * Commits the specified cache items to storage.
     *
     * @param CacheItemInterface[] $items
     *
     * @return bool
     *   TRUE if all provided items were successfully saved. FALSE otherwise.
     */
    protected function write(array $items)

    {
        // TODO: Implement write() method.
    }

    /**
     * Confirms if the cache contains specified cache item.
     *
     * Note: This method MAY avoid retrieving the cached value for performance reasons.
     * This could result in a race condition with CacheItemInterface::get(). To avoid
     * such situation use CacheItemInterface::isHit() instead.
     *
     * @param string $key
     *    The key for which to check existence.
     *
     * @throws InvalidArgumentException
     *   If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
     *   MUST be thrown.
     *
     * @return bool
     *  True if item exists in the cache, false otherwise.
     */
    public function hasItem($key)
    {
        // TODO: Implement hasItem() method.
    }
}


1			<?php
2			/**
3			*
4			* PHP version 5.5
5			*
6			* @package Cache
7			* @author Sergey V.Kuzin <[email protected]>
8			* @license MIT
9			*/
10
11			namespace Cache;
12
13			//require_once '/www/smarty/vendor/kuzmich/cache/vendor/psr/cache-util/src/CachePoolDeferTrait.php';
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-03-01 09:04 UTC by Report Bug Copy Issue Report `67%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
14			//require_once '/www/smarty/vendor/kuzmich/cache/vendor/psr/cache-util/src/BasicPoolTrait.php';
15
16			use Fig\Cache\BasicPoolTrait;
17			use Psr\Cache\CacheItemInterface;
18			use Psr\Cache\CacheItemPoolInterface;
19			use Psr\Cache\InvalidArgumentException;
			0 ignored issues – show Bug introduced 2015-12-29 07:05 UTC by Report Bug Copy Issue Report This use statement conflicts with another class in this namespace, `Cache\InvalidArgumentException`. Let’s assume that you have a directory layout like this: . \|-- OtherDir \| \|-- Bar.php \| `-- Foo.php `-- SomeDir `-- Foo.php and let’s assume the following content of `Bar.php`: // Bar.php namespace OtherDir; use SomeDir\Foo; // This now conflicts the class OtherDir\Foo If both files `OtherDir/Foo.php` and `SomeDir/Foo.php` are loaded in the same runtime, you will see a PHP error such as the following: PHP Fatal error: Cannot use SomeDir\Foo as Foo because the name is already in use in OtherDir/Foo.php However, as `OtherDir/Foo.php` does not necessarily have to be loaded and the error is only triggered if it is loaded before `OtherDir/Bar.php`, this problem might go unnoticed for a while. In order to prevent this error from surfacing, you must import the namespace with a different alias: // Bar.php namespace OtherDir; use SomeDir\Foo as SomeDirFoo; // There is no conflict anymore. Loading history...
20
21			class CacheItemPool implements CacheItemPoolInterface
22			{
23			use BasicPoolTrait;
24			/** @var \Doctrine\Common\Cache\CacheProvider */
25			protected $provider;
26
27			public function __construct(\Doctrine\Common\Cache\CacheProvider $provider)
28			{
29			$this->provider = $provider;
30			}
31
32			/**
33			* @return \Doctrine\Common\Cache\CacheProvider
34			*/
35			public function getProvider()
36			{
37			return $this->provider;
38			}
39
40			/**
41			* Returns a Cache Item representing the specified key.
42			*
43			* This method must always return an ItemInterface object, even in case of
44			* a cache miss. It MUST NOT return null.
45			*
46			* @param string $key
47			* The key for which to return the corresponding Cache Item.
48			* @return \Psr\Cache\CacheItemInterface
49			* The corresponding Cache Item.
50			* @throws \Psr\Cache\InvalidArgumentException
51			* If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
52			* MUST be thrown.
53			*/
54			public function getItem($key)
55			{
56			if (isset($this->deferred[$key])) {
57			return $this->deferred[$key];
58			}
59
60			if (false === $this->provider->contains($key)) {
61			return new CacheItem($key);
62			}
63
64			$item = $this->provider->fetch($key);
65			$item->setHit(true);
66
67			return $item;
68			}
69
70			/**
71			* Returns a traversable set of cache items.
72			*
73			* @param array $keys
74			* An indexed array of keys of items to retrieve.
75			* @return array\|\Traversable
76			* A traversable collection of Cache Items keyed by the cache keys of
77			* each item. A Cache item will be returned for each key, even if that
78			* key is not found. However, if no keys are specified then an empty
79			* traversable MUST be returned instead.
80			*/
81			public function getItems(array $keys = array())
82			{
83			if (true === empty($keys)) {
84			return [];
85			}
86
87			/*$results = $this->provider->fetchMultiple($keys);
			0 ignored issues – show Unused Code Comprehensibility introduced 2016-03-01 09:04 UTC by Report Bug Copy Issue Report `61%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
88			$items= [];
89			foreach($results as $key => $result) {
90			$item = new CacheItem($key);
91			$item->set($result);
92			$item->setProvider($this->provider);
93			$items[] = $item;
94			}*/
95			$items = [];
96			foreach ($keys as $key) {
97			$items[$key] = $this->getItem($key);
98			}
99
100			return $items;
101			}
102
103			/**
104			* Deletes all items in the pool.
105			*
106			* @return boolean
107			* True if the pool was successfully cleared. False if there was an error.
108			*/
109			public function clear()
110			{
111			return $this->provider->flushAll();
112			}
113
114			/**
115			* Removes multiple items from the pool.
116			*
117			* @param array $keys
118			* An array of keys that should be removed from the pool.
119			* @return static
120			* The invoked object.
121			*/
122			public function deleteItems(array $keys)
123			{
124			foreach ($keys as $key) {
125			if (true === $this->provider->contains($key)) {
126			$this->provider->delete($key);
127			}
128			}
129			return $this;
			0 ignored issues – show Bug Best Practice introduced 2016-03-01 09:04 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`Cache\CacheItemPool`) is incompatible with the return type declared by the interface `Psr\Cache\CacheItemPoolInterface::deleteItems` of type `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...
130			}
131
132			/**
133			* Persists a cache item immediately.
134			*
135			* @param CacheItemInterface $item
136			* The cache item to save.
137			*
138			* @return static
139			* The invoked object.
140			*/
141			public function save(CacheItemInterface $item)
142			{
143			$this->doSave($item);
144
145			return $this;
			0 ignored issues – show Bug Best Practice introduced 2016-03-01 09:04 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`Cache\CacheItemPool`) is incompatible with the return type declared by the interface `Psr\Cache\CacheItemPoolInterface::save` of type `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...
146			}
147
148			/**
149			* Sets a cache item to be persisted later.
150			*
151			* @param CacheItemInterface $item
152			* The cache item to save.
153			* @return static
154			* The invoked object.
155			*/
156			public function saveDeferred(CacheItemInterface $item)
157			{
158			$this->deferred[$item->getKey()] = $item;
159
160			return $this;
			0 ignored issues – show Bug Best Practice introduced 2016-03-01 09:04 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`Cache\CacheItemPool`) is incompatible with the return type declared by the interface `Psr\Cache\CacheItemPoolInterface::saveDeferred` of type `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...
161			}
162
163			/**
164			* Persists any deferred cache items.
165			*
166			* @return bool
167			* TRUE if all not-yet-saved items were successfully saved. FALSE otherwise.
168			*/
169			public function commit()
170			{
171			$result = true;
172			foreach ($this->deferred as $key => $deferred) {
173			$saveResult = $this->doSave($deferred);
174			if (true === $saveResult) {
175			unset($this->deferred[$key]);
176			}
177			$result = $result && $saveResult;
178			}
179			return $result;
180			}
181
182			private function doSave(CacheItemInterface $item)
183			{
184			$now = new \DateTime();
185			$ttl = $item->getExpiration()->format('U') - $now->format('U');
186			if ($ttl < 0) {
187			return false;
188			}
189			return $this->provider->save($item->getKey(), $item, $ttl);
190			}
191
192			/**
193			* Commits the specified cache items to storage.
194			*
195			* @param CacheItemInterface[] $items
196			*
197			* @return bool
198			* TRUE if all provided items were successfully saved. FALSE otherwise.
199			*/
200			protected function write(array $items)
			0 ignored issues – show Unused Code introduced 2015-12-29 07:05 UTC by Report Bug Copy Issue Report The parameter `$items` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
201			{
202			// TODO: Implement write() method.
203			}
204
205			/**
206			* Confirms if the cache contains specified cache item.
207			*
208			* Note: This method MAY avoid retrieving the cached value for performance reasons.
209			* This could result in a race condition with CacheItemInterface::get(). To avoid
210			* such situation use CacheItemInterface::isHit() instead.
211			*
212			* @param string $key
213			* The key for which to check existence.
214			*
215			* @throws InvalidArgumentException
216			* If the $key string is not a legal value a \Psr\Cache\InvalidArgumentException
217			* MUST be thrown.
218			*
219			* @return bool
220			* True if item exists in the cache, false otherwise.
221			*/
222			public function hasItem($key)
223			{
224			// TODO: Implement hasItem() method.
225			}
226			}
227

kuzmichus / cache

CacheItemPool::__construct() A last analyzed 2016-03-01 09:05 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CacheItemPool::__construct() A
last analyzed 2016-03-01 09:05 UTC