Charcoal\App\Config\CacheConfig

Complexity

Total Complexity

13

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	defaults()	0	8	1
A	setTypes()	0	8	2
A	validTypes()	0	12	1
A	addType()	0	10	2
A	types()	0	4	1
A	setDefaultTtl()	0	10	2
A	defaultTtl()	0	4	1
A	setPrefix()	0	10	2
A	prefix()	0	4	1

<?php

namespace Charcoal\App\Config;

use InvalidArgumentException;

// From 'charcoal-config'
use Charcoal\Config\AbstractConfig;

/**
 * Cache Configuration
 */
class CacheConfig extends AbstractConfig
{
    /**
     * Human-readable intervals in seconds.
     */
    const HOUR_IN_SECONDS = 3600;
    const DAY_IN_SECONDS  = 86400;
    const WEEK_IN_SECONDS = 604800;

    /**
     * Cache driver(s).
     *
     * @var array
     */
    private $types = [ 'memory' ];

    /**
     * Time-to-live in seconds.
     *
     * @var integer
     */
    private $defaultTtl = self::WEEK_IN_SECONDS;

    /**
     * Cache namespace.
     *
     * @var string
     */
    private $prefix = 'charcoal';

    /**
     * @return array
     */
    public function defaults()
    {
        return [
            'types'       => [ 'memory' ],
            'default_ttl' => self::WEEK_IN_SECONDS,
            'prefix'      => 'charcoal'
        ];
    }

    /**
     * Set the types (drivers) of cache.
     *
     * The first cache actually available on the system will be the one used for caching.
     *
     * @param string[] $types The types of cache to try using, in order of priority.
     * @return CacheConfig Chainable
     */
    public function setTypes(array $types)
    {
        $this->types = [];
        foreach ($types as $type) {
            $this->addType($type);
        }
        return $this;
    }

    /**
     * Get the valid types (drivers).
     *
     * @return array
     */
    public function validTypes()
    {
        return [
            'apc',
            'file',
            'db',
            'memcache',
            'memory',
            'noop',
            'redis'
        ];
    }

    /**
     * @param string $type The cache type.
     * @throws InvalidArgumentException If the type is not a string.
     * @return CacheConfig Chainable
     */
    public function addType($type)
    {
        if (!in_array($type, $this->validTypes())) {
            throw new InvalidArgumentException(
                sprintf('Invalid cache type: "%s"', $type)
            );
        }
        $this->types[] = $type;
        return $this;
    }

    /**
     * @return array
     */
    public function types()
    {
        return $this->types;
    }

    /**
     * @param integer $ttl The time-to-live, in seconds.
     * @throws InvalidArgumentException If the TTL argument is not numeric.
     * @return CacheConfig Chainable
     */
    public function setDefaultTtl($ttl)
    {
        if (!is_numeric($ttl)) {
            throw new InvalidArgumentException(
                'TTL must be an integer (seconds).'
            );
        }
        $this->defaultTtl = (int)$ttl;
        return $this;
    }

    /**
     * @return integer
     */
    public function defaultTtl()
    {
        return $this->defaultTtl;
    }

    /**
     * @param string $prefix The cache prefix (or namespace).
     * @throws InvalidArgumentException If the prefix is not a string.
     * @return CacheConfig Chainable
     */
    public function setPrefix($prefix)
    {
        if (!is_string($prefix)) {
            throw new InvalidArgumentException(
                'Prefix must be a string.'
            );
        }
        $this->prefix = $prefix;
        return $this;
    }

    /**
     * @return string
     */
    public function prefix()
    {
        return $this->prefix;
    }
}