LazyAssetManager.php

Go to the documentation of this file.

<?php
 
/*
 * This file is part of the Assetic package, an OpenSky project.
 *
 * (c) 2010-2014 OpenSky Project Inc
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 
namespace Assetic\Factory;
 
use Assetic\Asset\AssetInterface;
use Assetic\AssetManager;
use Assetic\Factory\Loader\FormulaLoaderInterface;
use Assetic\Factory\Resource\ResourceInterface;
 
class LazyAssetManager extends AssetManager
{
    private $factory;
    private $loaders;
    private $resources;
    private $formulae;
    private $loaded;
    private $loading;
 
    public function __construct(AssetFactory $factory, $loaders = array())
    {
        $this->factory = $factory;
        $this->loaders = array();
        $this->resources = array();
        $this->formulae = array();
        $this->loaded = false;
        $this->loading = false;
 
        foreach ($loaders as $alias => $loader) {
            $this->setLoader($alias, $loader);
        }
    }
 
    public function setLoader($alias, FormulaLoaderInterface $loader)
    {
        $this->loaders[$alias] = $loader;
        $this->loaded = false;
    }
 
    public function addResource(ResourceInterface $resource, $loader)
    {
        $this->resources[$loader][] = $resource;
        $this->loaded = false;
    }
 
    public function getResources()
    {
        $resources = array();
        foreach ($this->resources as $r) {
            $resources = array_merge($resources, $r);
        }
 
        return $resources;
    }
 
    public function hasFormula($name)
    {
        if (!$this->loaded) {
            $this->load();
        }
 
        return isset($this->formulae[$name]);
    }
 
    public function getFormula($name)
    {
        if (!$this->loaded) {
            $this->load();
        }
 
        if (!isset($this->formulae[$name])) {
            throw new \InvalidArgumentException(sprintf('There is no "%s" formula.', $name));
        }
 
        return $this->formulae[$name];
    }
 
    public function setFormula($name, array $formula)
    {
        $this->formulae[$name] = $formula;
    }
 
    public function load()
    {
        if ($this->loading) {
            return;
        }
 
        if ($diff = array_diff(array_keys($this->resources), array_keys($this->loaders))) {
            throw new \LogicException('The following loader(s) are not registered: '.implode(', ', $diff));
        }
 
        $this->loading = true;
 
        foreach ($this->resources as $loader => $resources) {
            foreach ($resources as $resource) {
                $this->formulae = array_replace($this->formulae, $this->loaders[$loader]->load($resource));
            }
        }
 
        $this->loaded = true;
        $this->loading = false;
    }
 
    public function get($name)
    {
        if (!$this->loaded) {
            $this->load();
        }
 
        if (!parent::has($name) && isset($this->formulae[$name])) {
            list($inputs, $filters, $options) = $this->formulae[$name];
            $options['name'] = $name;
            parent::set($name, $this->factory->createAsset($inputs, $filters, $options));
        }
 
        return parent::get($name);
    }
 
    public function has($name)
    {
        if (!$this->loaded) {
            $this->load();
        }
 
        return isset($this->formulae[$name]) || parent::has($name);
    }
 
    public function getNames()
    {
        if (!$this->loaded) {
            $this->load();
        }
 
        return array_unique(array_merge(parent::getNames(), array_keys($this->formulae)));
    }
 
    public function isDebug()
    {
        return $this->factory->isDebug();
    }
 
    public function getLastModified(AssetInterface $asset)
    {
        return $this->factory->getLastModified($asset);
    }
}