Rocket\UI\Assets\Assetic\Asset\AssetReference

Complexity

Total Complexity

26

Size/Duplication

Total Lines	151
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

26.87%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__clone()	0	8	2
A	ensureFilter()	0	4	1
A	getFilters()	0	6	1
A	clearFilters()	0	5	1
A	load()	0	6	1
A	dump()	0	6	1
A	getContent()	0	4	1
A	setContent()	0	4	1
A	getSourceRoot()	0	4	1
A	getSourcePath()	0	4	1
A	getSourceDirectory()	0	4	1
A	getTargetPath()	0	4	1
A	setTargetPath()	0	4	1
A	getLastModified()	0	4	1
A	getVars()	0	4	1
A	getValues()	0	4	1
A	setValues()	0	4	1
A	getAsset()	0	4	1
A	callAsset()	0	6	1
A	flushFilters()	0	8	2
A	resolve()	0	14	3

<?php namespace Rocket\UI\Assets\Assetic\Asset;

use Assetic\Asset\AssetInterface;
use Assetic\AssetManager;
use Assetic\Filter\FilterInterface;

/**
 * A reference to an asset in the asset manager.
 *
 * @author Kris Wallsmith <kris.wallsmith@gmail.com>
 */
class AssetReference implements AssetInterface
{
    private $am;
    private $name;
    private $filters = [];
    private $clone = false;
    private $asset;

    public function __construct(AssetManager $am, $name)
    {
        $this->am = $am;
        $this->name = $name;
    }

    public function __clone()
    {
        $this->clone = true;

        if ($this->asset) {
            $this->asset = clone $this->asset;
        }
    }

    public function ensureFilter(FilterInterface $filter)
    {
        $this->filters[] = $filter;
    }

    public function getFilters()
    {
        $this->flushFilters();

        return $this->callAsset(__FUNCTION__);
    }

    public function clearFilters()
    {
        $this->filters = [];
        $this->callAsset(__FUNCTION__);
    }

    public function load(FilterInterface $additionalFilter = null)
    {
        $this->flushFilters();

        return $this->callAsset(__FUNCTION__, [$additionalFilter]);
    }

    public function dump(FilterInterface $additionalFilter = null)
    {
        $this->flushFilters();

        return $this->callAsset(__FUNCTION__, [$additionalFilter]);
    }

    public function getContent()
    {
        return $this->callAsset(__FUNCTION__);
    }

    public function setContent($content)
    {
        $this->callAsset(__FUNCTION__, [$content]);
    }

    public function getSourceRoot()
    {
        return $this->callAsset(__FUNCTION__);
    }

    public function getSourcePath()
    {
        return $this->callAsset(__FUNCTION__);
    }

    public function getSourceDirectory()
    {
        return $this->callAsset(__FUNCTION__);
    }

    public function getTargetPath()
    {
        return $this->callAsset(__FUNCTION__);
    }

    public function setTargetPath($targetPath)
    {
        $this->callAsset(__FUNCTION__, [$targetPath]);
    }

    public function getLastModified()
    {
        return $this->callAsset(__FUNCTION__);
    }

    public function getVars()
    {
        return $this->callAsset(__FUNCTION__);
    }

    public function getValues()
    {
        return $this->callAsset(__FUNCTION__);
    }

    public function setValues(array $values)
    {
        $this->callAsset(__FUNCTION__, [$values]);
    }

    /**
     * @return \Assetic\Asset\AssetInterface
     */
    public function getAsset()
    {
        return $this->resolve();
    }

    // private

    private function callAsset($method, $arguments = array())
    {
        $asset = $this->resolve();

        return call_user_func_array(array($asset, $method), $arguments);
    }

    private function flushFilters()
    {
        $asset = $this->resolve();

        while ($filter = array_shift($this->filters)) {
            $asset->ensureFilter($filter);
        }
    }

    private function resolve()
    {
        if ($this->asset) {
            return $this->asset;
        }

        $asset = $this->am->get($this->name);

        if ($this->clone) {
            $asset = $this->asset = clone $asset;
        }

        return $asset;
    }
}