AssetManager\Core\Resolver\ConcatResolver

Complexity

Total Complexity

14

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setMimeResolver()	0	4	1
A	getMimeResolver()	0	4	1
A	setConcats()	0	4	1
A	setAggregateResolver()	0	4	1
A	getAggregateResolver()	0	4	1
A	getConcats()	0	4	1
B	resolve()	0	37	4
A	setAssetFilterManager()	0	4	1
A	getAssetFilterManager()	0	4	1
A	collect()	0	4	1

<?php

namespace AssetManager\Core\Resolver;

use Assetic\Asset\AssetInterface;
use AssetManager\Core\Asset\AggregateAsset;
use AssetManager\Core\Exception;
use AssetManager\Core\Service\AssetFilterManager;
use AssetManager\Core\Service\AssetFilterManagerAwareInterface;
use AssetManager\Core\Service\MimeResolver;
use Traversable;
use Zend\Stdlib\ArrayUtils;

/**
 * This resolver allows the resolving of concatenated files.
 * Concatted files are added as an StringAsset and filters get applied to concatenated string.
 */
class ConcatResolver implements
    ResolverInterface,
    AggregateResolverAwareInterface,
    AssetFilterManagerAwareInterface,
    MimeResolverAwareInterface
{
    /**
     * @var null|ResolverInterface
     */
    protected $aggregateResolver;

    /**
     * @var null|AssetFilterManager The filterManager service.
     */
    protected $filterManager;

    /**
     * @var array the concats
     */
    protected $concats = array();

    /**
     * @var MimeResolver The mime resolver.
     */
    protected $mimeResolver;

    /**
     * Constructor
     *
     * Instantiate and optionally populate concats.
     *
     * @param array|Traversable $concats
     */
    public function __construct($concats = array())
    {
        $this->setConcats($concats);
    }

    /**
     * Set the mime resolver
     *
     * @param MimeResolver $resolver
     */
    public function setMimeResolver(MimeResolver $resolver)
    {
        $this->mimeResolver = $resolver;
    }

    /**
     * Get the mime resolver
     *
     * @return MimeResolver
     */
    public function getMimeResolver()
    {
        return $this->mimeResolver;
    }

    /**
     * Set (overwrite) concats
     *
     * Concats should be arrays or Traversable objects with name => path pairs
     *
     * @param  array|Traversable                  $concats
     * @throws Exception\InvalidArgumentException
     */
    public function setConcats($concats)
    {
        $this->concats = ArrayUtils::iteratorToArray($concats);
    }

    /**
     * Set the aggregate resolver.
     *
     * @param ResolverInterface $aggregateResolver
     */
    public function setAggregateResolver(ResolverInterface $aggregateResolver)
    {
        $this->aggregateResolver = $aggregateResolver;
    }

    /**
     * Get the aggregate resolver.
     *
     * @return ResolverInterface
     */
    public function getAggregateResolver()
    {
        return $this->aggregateResolver;
    }

    /**
     * Retrieve the concats
     *
     * @return array
     */
    public function getConcats()
    {
        return $this->concats;
    }

    /**
     * {@inheritDoc}
     */
    public function resolve($name)
    {
        if (!isset($this->concats[$name])) {
            return null;
        }

        $resolvedAssets = array();

        foreach ((array) $this->concats[$name] as $assetName) {
            $resolvedAsset = $this->getAggregateResolver()->resolve((string) $assetName);

            if (!$resolvedAsset instanceof AssetInterface) {
                throw new Exception\RuntimeException(
                    sprintf(
                        'Asset "%s" from collection "%s" can\'t be resolved '
                        .'to an Asset implementing Assetic\Asset\AssetInterface.',
                        $assetName,
                        $name
                    )
                );
            }

            $resolvedAsset->mimetype = $this->getMimeResolver()->getMimeType(

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

                $resolvedAsset->getSourceRoot() . $resolvedAsset->getSourcePath()
            );

            $this->getAssetFilterManager()->setFilters($assetName, $resolvedAsset);

            $resolvedAssets[] = $resolvedAsset;
        }
        $aggregateAsset = new AggregateAsset($resolvedAssets);
        $this->getAssetFilterManager()->setFilters($name, $aggregateAsset);
        $aggregateAsset->setTargetPath($name);
        $aggregateAsset->mimetype = $this->getMimeResolver()->getMimeType($name);

        return $aggregateAsset;
    }

    /**
     * Set the AssetFilterManager.
     *
     * @param AssetFilterManager $filterManager
     */
    public function setAssetFilterManager(AssetFilterManager $filterManager)
    {
        $this->filterManager = $filterManager;
    }

    /**
     * Get the AssetFilterManager
     *
     * @return AssetFilterManager
     */
    public function getAssetFilterManager()
    {
        return $this->filterManager;
    }

    /**
     * {@inheritDoc}
     */
    public function collect()
    {
        return array_keys($this->concats);
    }
}