AssetManager\Core\Service\AssetCacheManager

Complexity

Total Complexity

20

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	setCache()	0	13	2
B	getProvider()	0	29	6
B	getCacheProviderConfig()	0	17	6
B	classMapper()	0	19	5

<?php

namespace AssetManager\Core\Service;

use Assetic\Asset\AssetCache;
use Assetic\Asset\AssetInterface;
use Assetic\Cache\CacheInterface;
use Psr\Container\ContainerInterface;

/**
 * Asset Cache Manager.  Sets asset cache based on configuration.
 */
class AssetCacheManager
{
    /**
     * @var \Psr\Container\ContainerInterface;
     */
    protected $container;

    /**
     * @var array Cache configuration.
     */
    protected $config = array();

    /**
     * Construct the AssetCacheManager
     *
     * @param   ContainerInterface $container
     * @param   array              $config
     */
    public function __construct(
        ContainerInterface $container,
        $config
    ) {
        $this->container = $container;
        $this->config = $config;
    }

    /**
     * Set the cache (if any) on the asset, and return the new AssetCache.
     *
     * @param string         $path  Path to asset
     * @param AssetInterface $asset Assetic Asset Interface
     *
     * @return  AssetInterface|CacheInterface
     */
    public function setCache($path, AssetInterface $asset)
    {
        $provider = $this->getProvider($path);

        if (!$provider instanceof CacheInterface) {
            return $asset;
        }

        $assetCache             = new AssetCache($asset, $provider);
        $assetCache->mimetype   = $asset->mimetype;

The property mimetype does not seem to exist in Assetic\Asset\AssetCache.

Accessing mimetype on the interface Assetic\Asset\AssetInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        return $assetCache;
    }

    /**
     * Get the cache provider.  First checks to see if the provider is callable,
     * then will attempt to get it from the service locator, finally will fallback
     * to a class mapper.
     *
     * @param $path
     *
     * @return array
     */
    private function getProvider($path)
    {
        $cacheProvider = $this->getCacheProviderConfig($path);

        if (!$cacheProvider) {
            return null;
        }

        if (is_string($cacheProvider['cache']) &&
            $this->container->has($cacheProvider['cache'])
        ) {
            return $this->container->get($cacheProvider['cache']);
        }

        // Left here for BC.  Please consider defining a ZF2 service instead.
        if (is_callable($cacheProvider['cache'])) {
            return call_user_func($cacheProvider['cache'], $path);
        }

        $dir = '';
        $class = $cacheProvider['cache'];

        if (!empty($cacheProvider['options']['dir'])) {
            $dir = $cacheProvider['options']['dir'];
        }

        $class = $this->classMapper($class);
        return new $class($dir, $path);
    }

    /**
     * Get the cache provider config.  Use default values if defined.
     *
     * @param $path
     *
     * @return null|array Cache config definition.  Returns null if not found in
     *                    config.
     */
    private function getCacheProviderConfig($path)
    {
        $cacheProvider = null;

        if (!empty($this->config[$path]) && !empty($this->config[$path]['cache'])) {
            $cacheProvider = $this->config[$path];
        }

        if (!$cacheProvider
            && !empty($this->config['default'])
            && !empty($this->config['default']['cache'])
        ) {
            $cacheProvider = $this->config['default'];
        }

        return $cacheProvider;
    }

    /**
     * Class mapper to provide backwards compatibility
     *
     * @param $class
     *
     * @return string
     */
    private function classMapper($class)
    {
        $classToCheck = $class;
        $classToCheck .= (substr($class, -5) === 'Cache') ? '' : 'Cache';

        switch ($classToCheck) {
            case 'ApcCache':
                $class = 'Assetic\Cache\ApcCache';
                break;
            case 'FilesystemCache':
                $class = 'Assetic\Cache\FilesystemCache';
                break;
            case 'FilePathCache':
                $class = 'AssetManager\Core\Cache\FilePathCache';
                break;
        }

        return $class;
    }
}