Comodojo\Cache\Manager

Complexity

Total Complexity

34

Size/Duplication

Total Lines	247
Duplicated Lines	44.94 %

Coupling/Cohesion

Components	2
Dependencies	11

Test Coverage

Coverage

94.25%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	23	23	1
A	addProvider()	0	5	1
A	getItem()	0	5	1
A	hasItem()	0	5	1
B	deleteItem()	19	19	5
B	save()	0	26	6
A	selectFrom()	13	19	3
A	fromSingleProvider()	0	9	2
B	fromAllProviders()	14	35	5
B	traverse()	23	51	6
A	createFromConfiguration()	19	19	3

<?php namespace Comodojo\Cache;

use \Comodojo\Cache\Item;
use \Comodojo\Cache\Providers\AbstractProvider;
use \Comodojo\Cache\Providers\Vacuum;
use \Comodojo\Cache\Interfaces\CacheItemPoolManagerInterface;
use \Comodojo\Cache\Interfaces\EnhancedCacheItemPoolInterface;
use \Comodojo\Cache\Traits\NamespaceTrait;
use \Comodojo\Cache\Traits\BasicCacheItemPoolTrait;
use \Comodojo\Cache\Traits\GenericManagerTrait;
use \Comodojo\Cache\Components\StackManager;
use \Comodojo\Foundation\Validation\DataFilter;
use \Comodojo\Cache\Components\ConfigurationParser;
use \Comodojo\Foundation\Base\Configuration;
use \Psr\Cache\CacheItemInterface;
use \Psr\Log\LoggerInterface;
use \ArrayObject;

/**
 * @package     Comodojo Cache
 * @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.
 */

class Manager extends AbstractProvider implements CacheItemPoolManagerInterface {

    use NamespaceTrait, GenericManagerTrait {
        GenericManagerTrait::setNamespace insteadof NamespaceTrait;
    }
    use BasicCacheItemPoolTrait;

    const DEFAULT_PICK_MODE = 1;

    protected $pick_mode;

    protected $stack;

    protected $align_cache;

    protected $vacuum;

    protected $selected;

    public function __construct(

This method seems to be duplicated in your project.

        $pick_mode = null,
        LoggerInterface $logger = null,
        $align_cache = true,
        $flap_interval = null
    ) {

        $this->pick_mode = DataFilter::filterInteger($pick_mode, 1, 6, self::DEFAULT_PICK_MODE);

1 is of type integer, but the function expects a array.

        $this->align_cache = DataFilter::filterBoolean($align_cache, false);

$align_cache is of type boolean, but the function expects a array.

        $stack = new ArrayObject([]);

        $this->stack = new StackManager($stack->getIterator());
        $this->stack->setFlapInterval($flap_interval);

        parent::__construct($logger);

        $this->vacuum = new Vacuum([], $this->logger);

        $this->logger->debug("Cache manager online; pick mode ".$this->pick_mode);

    }

    public function addProvider(EnhancedCacheItemPoolInterface $provider, $weight = 0) {

        return $this->genericAddProvider($provider, $weight);

    }

    public function getItem($key) {

        return $this->selectFrom('GET', $key);

    }

    public function hasItem($key) {

        return $this->selectFrom('HAS', $key);

    }

    public function deleteItem($key) {

This method seems to be duplicated in your project.

        if ( iterator_count($this->stack) == 0 ) return $this->vacuum->deleteItem($key);

        if ( $this->align_cache === false && $this->pick_mode < 5 ) {
            return $this->selectProvider()->deleteItem($key);
        }

        $result = [];

        foreach ( $this->stack as $provider ) {

            $result[] = $provider[0]->deleteItem($key);

        }

        return !in_array(false, $result);

    }

    public function save(CacheItemInterface $item) {

        if ( iterator_count($this->stack) == 0 ) return $this->vacuum->save($item);

        if ( $this->align_cache === false && $this->pick_mode < 5 ) {
            return $this->selectProvider()->save($item);
        }

        $result = [];

        foreach ( $this->stack as $provider ) {

            $pro = $provider[0];

            $provider_result = $pro->save($item);

            $this->logger->debug("Saving item ".$item->getKey()." into provider ".
                $pro->getId().": ".($provider_result ? "OK" : "NOK - ".$pro->getStateMessage()));

            $result[] = $provider_result;

        }

        return !in_array(false, $result);

    }

    public static function createFromConfiguration(Configuration $configuration, LoggerInterface $logger, $stanza = null) {

This method seems to be duplicated in your project.

        list($enable, $manager_configuration, $providers) = ConfigurationParser::parse($configuration, $logger, $stanza);

        $manager = new Manager(...$manager_configuration);

        if ( $enable ) {
            foreach ( $providers as $name => $provider ) {
                $instance = $provider->instance;
                $weight = $provider->weight;
                $id = $instance->getId();
                $logger->debug("Adding provider $name ($id) to cache manager (w $weight)");
                $manager->addProvider($instance, $weight);
            }
        }

        return $manager;

    }

    protected function selectFrom($mode, $key) {

        if ( $this->pick_mode < 5 ) {

This code seems to be duplicated across your project.

            $result = $this->fromSingleProvider($mode, $key);

        } else if ( $this->pick_mode == 5 ) {

            $result = $this->fromAllProviders($mode, $key);

        } else {

            $result = $this->traverse($mode, $key);

        }

        return $result;

    }

    protected function fromSingleProvider($mode, $key) {

        $provider = $this->selectProvider();

        if ( $mode == 'HAS' ) return $provider->hasItem($key);

        return $provider->getItem($key);

    }

    protected function fromAllProviders($mode, $key) {

        $result = [];

        if ( $mode == 'GET' ) {

            foreach ( $this->stack as $provider ) {

                $result[] = $provider[0]->getItem($key);

                // selected provider has no sense in this case
                $this->selected = $provider[0];

            }

            if ( count(array_unique($result)) == 1 ) return $result[0];

            return new Item($key);

        } else {

This code seems to be duplicated across your project.

            foreach ( $this->stack as $provider ) {

                $result[] = $provider[0]->hasItem($key);

                // selected provider has no sense in this case
                $this->selected = $provider[0];

            }

            return !in_array(false, $result);

        }

    }

    protected function traverse($mode, $key) {

        $this->stack->rewind();

        if ( $mode == 'GET' ) {

            foreach ( $this->stack as $provider ) {

                $item = $provider[0]->getItem($key);

                if ( $item->isHit() ) {

                    // selected provider has no sense in this case
                    $this->selected = $provider[0];

                    return $item;

                }

            }

            // selected provider has no sense in this case
            $this->selected = $this->vacuum;

            return new Item($key);

        } else {

This code seems to be duplicated across your project.

            foreach ( $this->stack as $provider ) {

                $item = $provider[0]->hasItem($key);

                if ( $item === true ) {

                    // selected provider has no sense in this case
                    $this->selected = $provider[0];

                    return true;

                }

            }

            // selected provider has no sense in this case
            $this->selected = $this->vacuum;

            return false;

        }

    }

}