Flipbox\Cache\Factory

Complexity

Total Complexity

12

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
B	create()	0	35	2
A	autoGetDriver()	0	19	2
A	getDriver()	0	10	2
A	registerDriver()	0	20	2
A	registerDrivers()	0	6	2
A	getDrivers()	0	4	1

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://github.com/flipbox/cache/blob/master/LICENSE
 * @link       https://github.com/flipbox/cache
 */

namespace Flipbox\Cache;

use Flipbox\Cache\Exceptions\InvalidDriverException;
use Flipbox\Skeleton\Helpers\ArrayHelper;
use Flipbox\Skeleton\Helpers\ObjectHelper;
use Flipbox\Skeleton\Logger\AutoLoggerTrait;
use Psr\Log\LoggerInterface;
use Stash\Driver\BlackHole as DummyDriver;
use Stash\Interfaces\DriverInterface;
use Stash\Interfaces\PoolInterface;

/**
 * @author Flipbox Factory <hello@flipboxfactory.com>
 * @since 2.0.0
 */
class Factory
{

    use AutoLoggerTrait;

    /**
     * This is the default time, in seconds, that objects are cached for.
     *
     * @var int
     */
    public $defaultDuration = 432000;

    /**
     * The default driver
     *
     * @var string
     */
    public $defaultDriver = 'file';

    /**
     * Registered cache drivers
     *
     * @var DriverInterface[]
     */
    protected $registeredDrivers = [];

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

        // Manually register the default driver
        $this->registeredDrivers['dummy'] = new DummyDriver();
    }

    /*******************************************
     * CREATE
     *******************************************/

    /**
     * Create a new cache pool
     *
     * @param array $config
     * @return PoolInterface
     * @throws InvalidDriverException
     */
    public function create($config = []): PoolInterface
    {
        // Array
        $config = ArrayHelper::toArray($config);

        // Get driver from config
        if (!$driverType = ObjectHelper::findClassFromConfig($config)) {
            $driverType = $this->defaultDriver;

            $this->warning(
                "Cache pool configuration did not indicate a driver type...using default",
                [
                    'config' => $config,
                    'default' => $driverType
                ]
            );
        }

        /** @var Pool $pool */
        $pool = new Pool(
            $this->autoGetDriver($driverType)
        );

        // Set logger
        $pool->setLogger($this->getLogger());

It seems like $this->getLogger() can be null; however, setLogger() does not accept null, maybe add an additional type check?

        // Set duration
        $pool->setItemDuration(ArrayHelper::getValue(
            $config,
            'duration',
            $this->defaultDuration
        ));

        return $pool;
    }

    /**
     * Get a cache driver.  If the driver is not found, return the default.
     *
     * @param $identifier
     * @return DriverInterface
     * @throws InvalidDriverException
     */
    public function autoGetDriver($identifier): DriverInterface
    {
        if (!$driver = ArrayHelper::getValue($this->registeredDrivers, $identifier)) {
            $this->critical(
                "Cache driver not available...switching to default",
                [
                    'driver' => $identifier,
                    'default' => $this->defaultDriver,
                    'registered' => array_keys(
                        $this->registeredDrivers
                    )
                ]
            );

            // Get default driver
            $driver = $this->getDriver($this->defaultDriver);
        }
        return $driver;
    }

    /**
     * Get a cache driver
     *
     * @param $identifier
     * @return DriverInterface
     * @throws InvalidDriverException
     */
    public function getDriver($identifier): DriverInterface
    {
        if (!$driver = ArrayHelper::getValue($this->registeredDrivers, $identifier)) {
            throw new InvalidDriverException(sprintf(
                "Driver type '%s' is not registered.",
                $identifier
            ));
        }
        return $driver;
    }

    /**
     * Register a cache driver for use
     *
     * @param $identifier
     * @param DriverInterface $driver
     * @throws InvalidDriverException
     */
    public function registerDriver($identifier, DriverInterface $driver)
    {
        // Handle already taken
        if (ArrayHelper::keyExists($identifier, $this->registeredDrivers)) {
            throw new InvalidDriverException(sprintf(
                "Driver type '%s' is already registered.",
                $identifier
            ));
        }

        $this->info(
            "Registered cache driver",
            [
                'driver' => $identifier,
                'class' => get_class($driver)
            ]
        );

        $this->registeredDrivers[$identifier] = $driver;
    }

    /**
     * Register an array of drivers
     *
     * @param DriverInterface[] $drivers
     * @throws InvalidDriverException
     */
    public function registerDrivers(array $drivers)
    {
        foreach ($drivers as $handle => $driver) {
            $this->registerDriver($handle, $driver);
        }
    }

    /**
     * Get an array of registered cache drivers
     *
     * @return DriverInterface[]
     */
    public function getDrivers(): array
    {
        return $this->registeredDrivers;
    }
}