Comodojo\Cache\Providers\AbstractEnhancedProvider

Complexity

Total Complexity

35

Size/Duplication

Total Lines	266
Duplicated Lines	53.01 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
	getStats()	0	1	?
B	getItem()	0	24	4
A	hasItem()	20	20	3
A	clear()	0	16	2
A	clearNamespace()	16	16	2
A	deleteItem()	20	20	3
A	save()	0	20	3
A	test()	19	19	2
B	getItems()	0	31	5
A	deleteItems()	16	16	2
A	saveDeferred()	11	11	1
B	commit()	25	25	4
A	checkQueueNamespace()	14	14	3

<?php namespace Comodojo\Cache\Providers;

use \Comodojo\Cache\Traits\StatefulTrait;
use \Comodojo\Cache\Traits\NamespaceTrait;
use \Comodojo\Cache\Interfaces\EnhancedCacheItemPoolInterface;
use \Comodojo\Cache\Components\UniqueId;
use \Psr\Log\LoggerInterface;
use \Comodojo\Cache\Item;
use \Comodojo\Cache\Components\KeyValidator;
use \Psr\Cache\CacheItemInterface;
use \DateTime;
use \Comodojo\Exception\CacheException;
use \Comodojo\Exception\InvalidCacheArgumentException;
use \Exception;

/**
 * Abstract stateful provider implementation
 *
 * @package     Comodojo Spare Parts
 * @author      Marco Giovinazzi <marco.giovinazzi@comodojo.org>
 * @license     MIT
 *
 * LICENSE:
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

abstract class AbstractEnhancedProvider
    extends AbstractProvider

The extends keyword must be on the same line as the class name

Expected 0 spaces between "AbstractProvider" and comma; 1 found

    implements EnhancedCacheItemPoolInterface {

The implements keyword must be on the same line as the class name

    use StatefulTrait;
    use NamespaceTrait;

    protected $driver;

    private $queue = [];

    public function __construct(LoggerInterface $logger = null) {

        parent::__construct($logger);

        $this->setId(UniqueId::get())->test();

    }

    abstract public function getStats();

    public function getItem($key) {

        if ( KeyValidator::validateKey($key) === false ) {
            throw new InvalidCacheArgumentException('Invalid key provided');
        }

        try {

            $data = $this->driver->get($key, $this->getNamespace());

        } catch (Exception $e) {

            $this->setState(self::CACHE_ERROR, $e->getMessage());
            $data = null;

        }

        if ( $data === null ) return new Item($key);

        $item = new Item($key, true);

        return $item->set(unserialize($data));

    }

    public function hasItem($key) {

This method seems to be duplicated in your project.

        if ( KeyValidator::validateKey($key) === false ) {
            throw new InvalidCacheArgumentException('Invalid key provided');
        }

        try {

            $data = $this->driver->has($key, $this->getNamespace());

        } catch (Exception $e) {

            $this->setState(self::CACHE_ERROR, $e->getMessage());
            $data = false;

        }

        return $data;

    }

    public function clear() {

        try {

            $data = $this->driver->clear();

        } catch (Exception $e) {

            $this->setState(self::CACHE_ERROR, $e->getMessage());
            $data = false;

        }

        return $data;

    }

    public function clearNamespace() {

This method seems to be duplicated in your project.

        try {

            $data = $this->driver->clear($this->getNamespace());

        } catch (Exception $e) {

            $this->setState(self::CACHE_ERROR, $e->getMessage());
            $data = false;

        }

        return $data;

    }

    public function deleteItem($key) {

This method seems to be duplicated in your project.

        if ( KeyValidator::validateKey($key) === false ) {
            throw new InvalidCacheArgumentException('Invalid key provided');
        }

        try {

            $data = $this->driver->delete($key, $this->getNamespace());

        } catch (Exception $e) {

            $this->setState(self::CACHE_ERROR, $e->getMessage());
            $data = false;

        }

        return $data;

    }

    public function save(CacheItemInterface $item) {

        $ttl = $item->getTtl();

        if ( $ttl < 0 ) return false;

        try {

            $data = $this->driver->set($item->getKey(), $this->getNamespace(), serialize($item->getRaw()), $ttl);

        } catch (Exception $e) {

            $this->setState(self::CACHE_ERROR, $e->getMessage());
            $data = false;

        }

        return $data;

    }

    public function test() {

This method seems to be duplicated in your project.

        if ( $this->driver->test() ) {

            $this->setState(self::CACHE_SUCCESS);

            return true;

        }

        $error = $this->driver->getName()." driver unavailable, disabling provider ".$this->getId()." administratively";

        $this->logger->error($error);

        $this->setState(self::CACHE_ERROR, $error);

        return false;

    }

    public function getItems(array $keys = []) {

        if ( empty($keys) ) return [];

        $result = [];

        try {

            $data = $this->driver->getMultiple($keys, $this->getNamespace());

        } catch (Exception $e) {

            $this->setState(self::CACHE_ERROR, $e->getMessage());
            $data = array_combine($keys, array_fill(0, count($keys), null));

        }

        foreach ( $data as $key => $value ) {

            if ( $value == null ) {
                $result[$key] = new Item($key);
            } else {
                $result[$key] = new Item($key, true);
                $result[$key]->set(unserialize($value));
            }

        }

        return $result;

    }

    public function deleteItems(array $keys) {

This method seems to be duplicated in your project.

        try {

            $data = $this->driver->deleteMultiple($keys, $this->getNamespace());

        } catch (Exception $e) {

            $this->setState(self::CACHE_ERROR, $e->getMessage());
            $data = false;

        }

        return $data;

    }

    public function saveDeferred(CacheItemInterface $item) {

This method seems to be duplicated in your project.

        $this->checkQueueNamespace(true);

        $namespace = $this->getNamespace();

        $this->queue[$namespace][$item->getKey()] = $item;

        return true;

    }

    public function commit() {

This method seems to be duplicated in your project.

        $result = [];

        $active_namespace = $this->getNamespace();

        foreach ($this->queue as $namespace => $queue) {

            $this->setNamespace($namespace);

            foreach ($queue as $key => $item) {

                $result[] = $this->save($item);

            }

        }

        $this->queue = [];

        $this->setNamespace($active_namespace);

        return in_array(false, $result) ? false : true;

    }

    private function checkQueueNamespace($create = false) {

This method seems to be duplicated in your project.

        $namespace = $this->getNamespace();

        if ( array_key_exists($namespace, $this->queue) ) {
            return true;
        } else if ( $create ) {
            $this->queue[$namespace] = [];
            return true;
        } else {
            return false;
        }

    }

}