LICENSE 0000666 00000002054 13436754447 0005577 0 ustar 00 Copyright (c) 2010-2013 OpenSky Project Inc
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
README.md 0000666 00000022007 13436754447 0006051 0 ustar 00 # Assetic [![Build Status](https://travis-ci.org/kriswallsmith/assetic.png?branch=master)](https://travis-ci.org/kriswallsmith/assetic) ![project status](http://stillmaintained.com/kriswallsmith/assetic.png) #
Assetic is an asset management framework for PHP.
``` php
dump();
```
Assets
------
An Assetic asset is something with filterable content that can be loaded and
dumped. An asset also includes metadata, some of which can be manipulated and
some of which is immutable.
| **Property** | **Accessor** | **Mutator** |
|--------------|-----------------|---------------|
| content | getContent | setContent |
| mtime | getLastModified | n/a |
| source root | getSourceRoot | n/a |
| source path | getSourcePath | n/a |
| target path | getTargetPath | setTargetPath |
Filters
-------
Filters can be applied to manipulate assets.
``` php
dump();
```
The filters applied to the collection will cascade to each asset leaf if you
iterate over it.
``` php
dump();
}
```
The core provides the following filters in the `Assetic\Filter` namespace:
* `CoffeeScriptFilter`: compiles CoffeeScript into Javascript
* `CompassFilter`: Compass CSS authoring framework
* `CssEmbedFilter`: embeds image data in your stylesheets
* `CssImportFilter`: inlines imported stylesheets
* `CssMinFilter`: minifies CSS
* `CssRewriteFilter`: fixes relative URLs in CSS assets when moving to a new URL
* `DartFilter`: compiles Javascript using dart2js
* `GoogleClosure\CompilerApiFilter`: compiles Javascript using the Google Closure Compiler API
* `GoogleClosure\CompilerJarFilter`: compiles Javascript using the Google Closure Compiler JAR
* `GssFilter`: compliles CSS using the Google Closure Stylesheets Compiler
* `HandlebarsFilter`: compiles Handlebars templates into Javascript
* `JpegoptimFilter`: optimize your JPEGs
* `JpegtranFilter`: optimize your JPEGs
* `JSMinFilter`: minifies Javascript
* `JSMinPlusFilter`: minifies Javascript
* `LessFilter`: parses LESS into CSS (using less.js with node.js)
* `LessphpFilter`: parses LESS into CSS (using lessphp)
* `OptiPngFilter`: optimize your PNGs
* `PackagerFilter`: parses Javascript for packager tags
* `PackerFilter`: compresses Javascript using Dean Edwards's Packer
* `PhpCssEmbedFilter`: embeds image data in your stylesheet
* `PngoutFilter`: optimize your PNGs
* `Sass\SassFilter`: parses SASS into CSS
* `Sass\ScssFilter`: parses SCSS into CSS
* `ScssphpFilter`: parses SCSS using scssphp
* `SprocketsFilter`: Sprockets Javascript dependency management
* `StylusFilter`: parses STYL into CSS
* `TypeScriptFilter`: parses TypeScript into Javascript
* `UglifyCssFilter`: minifies CSS
* `UglifyJs2Filter`: minifies Javascript
* `UglifyJsFilter`: minifies Javascript
* `Yui\CssCompressorFilter`: compresses CSS using the YUI compressor
* `Yui\JsCompressorFilter`: compresses Javascript using the YUI compressor
Asset Manager
-------------
An asset manager is provided for organizing assets.
``` php
set('jquery', new FileAsset('/path/to/jquery.js'));
$am->set('base_css', new GlobAsset('/path/to/css/*'));
```
The asset manager can also be used to reference assets to avoid duplication.
``` php
set('my_plugin', new AssetCollection(array(
new AssetReference($am, 'jquery'),
new FileAsset('/path/to/jquery.plugin.js'),
)));
```
Filter Manager
--------------
A filter manager is also provided for organizing filters.
``` php
set('sass', new SassFilter('/path/to/parser/sass'));
$fm->set('yui_css', new Yui\CssCompressorFilter('/path/to/yuicompressor.jar'));
```
Asset Factory
-------------
If you'd rather not create all these objects by hand, you can use the asset
factory, which will do most of the work for you.
``` php
setAssetManager($am);
$factory->setFilterManager($fm);
$factory->setDebug(true);
$css = $factory->createAsset(array(
'@reset', // load the asset manager's "reset" asset
'css/src/*.scss', // load every scss files from "/path/to/asset/directory/css/src/"
), array(
'scss', // filter through the filter manager's "scss" filter
'?yui_css', // don't use this filter in debug mode
));
echo $css->dump();
```
Prefixing a filter name with a question mark, as `yui_css` is here, will cause
that filter to be omitted when the factory is in debug mode.
Caching
-------
A simple caching mechanism is provided to avoid unnecessary work.
``` php
dump();
$js->dump();
$js->dump();
```
Cache Busting
-------------
You can use the CacheBustingWorker to provide unique names.
Two strategies are provided: CacheBustingWorker::STRATEGY_CONTENT (content based), CacheBustingWorker::STRATEGY_MODIFICATION (modification time based)
``` php
setAssetManager($am);
$factory->setFilterManager($fm);
$factory->setDebug(true);
$factory->addWorker(new CacheBustingWorker(CacheBustingWorker::STRATEGY_CONTENT));
$css = $factory->createAsset(array(
'@reset', // load the asset manager's "reset" asset
'css/src/*.scss', // load every scss files from "/path/to/asset/directory/css/src/"
), array(
'scss', // filter through the filter manager's "scss" filter
'?yui_css', // don't use this filter in debug mode
));
echo $css->dump();
```
Static Assets
-------------
Alternatively you can just write filtered assets to your web directory and be
done with it.
``` php
writeManagerAssets($am);
```
Twig
----
To use the Assetic [Twig][3] extension you must register it to your Twig
environment:
``` php
addExtension(new AsseticExtension($factory, $debug));
```
Once in place, the extension exposes a stylesheets and a javascripts tag with a syntax similar
to what the asset factory uses:
``` html+jinja
{% stylesheets '/path/to/sass/main.sass' filter='sass,?yui_css' output='css/all.css' %}
{% endstylesheets %}
```
This example will render one `link` element on the page that includes a URL
where the filtered asset can be found.
When the extension is in debug mode, this same tag will render multiple `link`
elements, one for each asset referenced by the `css/src/*.sass` glob. The
specified filters will still be applied, unless they are marked as optional
using the `?` prefix.
This behavior can also be triggered by setting a `debug` attribute on the tag:
``` html+jinja
{% stylesheets 'css/*' debug=true %} ... {% stylesheets %}
```
These assets need to be written to the web directory so these URLs don't
return 404 errors.
``` php
setLoader('twig', new TwigFormulaLoader($twig));
// loop through all your templates
foreach ($templates as $template) {
$resource = new TwigResource($twigLoader, $template);
$am->addResource($resource, 'twig');
}
$writer = new AssetWriter('/path/to/web');
$writer->writeManagerAssets($am);
```
---
Assetic is based on the Python [webassets][1] library (available on
[GitHub][2]).
[1]: http://elsdoerfer.name/docs/webassets
[2]: https://github.com/miracle2k/webassets
[3]: http://twig.sensiolabs.org
CHANGELOG-1.0.md 0000666 00000001610 13436754447 0006674 0 ustar 00 1.0.4 (August 28, 2012)
-----------------------
* Fixed the Twig tag to avoid a fatal error when left unclosed
* Added the HashableInterface for non-serialiable filters
* Fixed a bug for compass on windows
1.0.3 (March 2, 2012)
---------------------
* Added "boring" option to Compass filter
* Fixed accumulation of load paths in Compass filter
* Fixed issues in CssImport and CssRewrite filters
1.0.2 (August 26, 2011)
-----------------------
* Twig 1.2 compatibility
* Fixed filtering of large LessCSS assets
* Fixed escaping of commands on Windows
* Misc fixes to Compass filter
* Removed default CssEmbed charset
1.0.1 (July 15, 2011)
---------------------
* Fixed Twig error handling
* Removed use of STDIN
* Added inheritance of environment variables
* Fixed Compass on Windows
* Improved escaping of commands
1.0.0 (July 10, 2011)
---------------------
* Initial release
CHANGELOG-1.1.md 0000666 00000003015 13436754447 0006676 0 ustar 00 1.1.0
-----
* Added the possibility to configure additional load paths for less and lessphp
* Added the UglifyCssFilter
* Fixed the handling of directories in the GlobAsset. #256
* Added Handlebars support
* Added Scssphp-compass support
* Added the CacheBustingWorker
* Added the UglifyJs2Filter
1.1.0-alpha1 (August 28, 2012)
------------------------------
* Added pure php css embed filter
* Added Scssphp support
* Added support for Google Closure language option
* Added a way to set a specific ruby path for CompassFilter and SassFilter
* Ensure uniqueness of temporary files created by the compressor filter. Fixed #61
* Added Compass option for generated_images_path (for generated Images/Sprites)
* Added PackerFilter
* Add the way to contact closure compiler API using curl, if available and allow_url_fopen is off
* Added filters for JSMin and JSMinPlus
* Added the UglifyJsFilter
* Improved the error message in getModifiedTime when a file asset uses an invalid file
* added support for asset variables:
Asset variables allow you to pre-compile your assets for a finite set of known
variable values, and then to simply deliver the correct asset version at runtime.
For example, this is helpful for assets with language, or browser-specific code.
* Removed the copy-paste of the Symfony2 Process component and use the original one
* Added ability to pass variables into lessphp filter
* Added google closure stylesheets jar filter
* Added the support of `--bare` for the CoffeeScriptFilter
src/functions.php 0000666 00000005766 13436754447 0010117 0 ustar 00 factory = $factory;
}
/**
* Returns an array of javascript URLs.
*
* @param array|string $inputs Input strings
* @param array|string $filters Filter names
* @param array $options An array of options
*
* @return array An array of javascript URLs
*/
function assetic_javascripts($inputs = array(), $filters = array(), array $options = array())
{
if (!isset($options['output'])) {
$options['output'] = 'js/*.js';
}
return _assetic_urls($inputs, $filters, $options);
}
/**
* Returns an array of stylesheet URLs.
*
* @param array|string $inputs Input strings
* @param array|string $filters Filter names
* @param array $options An array of options
*
* @return array An array of stylesheet URLs
*/
function assetic_stylesheets($inputs = array(), $filters = array(), array $options = array())
{
if (!isset($options['output'])) {
$options['output'] = 'css/*.css';
}
return _assetic_urls($inputs, $filters, $options);
}
/**
* Returns an image URL.
*
* @param string $input An input
* @param array|string $filters Filter names
* @param array $options An array of options
*
* @return string An image URL
*/
function assetic_image($input, $filters = array(), array $options = array())
{
if (!isset($options['output'])) {
$options['output'] = 'images/*';
}
$urls = _assetic_urls($input, $filters, $options);
return current($urls);
}
/**
* Returns an array of asset urls.
*
* @param array|string $inputs Input strings
* @param array|string $filters Filter names
* @param array $options An array of options
*
* @return array An array of URLs
*/
function _assetic_urls($inputs = array(), $filters = array(), array $options = array())
{
global $_assetic;
if (!is_array($inputs)) {
$inputs = array_filter(array_map('trim', explode(',', $inputs)));
}
if (!is_array($filters)) {
$filters = array_filter(array_map('trim', explode(',', $filters)));
}
$coll = $_assetic->factory->createAsset($inputs, $filters, $options);
$debug = isset($options['debug']) ? $options['debug'] : $_assetic->factory->isDebug();
$combine = isset($options['combine']) ? $options['combine'] : !$debug;
$one = $coll->getTargetPath();
if ($combine) {
$many = array($one);
} else {
$many = array();
foreach ($coll as $leaf) {
$many[] = $leaf->getTargetPath();
}
}
return new TraversableString($one, $many);
}
src/Assetic/Cache/ConfigCache.php 0000666 00000006044 13436754447 0012624 0 ustar 00
*/
class ConfigCache
{
private $dir;
/**
* Construct.
*
* @param string $dir The cache directory
*/
public function __construct($dir)
{
$this->dir = $dir;
}
/**
* Checks of the cache has a file.
*
* @param string $resource A cache key
*
* @return Boolean True if a file exists
*/
public function has($resource)
{
return file_exists($this->getSourcePath($resource));
}
/**
* Writes a value to a file.
*
* @param string $resource A cache key
* @param mixed $value A value to cache
*/
public function set($resource, $value)
{
$path = $this->getSourcePath($resource);
if (!is_dir($dir = dirname($path)) && false === @mkdir($dir, 0777, true)) {
// @codeCoverageIgnoreStart
throw new \RuntimeException('Unable to create directory '.$dir);
// @codeCoverageIgnoreEnd
}
if (false === @file_put_contents($path, sprintf("getSourcePath($resource);
if (!file_exists($path)) {
throw new \RuntimeException('There is no cached value for '.$resource);
}
return include $path;
}
/**
* Returns a timestamp for when the cache was created.
*
* @param string $resource A cache key
*
* @return integer A UNIX timestamp
*/
public function getTimestamp($resource)
{
$path = $this->getSourcePath($resource);
if (!file_exists($path)) {
throw new \RuntimeException('There is no cached value for '.$resource);
}
if (false === $mtime = @filemtime($path)) {
// @codeCoverageIgnoreStart
throw new \RuntimeException('Unable to determine file mtime for '.$path);
// @codeCoverageIgnoreEnd
}
return $mtime;
}
/**
* Returns the path where the file corresponding to the supplied cache key can be included from.
*
* @param string $resource A cache key
*
* @return string A file path
*/
private function getSourcePath($resource)
{
$key = md5($resource);
return $this->dir.'/'.$key[0].'/'.$key.'.php';
}
}
src/Assetic/Cache/ApcCache.php 0000666 00000002406 13436754447 0012120 0 ustar 00
*/
class ApcCache implements CacheInterface
{
public $ttl = 0;
/**
* @see CacheInterface::has()
*/
public function has($key)
{
return apc_exists($key);
}
/**
* @see CacheInterface::get()
*/
public function get($key)
{
$value = apc_fetch($key, $success);
if (!$success) {
throw new \RuntimeException('There is no cached value for ' . $key);
}
return $value;
}
/**
* @see CacheInterface::set()
*/
public function set($key, $value)
{
$store = apc_store($key, $value, $this->ttl);
if (!$store) {
throw new \RuntimeException('Unable to store "' . $key . '" for ' . $this->ttl . ' seconds.');
}
return $store;
}
/**
* @see CacheInterface::remove()
*/
public function remove($key)
{
return apc_delete($key);
}
}
src/Assetic/Cache/CacheInterface.php 0000666 00000002147 13436754447 0013317 0 ustar 00
*/
interface CacheInterface
{
/**
* Checks if the cache has a value for a key.
*
* @param string $key A unique key
*
* @return Boolean Whether the cache has a value for this key
*/
public function has($key);
/**
* Returns the value for a key.
*
* @param string $key A unique key
*
* @return string|null The value in the cache
*/
public function get($key);
/**
* Sets a value in the cache.
*
* @param string $key A unique key
* @param string $value The value to cache
*/
public function set($key, $value);
/**
* Removes a value from the cache.
*
* @param string $key A unique key
*/
public function remove($key);
}
src/Assetic/Cache/ExpiringCache.php 0000666 00000002432 13436754447 0013201 0 ustar 00
*/
class ExpiringCache implements CacheInterface
{
private $cache;
private $lifetime;
public function __construct(CacheInterface $cache, $lifetime)
{
$this->cache = $cache;
$this->lifetime = $lifetime;
}
public function has($key)
{
if ($this->cache->has($key)) {
if (time() < $this->cache->get($key.'.expires')) {
return true;
}
$this->cache->remove($key.'.expires');
$this->cache->remove($key);
}
return false;
}
public function get($key)
{
return $this->cache->get($key);
}
public function set($key, $value)
{
$this->cache->set($key.'.expires', time() + $this->lifetime);
$this->cache->set($key, $value);
}
public function remove($key)
{
$this->cache->remove($key.'.expires');
$this->cache->remove($key);
}
}
src/Assetic/Cache/ArrayCache.php 0000666 00000002102 13436754447 0012464 0 ustar 00
*/
class ArrayCache implements CacheInterface
{
private $cache = array();
/**
* @see CacheInterface::has()
*/
public function has($key)
{
return isset($this->cache[$key]);
}
/**
* @see CacheInterface::get()
*/
public function get($key)
{
if(!$this->has($key)) {
throw new \RuntimeException('There is no cached value for '.$key);
}
return $this->cache[$key];
}
/**
* @see CacheInterface::set()
*/
public function set($key, $value)
{
$this->cache[$key] = $value;
}
/**
* @see CacheInterface::remove()
*/
public function remove($key)
{
unset($this->cache[$key]);
}
}
src/Assetic/Cache/FilesystemCache.php 0000666 00000002721 13436754447 0013541 0 ustar 00
*/
class FilesystemCache implements CacheInterface
{
private $dir;
public function __construct($dir)
{
$this->dir = $dir;
}
public function has($key)
{
return file_exists($this->dir.'/'.$key);
}
public function get($key)
{
$path = $this->dir.'/'.$key;
if (!file_exists($path)) {
throw new \RuntimeException('There is no cached value for '.$key);
}
return file_get_contents($path);
}
public function set($key, $value)
{
if (!is_dir($this->dir) && false === @mkdir($this->dir, 0777, true)) {
throw new \RuntimeException('Unable to create directory '.$this->dir);
}
$path = $this->dir.'/'.$key;
if (false === @file_put_contents($path, $value)) {
throw new \RuntimeException('Unable to write file '.$path);
}
}
public function remove($key)
{
$path = $this->dir.'/'.$key;
if (file_exists($path) && false === @unlink($path)) {
throw new \RuntimeException('Unable to remove file '.$path);
}
}
}
src/Assetic/Filter/HashableInterface.php 0000666 00000001027 13436754447 0014241 0 ustar 00
*/
interface HashableInterface
{
/**
* Generates a hash for the object
*
* @return string Object hash
*/
public function hash();
}
src/Assetic/Filter/BaseCssFilter.php 0000666 00000005722 13436754447 0013410 0 ustar 00
*/
abstract class BaseCssFilter implements FilterInterface
{
/**
* Filters all references -- url() and "@import" -- through a callable.
*
* @param string $content The CSS
* @param callable $callback A PHP callable
* @param integer $limit
* @param integer $count
*
* @return string The filtered CSS
*/
protected function filterReferences($content, $callback, $limit = -1, &$count = 0)
{
$content = $this->filterUrls($content, $callback, $limit, $count);
$content = $this->filterImports($content, $callback, $limit, $count, false);
$content = $this->filterIEFilters($content, $callback, $limit, $count);
return $content;
}
/**
* Filters all CSS url()'s through a callable.
*
* @param string $content The CSS
* @param callable $callback A PHP callable
* @param integer $limit Limit the number of replacements
* @param integer $count Will be populated with the count
*
* @return string The filtered CSS
*/
protected function filterUrls($content, $callback, $limit = -1, &$count = 0)
{
return preg_replace_callback('/url\((["\']?)(?P.*?)(\\1)\)/', $callback, $content, $limit, $count);
}
/**
* Filters all CSS imports through a callable.
*
* @param string $content The CSS
* @param callable $callback A PHP callable
* @param integer $limit Limit the number of replacements
* @param integer $count Will be populated with the count
* @param Boolean $includeUrl Whether to include url() in the pattern
*
* @return string The filtered CSS
*/
protected function filterImports($content, $callback, $limit = -1, &$count = 0, $includeUrl = true)
{
$pattern = $includeUrl
? '/@import (?:url\()?(\'|"|)(?P[^\'"\)\n\r]*)\1\)?;?/'
: '/@import (?!url\()(\'|"|)(?P[^\'"\)\n\r]*)\1;?/';
return preg_replace_callback($pattern, $callback, $content, $limit, $count);
}
/**
* Filters all IE filters (AlphaImageLoader filter) through a callable.
*
* @param string $content The CSS
* @param callable $callback A PHP callable
* @param integer $limit Limit the number of replacements
* @param integer $count Will be populated with the count
*
* @return string The filtered CSS
*/
protected function filterIEFilters($content, $callback, $limit = -1, &$count = 0)
{
return preg_replace_callback('/src=(["\']?)(?P.*?)\\1/', $callback, $content, $limit, $count);
}
}
src/Assetic/Filter/StylusFilter.php 0000666 00000005042 13436754447 0013363 0 ustar 00
*/
class StylusFilter extends BaseNodeFilter
{
private $nodeBin;
private $compress;
/**
* Constructs filter.
*
* @param string $nodeBin The path to the node binary
* @param array $nodePaths An array of node paths
*/
public function __construct($nodeBin = '/usr/bin/node', array $nodePaths = array())
{
$this->nodeBin = $nodeBin;
$this->setNodePaths($nodePaths);
}
/**
* Enable output compression.
*
* @param boolean $compress
*/
public function setCompress($compress)
{
$this->compress = $compress;
}
/**
* {@inheritdoc}
*/
public function filterLoad(AssetInterface $asset)
{
static $format = <<<'EOF'
var stylus = require('stylus');
var sys = require(process.binding('natives').util ? 'util' : 'sys');
stylus(%s, %s).render(function(e, css){
if (e) {
throw e;
}
sys.print(css);
process.exit(0);
});
EOF;
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
// parser options
$parserOptions = array();
if ($root && $path) {
$parserOptions['paths'] = array(dirname($root.'/'.$path));
$parserOptions['filename'] = basename($path);
}
if (null !== $this->compress) {
$parserOptions['compress'] = $this->compress;
}
$pb = $this->createProcessBuilder();
$pb->inheritEnvironmentVariables();
$pb->add($this->nodeBin)->add($input = tempnam(sys_get_temp_dir(), 'assetic_stylus'));
file_put_contents($input, sprintf($format,
json_encode($asset->getContent()),
json_encode($parserOptions)
));
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
/**
* {@inheritdoc}
*/
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/TypeScriptFilter.php 0000666 00000004007 13436754447 0014166 0 ustar 00
*/
class TypeScriptFilter extends BaseNodeFilter
{
private $tscBin;
private $nodeBin;
public function __construct($tscBin = '/usr/bin/tsc', $nodeBin = null)
{
$this->tscBin = $tscBin;
$this->nodeBin = $nodeBin;
}
public function filterLoad(AssetInterface $asset)
{
$pb = $this->createProcessBuilder($this->nodeBin
? array($this->nodeBin, $this->tscBin)
: array($this->tscBin));
$templateName = basename($asset->getSourcePath());
$inputDirPath = sys_get_temp_dir().DIRECTORY_SEPARATOR.uniqid('input_dir');
$inputPath = $inputDirPath.DIRECTORY_SEPARATOR.$templateName.'.ts';
$outputPath = tempnam(sys_get_temp_dir(), 'output');
mkdir($inputDirPath);
file_put_contents($inputPath, $asset->getContent());
$pb->add($inputPath)->add('--out')->add($outputPath);
$proc = $pb->getProcess();
$code = $proc->run();
unlink($inputPath);
rmdir($inputDirPath);
if (0 !== $code) {
if (file_exists($outputPath)) {
unlink($outputPath);
}
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
if (!file_exists($outputPath)) {
throw new \RuntimeException('Error creating output file.');
}
$compiledJs = file_get_contents($outputPath);
unlink($outputPath);
$asset->setContent($compiledJs);
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/UglifyJs2Filter.php 0000666 00000004717 13436754447 0013706 0 ustar 00
*/
class UglifyJs2Filter extends BaseNodeFilter
{
private $uglifyjsBin;
private $nodeBin;
private $compress;
private $beautify;
private $mangle;
public function __construct($uglifyjsBin = '/usr/bin/uglifyjs', $nodeBin = null)
{
$this->uglifyjsBin = $uglifyjsBin;
$this->nodeBin = $nodeBin;
}
public function setCompress($compress)
{
$this->compress = $compress;
}
public function setBeautify($beautify)
{
$this->beautify = $beautify;
}
public function setMangle($mangle)
{
$this->mangle = $mangle;
}
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$pb = $this->createProcessBuilder($this->nodeBin
? array($this->nodeBin, $this->uglifyjsBin)
: array($this->uglifyjsBin));
if ($this->compress) {
$pb->add('--compress');
}
if ($this->beautify) {
$pb->add('--beautify');
}
if ($this->mangle) {
$pb->add('--mangle');
}
// input and output files
$input = tempnam(sys_get_temp_dir(), 'input');
$output = tempnam(sys_get_temp_dir(), 'output');
file_put_contents($input, $asset->getContent());
$pb->add('-o')->add($output)->add($input);
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
if (file_exists($output)) {
unlink($output);
}
if (127 === $code) {
throw new \RuntimeException('Path to node executable could not be resolved.');
}
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
if (!file_exists($output)) {
throw new \RuntimeException('Error creating output file.');
}
$asset->setContent(file_get_contents($output));
unlink($output);
}
}
src/Assetic/Filter/ScssphpFilter.php 0000666 00000003137 13436754447 0013506 0 ustar 00
*/
class ScssphpFilter implements FilterInterface
{
private $compass = false;
private $importPaths = array();
public function enableCompass($enable = true)
{
$this->compass = (Boolean) $enable;
}
public function isCompassEnabled()
{
return $this->compass;
}
public function filterLoad(AssetInterface $asset)
{
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
$lc = new \scssc();
if ($this->compass) {
new \scss_compass($lc);
}
if ($root && $path) {
$lc->addImportPath(dirname($root.'/'.$path));
}
foreach ($this->importPaths as $path) {
$lc->addImportPath($path);
}
$asset->setContent($lc->compile($asset->getContent()));
}
public function setImportPaths(array $paths)
{
$this->importPaths = $paths;
}
public function addImportPath($path)
{
$this->importPaths[] = $path;
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/DartFilter.php 0000666 00000003050 13436754447 0012747 0 ustar 00 dartBin = $dartBin;
}
public function filterLoad(AssetInterface $asset)
{
$input = tempnam(sys_get_temp_dir(), 'assetic_dart');
$output = tempnam(sys_get_temp_dir(), 'assetic_dart');
file_put_contents($input, $asset->getContent());
$pb = $this->createProcessBuilder()
->add($this->dartBin)
->add('-o'.$output)
->add($input)
;
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
if (file_exists($output)) {
unlink($output);
}
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
if (!file_exists($output)) {
throw new \RuntimeException('Error creating output file.');
}
$asset->setContent(file_get_contents($output));
unlink($output);
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/UglifyCssFilter.php 0000666 00000005637 13436754447 0014002 0 ustar 00
*/
class UglifyCssFilter extends BaseNodeFilter
{
private $uglifycssBin;
private $nodeBin;
private $expandVars;
private $uglyComments;
private $cuteComments;
/**
* @param string $uglifycssBin Absolute path to the uglifycss executable
* @param string $nodeBin Absolute path to the folder containg node.js executable
*/
public function __construct($uglifycssBin = '/usr/bin/uglifycss', $nodeBin = null)
{
$this->uglifycssBin = $uglifycssBin;
$this->nodeBin = $nodeBin;
}
/**
* Expand variables
* @param bool $expandVars True to enable
*/
public function setExpandVars($expandVars)
{
$this->expandVars = $expandVars;
}
/**
* Remove newlines within preserved comments
* @param bool $uglyComments True to enable
*/
public function setUglyComments($uglyComments)
{
$this->uglyComments = $uglyComments;
}
/**
* Preserve newlines within and around preserved comments
* @param bool $cuteComments True to enable
*/
public function setCuteComments($cuteComments)
{
$this->cuteComments = $cuteComments;
}
/**
* @see Assetic\Filter\FilterInterface::filterLoad()
*/
public function filterLoad(AssetInterface $asset)
{
}
/**
* Run the asset through UglifyJs
*
* @see Assetic\Filter\FilterInterface::filterDump()
*/
public function filterDump(AssetInterface $asset)
{
$pb = $this->createProcessBuilder($this->nodeBin
? array($this->nodeBin, $this->uglifycssBin)
: array($this->uglifycssBin));
if ($this->expandVars) {
$pb->add('--expand-vars');
}
if ($this->uglyComments) {
$pb->add('--ugly-comments');
}
if ($this->cuteComments) {
$pb->add('--cute-comments');
}
// input and output files
$input = tempnam(sys_get_temp_dir(), 'input');
file_put_contents($input, $asset->getContent());
$pb->add($input);
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (127 === $code) {
throw new \RuntimeException('Path to node executable could not be resolved.');
}
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
}
src/Assetic/Filter/Yui/JsCompressorFilter.php 0000666 00000002603 13436754447 0015257 0 ustar 00
*/
class JsCompressorFilter extends BaseCompressorFilter
{
private $nomunge;
private $preserveSemi;
private $disableOptimizations;
public function setNomunge($nomunge = true)
{
$this->nomunge = $nomunge;
}
public function setPreserveSemi($preserveSemi)
{
$this->preserveSemi = $preserveSemi;
}
public function setDisableOptimizations($disableOptimizations)
{
$this->disableOptimizations = $disableOptimizations;
}
public function filterDump(AssetInterface $asset)
{
$options = array();
if ($this->nomunge) {
$options[] = '--nomunge';
}
if ($this->preserveSemi) {
$options[] = '--preserve-semi';
}
if ($this->disableOptimizations) {
$options[] = '--disable-optimizations';
}
$asset->setContent($this->compress($asset->getContent(), 'js', $options));
}
}
src/Assetic/Filter/Yui/CssCompressorFilter.php 0000666 00000001225 13436754447 0015432 0 ustar 00
*/
class CssCompressorFilter extends BaseCompressorFilter
{
public function filterDump(AssetInterface $asset)
{
$asset->setContent($this->compress($asset->getContent(), 'css'));
}
}
src/Assetic/Filter/Yui/BaseCompressorFilter.php 0000666 00000005565 13436754447 0015567 0 ustar 00
*/
abstract class BaseCompressorFilter extends BaseProcessFilter
{
private $jarPath;
private $javaPath;
private $charset;
private $lineBreak;
private $stackSize;
public function __construct($jarPath, $javaPath = '/usr/bin/java')
{
$this->jarPath = $jarPath;
$this->javaPath = $javaPath;
}
public function setCharset($charset)
{
$this->charset = $charset;
}
public function setLineBreak($lineBreak)
{
$this->lineBreak = $lineBreak;
}
public function setStackSize($stackSize)
{
$this->stackSize = $stackSize;
}
public function filterLoad(AssetInterface $asset)
{
}
/**
* Compresses a string.
*
* @param string $content The content to compress
* @param string $type The type of content, either "js" or "css"
* @param array $options An indexed array of additional options
*
* @return string The compressed content
*/
protected function compress($content, $type, $options = array())
{
$pb = $this->createProcessBuilder(array($this->javaPath));
if (null !== $this->stackSize) {
$pb->add('-Xss'.$this->stackSize);
}
$pb->add('-jar')->add($this->jarPath);
foreach ($options as $option) {
$pb->add($option);
}
if (null !== $this->charset) {
$pb->add('--charset')->add($this->charset);
}
if (null !== $this->lineBreak) {
$pb->add('--line-break')->add($this->lineBreak);
}
// input and output files
$tempDir = realpath(sys_get_temp_dir());
$input = tempnam($tempDir, 'YUI-IN-');
$output = tempnam($tempDir, 'YUI-OUT-');
file_put_contents($input, $content);
$pb->add('-o')->add($output)->add('--type')->add($type)->add($input);
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
if (file_exists($output)) {
unlink($output);
}
throw FilterException::fromProcess($proc)->setInput($content);
}
if (!file_exists($output)) {
throw new \RuntimeException('Error creating output file.');
}
$retval = file_get_contents($output);
unlink($output);
return $retval;
}
}
src/Assetic/Filter/GssFilter.php 0000666 00000007446 13436754447 0012626 0 ustar 00
*/
class GssFilter extends BaseProcessFilter
{
private $jarPath;
private $javaPath;
private $allowUnrecognizedFunctions;
private $allowedNonStandardFunctions;
private $copyrightNotice;
private $define;
private $gssFunctionMapProvider;
private $inputOrientation;
private $outputOrientation;
private $prettyPrint;
public function __construct($jarPath, $javaPath = '/usr/bin/java')
{
$this->jarPath = $jarPath;
$this->javaPath = $javaPath;
}
public function setAllowUnrecognizedFunctions($allowUnrecognizedFunctions)
{
$this->allowUnrecognizedFunctions = $allowUnrecognizedFunctions;
}
public function setAllowedNonStandardFunctions($allowNonStandardFunctions)
{
$this->allowedNonStandardFunctions = $allowNonStandardFunctions;
}
public function setCopyrightNotice($copyrightNotice)
{
$this->copyrightNotice = $copyrightNotice;
}
public function setDefine($define)
{
$this->define = $define;
}
public function setGssFunctionMapProvider($gssFunctionMapProvider)
{
$this->gssFunctionMapProvider = $gssFunctionMapProvider;
}
public function setInputOrientation($inputOrientation)
{
$this->inputOrientation = $inputOrientation;
}
public function setOutputOrientation($outputOrientation)
{
$this->outputOrientation = $outputOrientation;
}
public function setPrettyPrint($prettyPrint)
{
$this->prettyPrint = $prettyPrint;
}
public function filterLoad(AssetInterface $asset)
{
$cleanup = array();
$pb = $this->createProcessBuilder(array(
$this->javaPath,
'-jar',
$this->jarPath,
));
if (null !== $this->allowUnrecognizedFunctions) {
$pb->add('--allow-unrecognized-functions');
}
if (null !== $this->allowedNonStandardFunctions) {
$pb->add('--allowed_non_standard_functions')->add($this->allowedNonStandardFunctions);
}
if (null !== $this->copyrightNotice) {
$pb->add('--copyright-notice')->add($this->copyrightNotice);
}
if (null !== $this->define) {
$pb->add('--define')->add($this->define);
}
if (null !== $this->gssFunctionMapProvider) {
$pb->add('--gss-function-map-provider')->add($this->gssFunctionMapProvider);
}
if (null !== $this->inputOrientation) {
$pb->add('--input-orientation')->add($this->inputOrientation);
}
if (null !== $this->outputOrientation) {
$pb->add('--output-orientation')->add($this->outputOrientation);
}
if (null !== $this->prettyPrint) {
$pb->add('--pretty-print');
}
$pb->add($cleanup[] = $input = tempnam(sys_get_temp_dir(), 'assetic_google_closure_stylesheets_compiler'));
file_put_contents($input, $asset->getContent());
$proc = $pb->getProcess();
$code = $proc->run();
array_map('unlink', $cleanup);
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/JSMinFilter.php 0000666 00000001425 13436754447 0013041 0 ustar 00
*/
class JSMinFilter implements FilterInterface
{
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$asset->setContent(\JSMin::minify($asset->getContent()));
}
}
src/Assetic/Filter/CssImportFilter.php 0000666 00000006522 13436754447 0014007 0 ustar 00
*/
class CssImportFilter extends BaseCssFilter
{
private $importFilter;
/**
* Constructor.
*
* @param FilterInterface $importFilter Filter for each imported asset
*/
public function __construct(FilterInterface $importFilter = null)
{
$this->importFilter = $importFilter ?: new CssRewriteFilter();
}
public function filterLoad(AssetInterface $asset)
{
$importFilter = $this->importFilter;
$sourceRoot = $asset->getSourceRoot();
$sourcePath = $asset->getSourcePath();
$callback = function($matches) use ($importFilter, $sourceRoot, $sourcePath) {
if (!$matches['url'] || null === $sourceRoot) {
return $matches[0];
}
$importRoot = $sourceRoot;
if (false !== strpos($matches['url'], '://')) {
// absolute
list($importScheme, $tmp) = explode('://', $matches['url'], 2);
list($importHost, $importPath) = explode('/', $tmp, 2);
$importRoot = $importScheme.'://'.$importHost;
} elseif (0 === strpos($matches['url'], '//')) {
// protocol-relative
list($importHost, $importPath) = explode('/', substr($matches['url'], 2), 2);
$importHost = '//'.$importHost;
} elseif ('/' == $matches['url'][0]) {
// root-relative
$importPath = substr($matches['url'], 1);
} elseif (null !== $sourcePath) {
// document-relative
$importPath = $matches['url'];
if ('.' != $sourceDir = dirname($sourcePath)) {
$importPath = $sourceDir.'/'.$importPath;
}
} else {
return $matches[0];
}
// ignore other imports
if ('css' != pathinfo($importPath, PATHINFO_EXTENSION)) {
return $matches[0];
}
$importSource = $importRoot.'/'.$importPath;
if (false !== strpos($importSource, '://') || 0 === strpos($importSource, '//')) {
$import = new HttpAsset($importSource, array($importFilter), true);
} elseif (!file_exists($importSource)) {
// ignore not found imports
return $matches[0];
} else {
$import = new FileAsset($importSource, array($importFilter), $importRoot, $importPath);
}
$import->setTargetPath($sourcePath);
return $import->dump();
};
$content = $asset->getContent();
$lastHash = md5($content);
do {
$content = $this->filterImports($content, $callback);
$hash = md5($content);
} while ($lastHash != $hash && $lastHash = $hash);
$asset->setContent($content);
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/CallablesFilter.php 0000666 00000002034 13436754447 0013740 0 ustar 00
*/
class CallablesFilter implements FilterInterface
{
private $loader;
private $dumper;
/**
* @param callable|null $loader
* @param callable|null $dumper
*/
public function __construct($loader = null, $dumper = null)
{
$this->loader = $loader;
$this->dumper = $dumper;
}
public function filterLoad(AssetInterface $asset)
{
if (null !== $callable = $this->loader) {
$callable($asset);
}
}
public function filterDump(AssetInterface $asset)
{
if (null !== $callable = $this->dumper) {
$callable($asset);
}
}
}
src/Assetic/Filter/PackerFilter.php 0000666 00000002507 13436754447 0013270 0 ustar 00
*/
class PackerFilter implements FilterInterface
{
protected $encoding = 'None';
protected $fastDecode = true;
protected $specialChars = false;
public function setEncoding($encoding)
{
$this->encoding = $encoding;
}
public function setFastDecode($fastDecode)
{
$this->fastDecode = (bool) $fastDecode;
}
public function setSpecialChars($specialChars)
{
$this->specialChars = (bool) $specialChars;
}
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$packer = new \JavaScriptPacker($asset->getContent(), $this->encoding, $this->fastDecode, $this->specialChars);
$asset->setContent($packer->pack());
}
}
src/Assetic/Filter/CompassFilter.php 0000666 00000024271 13436754447 0013472 0 ustar 00
*/
class CompassFilter extends BaseProcessFilter
{
private $compassPath;
private $rubyPath;
private $scss;
// sass options
private $unixNewlines;
private $debugInfo;
private $cacheLocation;
private $noCache;
// compass options
private $force;
private $style;
private $quiet;
private $boring;
private $noLineComments;
private $imagesDir;
private $javascriptsDir;
private $fontsDir;
// compass configuration file options
private $plugins = array();
private $loadPaths = array();
private $httpPath;
private $httpImagesPath;
private $httpFontsPath;
private $httpGeneratedImagesPath;
private $generatedImagesPath;
private $httpJavascriptsPath;
private $homeEnv = true;
public function __construct($compassPath = '/usr/bin/compass', $rubyPath = null)
{
$this->compassPath = $compassPath;
$this->rubyPath = $rubyPath;
$this->cacheLocation = sys_get_temp_dir();
if ('cli' !== php_sapi_name()) {
$this->boring = true;
}
}
public function setScss($scss)
{
$this->scss = $scss;
}
// sass options setters
public function setUnixNewlines($unixNewlines)
{
$this->unixNewlines = $unixNewlines;
}
public function setDebugInfo($debugInfo)
{
$this->debugInfo = $debugInfo;
}
public function setCacheLocation($cacheLocation)
{
$this->cacheLocation = $cacheLocation;
}
public function setNoCache($noCache)
{
$this->noCache = $noCache;
}
// compass options setters
public function setForce($force)
{
$this->force = $force;
}
public function setStyle($style)
{
$this->style = $style;
}
public function setQuiet($quiet)
{
$this->quiet = $quiet;
}
public function setBoring($boring)
{
$this->boring = $boring;
}
public function setNoLineComments($noLineComments)
{
$this->noLineComments = $noLineComments;
}
public function setImagesDir($imagesDir)
{
$this->imagesDir = $imagesDir;
}
public function setJavascriptsDir($javascriptsDir)
{
$this->javascriptsDir = $javascriptsDir;
}
public function setFontsDir($fontsDir)
{
$this->fontsDir = $fontsDir;
}
// compass configuration file options setters
public function setPlugins(array $plugins)
{
$this->plugins = $plugins;
}
public function addPlugin($plugin)
{
$this->plugins[] = $plugin;
}
public function setLoadPaths(array $loadPaths)
{
$this->loadPaths = $loadPaths;
}
public function addLoadPath($loadPath)
{
$this->loadPaths[] = $loadPath;
}
public function setHttpPath($httpPath)
{
$this->httpPath = $httpPath;
}
public function setHttpImagesPath($httpImagesPath)
{
$this->httpImagesPath = $httpImagesPath;
}
public function setHttpFontsPath($httpFontsPath)
{
$this->httpFontsPath = $httpFontsPath;
}
public function setHttpGeneratedImagesPath($httpGeneratedImagesPath)
{
$this->httpGeneratedImagesPath = $httpGeneratedImagesPath;
}
public function setGeneratedImagesPath($generatedImagesPath)
{
$this->generatedImagesPath = $generatedImagesPath;
}
public function setHttpJavascriptsPath($httpJavascriptsPath)
{
$this->httpJavascriptsPath = $httpJavascriptsPath;
}
public function setHomeEnv($homeEnv)
{
$this->homeEnv = $homeEnv;
}
public function filterLoad(AssetInterface $asset)
{
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
$loadPaths = $this->loadPaths;
if ($root && $path) {
$loadPaths[] = dirname($root.'/'.$path);
}
// compass does not seems to handle symlink, so we use realpath()
$tempDir = realpath(sys_get_temp_dir());
$compassProcessArgs = array(
$this->compassPath,
'compile',
$tempDir,
);
if (null !== $this->rubyPath) {
$compassProcessArgs = array_merge(explode(' ', $this->rubyPath), $compassProcessArgs);
}
$pb = $this->createProcessBuilder($compassProcessArgs);
$pb->inheritEnvironmentVariables();
if ($this->force) {
$pb->add('--force');
}
if ($this->style) {
$pb->add('--output-style')->add($this->style);
}
if ($this->quiet) {
$pb->add('--quiet');
}
if ($this->boring) {
$pb->add('--boring');
}
if ($this->noLineComments) {
$pb->add('--no-line-comments');
}
// these two options are not passed into the config file
// because like this, compass adapts this to be xxx_dir or xxx_path
// whether it's an absolute path or not
if ($this->imagesDir) {
$pb->add('--images-dir')->add($this->imagesDir);
}
if ($this->javascriptsDir) {
$pb->add('--javascripts-dir')->add($this->javascriptsDir);
}
// options in config file
$optionsConfig = array();
if (!empty($loadPaths)) {
$optionsConfig['additional_import_paths'] = $loadPaths;
}
if ($this->unixNewlines) {
$optionsConfig['sass_options']['unix_newlines'] = true;
}
if ($this->debugInfo) {
$optionsConfig['sass_options']['debug_info'] = true;
}
if ($this->cacheLocation) {
$optionsConfig['sass_options']['cache_location'] = $this->cacheLocation;
}
if ($this->noCache) {
$optionsConfig['sass_options']['no_cache'] = true;
}
if ($this->httpPath) {
$optionsConfig['http_path'] = $this->httpPath;
}
if ($this->httpImagesPath) {
$optionsConfig['http_images_path'] = $this->httpImagesPath;
}
if ($this->httpFontsPath) {
$optionsConfig['http_fonts_path'] = $this->httpFontsPath;
}
if ($this->httpGeneratedImagesPath) {
$optionsConfig['http_generated_images_path'] = $this->httpGeneratedImagesPath;
}
if ($this->generatedImagesPath) {
$optionsConfig['generated_images_path'] = $this->generatedImagesPath;
}
if ($this->httpJavascriptsPath) {
$optionsConfig['http_javascripts_path'] = $this->httpJavascriptsPath;
}
if ($this->fontsDir) {
$optionsConfig['fonts_dir'] = $this->fontsDir;
}
// options in configuration file
if (count($optionsConfig)) {
$config = array();
foreach ($this->plugins as $plugin) {
$config[] = sprintf("require '%s'", addcslashes($plugin, '\\'));
}
foreach ($optionsConfig as $name => $value) {
if (!is_array($value)) {
$config[] = sprintf('%s = "%s"', $name, addcslashes($value, '\\'));
} elseif (!empty($value)) {
$config[] = sprintf('%s = %s', $name, $this->formatArrayToRuby($value));
}
}
$configFile = tempnam($tempDir, 'assetic_compass');
file_put_contents($configFile, implode("\n", $config)."\n");
$pb->add('--config')->add($configFile);
}
$pb->add('--sass-dir')->add('')->add('--css-dir')->add('');
// compass choose the type (sass or scss from the filename)
if (null !== $this->scss) {
$type = $this->scss ? 'scss' : 'sass';
} elseif ($path) {
// FIXME: what if the extension is something else?
$type = pathinfo($path, PATHINFO_EXTENSION);
} else {
$type = 'scss';
}
$tempName = tempnam($tempDir, 'assetic_compass');
unlink($tempName); // FIXME: don't use tempnam() here
// input
$input = $tempName.'.'.$type;
// work-around for https://github.com/chriseppstein/compass/issues/748
if (defined('PHP_WINDOWS_VERSION_MAJOR')) {
$input = str_replace('\\', '/', $input);
}
$pb->add($input);
file_put_contents($input, $asset->getContent());
// output
$output = $tempName.'.css';
if ($this->homeEnv) {
// it's not really usefull but... https://github.com/chriseppstein/compass/issues/376
$pb->setEnv('HOME', sys_get_temp_dir());
}
$proc = $pb->getProcess();
$code = $proc->run();
if (0 !== $code) {
unlink($input);
if (isset($configFile)) {
unlink($configFile);
}
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent(file_get_contents($output));
unlink($input);
unlink($output);
if (isset($configFile)) {
unlink($configFile);
}
}
public function filterDump(AssetInterface $asset)
{
}
private function formatArrayToRuby($array)
{
$output = array();
// does we have an associative array ?
if (count(array_filter(array_keys($array), "is_numeric")) != count($array)) {
foreach ($array as $name => $value) {
$output[] = sprintf(' :%s => "%s"', $name, addcslashes($value, '\\'));
}
$output = "{\n".implode(",\n", $output)."\n}";
} else {
foreach ($array as $name => $value) {
$output[] = sprintf(' "%s"', addcslashes($value, '\\'));
}
$output = "[\n".implode(",\n", $output)."\n]";
}
return $output;
}
}
src/Assetic/Filter/SprocketsFilter.php 0000666 00000007055 13436754447 0014043 0 ustar 00
*/
class SprocketsFilter extends BaseProcessFilter
{
private $sprocketsLib;
private $rubyBin;
private $includeDirs;
private $assetRoot;
/**
* Constructor.
*
* @param string $sprocketsLib Path to the Sprockets lib/ directory
* @param string $rubyBin Path to the ruby binary
*/
public function __construct($sprocketsLib = null, $rubyBin = '/usr/bin/ruby')
{
$this->sprocketsLib = $sprocketsLib;
$this->rubyBin = $rubyBin;
$this->includeDirs = array();
}
public function addIncludeDir($directory)
{
$this->includeDirs[] = $directory;
}
public function setAssetRoot($assetRoot)
{
$this->assetRoot = $assetRoot;
}
/**
* Hack around a bit, get the job done.
*/
public function filterLoad(AssetInterface $asset)
{
static $format = <<<'EOF'
#!/usr/bin/env ruby
require %s
%s
options = { :load_path => [],
:source_files => [%s],
:expand_paths => false }
%ssecretary = Sprockets::Secretary.new(options)
secretary.install_assets if options[:asset_root]
print secretary.concatenation
EOF;
$more = '';
foreach ($this->includeDirs as $directory) {
$more .= 'options[:load_path] << '.var_export($directory, true)."\n";
}
if (null !== $this->assetRoot) {
$more .= 'options[:asset_root] = '.var_export($this->assetRoot, true)."\n";
}
if ($more) {
$more .= "\n";
}
$tmpAsset = tempnam(sys_get_temp_dir(), 'assetic_sprockets');
file_put_contents($tmpAsset, $asset->getContent());
$input = tempnam(sys_get_temp_dir(), 'assetic_sprockets');
file_put_contents($input, sprintf($format,
$this->sprocketsLib
? sprintf('File.join(%s, \'sprockets\')', var_export($this->sprocketsLib, true))
: '\'sprockets\'',
$this->getHack($asset),
var_export($tmpAsset, true),
$more
));
$pb = $this->createProcessBuilder(array(
$this->rubyBin,
$input,
));
$proc = $pb->getProcess();
$code = $proc->run();
unlink($tmpAsset);
unlink($input);
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
public function filterDump(AssetInterface $asset)
{
}
private function getHack(AssetInterface $asset)
{
static $format = <<<'EOF'
module Sprockets
class Preprocessor
protected
def pathname_for_relative_require_from(source_line)
Sprockets::Pathname.new(@environment, File.join(%s, location_from(source_line)))
end
end
end
EOF;
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
if ($root && $path) {
return sprintf($format, var_export(dirname($root.'/'.$path), true));
}
}
}
src/Assetic/Filter/GoogleClosure/BaseCompilerFilter.php 0000666 00000004566 13436754447 0017210 0 ustar 00
*/
abstract class BaseCompilerFilter implements FilterInterface
{
// compilation levels
const COMPILE_WHITESPACE_ONLY = 'WHITESPACE_ONLY';
const COMPILE_SIMPLE_OPTIMIZATIONS = 'SIMPLE_OPTIMIZATIONS';
const COMPILE_ADVANCED_OPTIMIZATIONS = 'ADVANCED_OPTIMIZATIONS';
// formatting modes
const FORMAT_PRETTY_PRINT = 'pretty_print';
const FORMAT_PRINT_INPUT_DELIMITER = 'print_input_delimiter';
// warning levels
const LEVEL_QUIET = 'QUIET';
const LEVEL_DEFAULT = 'DEFAULT';
const LEVEL_VERBOSE = 'VERBOSE';
// languages
const LANGUAGE_ECMASCRIPT3 = 'ECMASCRIPT3';
const LANGUAGE_ECMASCRIPT5 = 'ECMASCRIPT5';
const LANGUAGE_ECMASCRIPT5_STRICT = 'ECMASCRIPT5_STRICT';
protected $compilationLevel;
protected $jsExterns;
protected $externsUrl;
protected $excludeDefaultExterns;
protected $formatting;
protected $useClosureLibrary;
protected $warningLevel;
protected $language;
public function setCompilationLevel($compilationLevel)
{
$this->compilationLevel = $compilationLevel;
}
public function setJsExterns($jsExterns)
{
$this->jsExterns = $jsExterns;
}
public function setExternsUrl($externsUrl)
{
$this->externsUrl = $externsUrl;
}
public function setExcludeDefaultExterns($excludeDefaultExterns)
{
$this->excludeDefaultExterns = $excludeDefaultExterns;
}
public function setFormatting($formatting)
{
$this->formatting = $formatting;
}
public function setUseClosureLibrary($useClosureLibrary)
{
$this->useClosureLibrary = $useClosureLibrary;
}
public function setWarningLevel($warningLevel)
{
$this->warningLevel = $warningLevel;
}
public function setLanguage($language)
{
$this->language = $language;
}
public function filterLoad(AssetInterface $asset)
{
}
}
src/Assetic/Filter/GoogleClosure/CompilerJarFilter.php 0000666 00000005322 13436754447 0017041 0 ustar 00
*/
class CompilerJarFilter extends BaseCompilerFilter
{
private $jarPath;
private $javaPath;
public function __construct($jarPath, $javaPath = '/usr/bin/java')
{
$this->jarPath = $jarPath;
$this->javaPath = $javaPath;
}
public function filterDump(AssetInterface $asset)
{
$cleanup = array();
$pb = new ProcessBuilder(array(
$this->javaPath,
'-jar',
$this->jarPath,
));
if (null !== $this->compilationLevel) {
$pb->add('--compilation_level')->add($this->compilationLevel);
}
if (null !== $this->jsExterns) {
$cleanup[] = $externs = tempnam(sys_get_temp_dir(), 'assetic_google_closure_compiler');
file_put_contents($externs, $this->jsExterns);
$pb->add('--externs')->add($externs);
}
if (null !== $this->externsUrl) {
$cleanup[] = $externs = tempnam(sys_get_temp_dir(), 'assetic_google_closure_compiler');
file_put_contents($externs, file_get_contents($this->externsUrl));
$pb->add('--externs')->add($externs);
}
if (null !== $this->excludeDefaultExterns) {
$pb->add('--use_only_custom_externs');
}
if (null !== $this->formatting) {
$pb->add('--formatting')->add($this->formatting);
}
if (null !== $this->useClosureLibrary) {
$pb->add('--manage_closure_dependencies');
}
if (null !== $this->warningLevel) {
$pb->add('--warning_level')->add($this->warningLevel);
}
if (null !== $this->language) {
$pb->add('--language_in')->add($this->language);
}
$pb->add('--js')->add($cleanup[] = $input = tempnam(sys_get_temp_dir(), 'assetic_google_closure_compiler'));
file_put_contents($input, $asset->getContent());
$proc = $pb->getProcess();
$code = $proc->run();
array_map('unlink', $cleanup);
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
}
src/Assetic/Filter/GoogleClosure/CompilerApiFilter.php 0000666 00000007123 13436754447 0017037 0 ustar 00
*/
class CompilerApiFilter extends BaseCompilerFilter
{
public function filterDump(AssetInterface $asset)
{
$query = array(
'js_code' => $asset->getContent(),
'output_format' => 'json',
'output_info' => 'compiled_code',
);
if (null !== $this->compilationLevel) {
$query['compilation_level'] = $this->compilationLevel;
}
if (null !== $this->jsExterns) {
$query['js_externs'] = $this->jsExterns;
}
if (null !== $this->externsUrl) {
$query['externs_url'] = $this->externsUrl;
}
if (null !== $this->excludeDefaultExterns) {
$query['exclude_default_externs'] = $this->excludeDefaultExterns ? 'true' : 'false';
}
if (null !== $this->formatting) {
$query['formatting'] = $this->formatting;
}
if (null !== $this->useClosureLibrary) {
$query['use_closure_library'] = $this->useClosureLibrary ? 'true' : 'false';
}
if (null !== $this->warningLevel) {
$query['warning_level'] = $this->warningLevel;
}
if (null !== $this->language) {
$query['language'] = $this->language;
}
if (preg_match('/1|yes|on|true/i', ini_get('allow_url_fopen'))) {
$context = stream_context_create(array('http' => array(
'method' => 'POST',
'header' => 'Content-Type: application/x-www-form-urlencoded',
'content' => http_build_query($query),
)));
$response = file_get_contents('http://closure-compiler.appspot.com/compile', false, $context);
$data = json_decode($response);
} elseif (defined('CURLOPT_POST') && !in_array('curl_init', explode(',', ini_get('disable_functions')))) {
$ch = curl_init('http://closure-compiler.appspot.com/compile');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-type: application/x-www-form-urlencoded'));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $query);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 15);
$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response);
} else {
throw new \RuntimeException("There is no known way to contact closure compiler available");
}
if (isset($data->serverErrors) && 0 < count($data->serverErrors)) {
// @codeCoverageIgnoreStart
throw new \RuntimeException(sprintf('The Google Closure Compiler API threw some server errors: '.print_r($data->serverErrors, true)));
// @codeCoverageIgnoreEnd
}
if (isset($data->errors) && 0 < count($data->errors)) {
// @codeCoverageIgnoreStart
throw new \RuntimeException(sprintf('The Google Closure Compiler API threw some errors: '.print_r($data->errors, true)));
// @codeCoverageIgnoreEnd
}
$asset->setContent($data->compiledCode);
}
}
src/Assetic/Filter/BaseProcessFilter.php 0000666 00000002224 13436754447 0014270 0 ustar 00 timeout = $timeout;
}
/**
* Creates a new process builder.
*
* @param array $arguments An optional array of arguments
*
* @return ProcessBuilder A new process builder
*/
protected function createProcessBuilder(array $arguments = array())
{
$pb = new ProcessBuilder($arguments);
if (null !== $this->timeout) {
$pb->setTimeout($this->timeout);
}
return $pb;
}
}
src/Assetic/Filter/PhpCssEmbedFilter.php 0000666 00000002110 13436754447 0014206 0 ustar 00
* @link https://github.com/krichprollsch/phpCssEmbed
*/
class PhpCssEmbedFilter implements FilterInterface
{
private $presets = array();
public function setPresets(array $presets)
{
$this->presets = $presets;
}
public function filterLoad(AssetInterface $asset)
{
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
$pce = new CssEmbed();
if ($root && $path) {
$pce->setRootDir(dirname($root.'/'.$path));
}
$asset->setContent($pce->embedString($asset->getContent()));
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/LessphpFilter.php 0000666 00000004302 13436754447 0013474 0 ustar 00
* @author Kris Wallsmith
*/
class LessphpFilter implements FilterInterface
{
private $presets = array();
private $formatter;
private $preserveComments;
/**
* Lessphp Load Paths
*
* @var array
*/
protected $loadPaths = array();
/**
* Adds a load path to the paths used by lessphp
*
* @param string $path Load Path
*/
public function addLoadPath($path)
{
$this->loadPaths[] = $path;
}
public function setPresets(array $presets)
{
$this->presets = $presets;
}
/**
* @param string $formatter One of "lessjs", "compressed", or "classic".
*/
public function setFormatter($formatter)
{
$this->formatter = $formatter;
}
/**
* @param boolean $preserveComments
*/
public function setPreserveComments($preserveComments)
{
$this->preserveComments = $preserveComments;
}
public function filterLoad(AssetInterface $asset)
{
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
$lc = new \lessc();
if ($root && $path) {
$lc->importDir = dirname($root.'/'.$path);
}
foreach ($this->loadPaths as $loadPath) {
$lc->addImportDir($loadPath);
}
if ($this->formatter) {
$lc->setFormatter($this->formatter);
}
if (null !== $this->preserveComments) {
$lc->setPreserveComments($this->preserveComments);
}
$asset->setContent($lc->parse($asset->getContent(), $this->presets));
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/JpegoptimFilter.php 0000666 00000003471 13436754447 0014022 0 ustar 00
*/
class JpegoptimFilter extends BaseProcessFilter
{
private $jpegoptimBin;
private $stripAll;
private $max;
/**
* Constructor.
*
* @param string $jpegoptimBin Path to the jpegoptim binary
*/
public function __construct($jpegoptimBin = '/usr/bin/jpegoptim')
{
$this->jpegoptimBin = $jpegoptimBin;
}
public function setStripAll($stripAll)
{
$this->stripAll = $stripAll;
}
public function setMax($max)
{
$this->max = $max;
}
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$pb = $this->createProcessBuilder(array($this->jpegoptimBin));
if ($this->stripAll) {
$pb->add('--strip-all');
}
if ($this->max) {
$pb->add('--max='.$this->max);
}
$pb->add($input = tempnam(sys_get_temp_dir(), 'assetic_jpegoptim'));
file_put_contents($input, $asset->getContent());
$proc = $pb->getProcess();
$proc->run();
if (false !== strpos($proc->getOutput(), 'ERROR')) {
unlink($input);
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent(file_get_contents($input));
unlink($input);
}
}
src/Assetic/Filter/JSMinPlusFilter.php 0000666 00000001445 13436754447 0013707 0 ustar 00
*/
class JSMinPlusFilter implements FilterInterface
{
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$asset->setContent(\JSMinPlus::minify($asset->getContent()));
}
}
src/Assetic/Filter/CssRewriteFilter.php 0000666 00000006722 13436754447 0014160 0 ustar 00
*/
class CssRewriteFilter extends BaseCssFilter
{
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$sourceBase = $asset->getSourceRoot();
$sourcePath = $asset->getSourcePath();
$targetPath = $asset->getTargetPath();
if (null === $sourcePath || null === $targetPath || $sourcePath == $targetPath) {
return;
}
// learn how to get from the target back to the source
if (false !== strpos($sourceBase, '://')) {
list($scheme, $url) = explode('://', $sourceBase.'/'.$sourcePath, 2);
list($host, $path) = explode('/', $url, 2);
$host = $scheme.'://'.$host.'/';
$path = false === strpos($path, '/') ? '' : dirname($path);
$path .= '/';
} else {
// assume source and target are on the same host
$host = '';
// pop entries off the target until it fits in the source
if ('.' == dirname($sourcePath)) {
$path = str_repeat('../', substr_count($targetPath, '/'));
} elseif ('.' == $targetDir = dirname($targetPath)) {
$path = dirname($sourcePath).'/';
} else {
$path = '';
while (0 !== strpos($sourcePath, $targetDir)) {
if (false !== $pos = strrpos($targetDir, '/')) {
$targetDir = substr($targetDir, 0, $pos);
$path .= '../';
} else {
$targetDir = '';
$path .= '../';
break;
}
}
$path .= ltrim(substr(dirname($sourcePath).'/', strlen($targetDir)), '/');
}
}
$content = $this->filterReferences($asset->getContent(), function($matches) use ($host, $path) {
if (false !== strpos($matches['url'], '://') || 0 === strpos($matches['url'], '//') || 0 === strpos($matches['url'], 'data:')) {
// absolute or protocol-relative or data uri
return $matches[0];
}
if (isset($matches['url'][0]) && '/' == $matches['url'][0]) {
// root relative
return str_replace($matches['url'], $host.$matches['url'], $matches[0]);
}
// document relative
$url = $matches['url'];
while (0 === strpos($url, '../') && 2 <= substr_count($path, '/')) {
$path = substr($path, 0, strrpos(rtrim($path, '/'), '/') + 1);
$url = substr($url, 3);
}
$parts = array();
foreach (explode('/', $host.$path.$url) as $part) {
if ('..' === $part && count($parts) && '..' !== end($parts)) {
array_pop($parts);
} else {
$parts[] = $part;
}
}
return str_replace($matches['url'], implode('/', $parts), $matches[0]);
});
$asset->setContent($content);
}
}
src/Assetic/Filter/FilterInterface.php 0000666 00000001443 13436754447 0013761 0 ustar 00
*/
interface FilterInterface
{
/**
* Filters an asset after it has been loaded.
*
* @param AssetInterface $asset An asset
*/
public function filterLoad(AssetInterface $asset);
/**
* Filters an asset just before it's dumped.
*
* @param AssetInterface $asset An asset
*/
public function filterDump(AssetInterface $asset);
}
src/Assetic/Filter/JpegtranFilter.php 0000666 00000004372 13436754447 0013637 0 ustar 00
*/
class JpegtranFilter extends BaseProcessFilter
{
const COPY_NONE = 'none';
const COPY_COMMENTS = 'comments';
const COPY_ALL = 'all';
private $jpegtranBin;
private $optimize;
private $copy;
private $progressive;
private $restart;
/**
* Constructor.
*
* @param string $jpegtranBin Path to the jpegtran binary
*/
public function __construct($jpegtranBin = '/usr/bin/jpegtran')
{
$this->jpegtranBin = $jpegtranBin;
}
public function setOptimize($optimize)
{
$this->optimize = $optimize;
}
public function setCopy($copy)
{
$this->copy = $copy;
}
public function setProgressive($progressive)
{
$this->progressive = $progressive;
}
public function setRestart($restart)
{
$this->restart = $restart;
}
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$pb = $this->createProcessBuilder(array($this->jpegtranBin));
if ($this->optimize) {
$pb->add('-optimize');
}
if ($this->copy) {
$pb->add('-copy')->add($this->copy);
}
if ($this->progressive) {
$pb->add('-progressive');
}
if (null !== $this->restart) {
$pb->add('-restart')->add($this->restart);
}
$pb->add($input = tempnam(sys_get_temp_dir(), 'assetic_jpegtran'));
file_put_contents($input, $asset->getContent());
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
}
src/Assetic/Filter/CssEmbedFilter.php 0000666 00000006664 13436754447 0013560 0 ustar 00
*/
class CssEmbedFilter extends BaseProcessFilter
{
private $jarPath;
private $javaPath;
private $charset;
private $mhtml; // Enable MHTML mode.
private $mhtmlRoot; // Use as the MHTML root for the file.
private $root; // Prepends to all relative URLs.
private $skipMissing; // Don't throw an error for missing image files.
private $maxUriLength; // Maximum length for a data URI. Defaults to 32768.
private $maxImageSize; // Maximum image size (in bytes) to convert.
public function __construct($jarPath, $javaPath = '/usr/bin/java')
{
$this->jarPath = $jarPath;
$this->javaPath = $javaPath;
}
public function setCharset($charset)
{
$this->charset = $charset;
}
public function setMhtml($mhtml)
{
$this->mhtml = $mhtml;
}
public function setMhtmlRoot($mhtmlRoot)
{
$this->mhtmlRoot = $mhtmlRoot;
}
public function setRoot($root)
{
$this->root = $root;
}
public function setSkipMissing($skipMissing)
{
$this->skipMissing = $skipMissing;
}
public function setMaxUriLength($maxUriLength)
{
$this->maxUriLength = $maxUriLength;
}
public function setMaxImageSize($maxImageSize)
{
$this->maxImageSize = $maxImageSize;
}
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$pb = $this->createProcessBuilder(array(
$this->javaPath,
'-jar',
$this->jarPath,
));
if (null !== $this->charset) {
$pb->add('--charset')->add($this->charset);
}
if ($this->mhtml) {
$pb->add('--mhtml');
}
if (null !== $this->mhtmlRoot) {
$pb->add('--mhtmlroot')->add($this->mhtmlRoot);
}
// automatically define root if not already defined
if (null === $this->root) {
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
if ($root && $path) {
$pb->add('--root')->add(dirname($root.'/'.$path));
}
} else {
$pb->add('--root')->add($this->root);
}
if ($this->skipMissing) {
$pb->add('--skip-missing');
}
if (null !== $this->maxUriLength) {
$pb->add('--max-uri-length')->add($this->maxUriLength);
}
if (null !== $this->maxImageSize) {
$pb->add('--max-image-size')->add($this->maxImageSize);
}
// input
$pb->add($input = tempnam(sys_get_temp_dir(), 'assetic_cssembed'));
file_put_contents($input, $asset->getContent());
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
}
src/Assetic/Filter/FilterCollection.php 0000666 00000003451 13436754447 0014155 0 ustar 00
*/
class FilterCollection implements FilterInterface, \IteratorAggregate, \Countable
{
private $filters = array();
public function __construct($filters = array())
{
foreach ($filters as $filter) {
$this->ensure($filter);
}
}
/**
* Checks that the current collection contains the supplied filter.
*
* If the supplied filter is another filter collection, each of its
* filters will be checked.
*/
public function ensure(FilterInterface $filter)
{
if ($filter instanceof \Traversable) {
foreach ($filter as $f) {
$this->ensure($f);
}
} elseif (!in_array($filter, $this->filters, true)) {
$this->filters[] = $filter;
}
}
public function all()
{
return $this->filters;
}
public function clear()
{
$this->filters = array();
}
public function filterLoad(AssetInterface $asset)
{
foreach ($this->filters as $filter) {
$filter->filterLoad($asset);
}
}
public function filterDump(AssetInterface $asset)
{
foreach ($this->filters as $filter) {
$filter->filterDump($asset);
}
}
public function getIterator()
{
return new \ArrayIterator($this->filters);
}
public function count()
{
return count($this->filters);
}
}
src/Assetic/Filter/HandlebarsFilter.php 0000666 00000005113 13436754447 0014122 0 ustar 00
*/
class HandlebarsFilter extends BaseNodeFilter
{
private $handlebarsBin;
private $nodeBin;
private $minimize = false;
private $simple = false;
public function __construct($handlebarsBin = '/usr/bin/handlebars', $nodeBin = null)
{
$this->handlebarsBin = $handlebarsBin;
$this->nodeBin = $nodeBin;
}
public function setMinimize($minimize)
{
$this->minimize = $minimize;
}
public function setSimple($simple)
{
$this->simple = $simple;
}
public function filterLoad(AssetInterface $asset)
{
$pb = $this->createProcessBuilder($this->nodeBin
? array($this->nodeBin, $this->handlebarsBin)
: array($this->handlebarsBin));
$templateName = basename($asset->getSourcePath());
$inputDirPath = sys_get_temp_dir().DIRECTORY_SEPARATOR.uniqid('input_dir');
$inputPath = $inputDirPath.DIRECTORY_SEPARATOR.$templateName;
$outputPath = tempnam(sys_get_temp_dir(), 'output');
mkdir($inputDirPath);
file_put_contents($inputPath, $asset->getContent());
$pb->add($inputPath)->add('-f')->add($outputPath);
if ($this->minimize) {
$pb->add('--min');
}
if ($this->simple) {
$pb->add('--simple');
}
$process = $pb->getProcess();
$returnCode = $process->run();
unlink($inputPath);
rmdir($inputDirPath);
if (127 === $returnCode) {
throw new \RuntimeException('Path to node executable could not be resolved.');
}
if (0 !== $returnCode) {
if (file_exists($outputPath)) {
unlink($outputPath);
}
throw FilterException::fromProcess($process)->setInput($asset->getContent());
}
if (!file_exists($outputPath)) {
throw new \RuntimeException('Error creating output file.');
}
$compiledJs = file_get_contents($outputPath);
unlink($outputPath);
$asset->setContent($compiledJs);
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/BaseNodeFilter.php 0000666 00000001636 13436754447 0013545 0 ustar 00 nodePaths;
}
public function setNodePaths(array $nodePaths)
{
$this->nodePaths = $nodePaths;
}
public function addNodePath($nodePath)
{
$this->nodePaths[] = $nodePath;
}
protected function createProcessBuilder(array $arguments = array())
{
$pb = parent::createProcessBuilder($arguments);
if ($this->nodePaths) {
$pb->setEnv('NODE_PATH', implode(':', $this->nodePaths));
}
return $pb;
}
}
src/Assetic/Filter/CoffeeScriptFilter.php 0000666 00000003213 13436754447 0014432 0 ustar 00
*/
class CoffeeScriptFilter extends BaseNodeFilter
{
private $coffeeBin;
private $nodeBin;
// coffee options
private $bare;
public function __construct($coffeeBin = '/usr/bin/coffee', $nodeBin = null)
{
$this->coffeeBin = $coffeeBin;
$this->nodeBin = $nodeBin;
}
public function setBare($bare)
{
$this->bare = $bare;
}
public function filterLoad(AssetInterface $asset)
{
$input = tempnam(sys_get_temp_dir(), 'assetic_coffeescript');
file_put_contents($input, $asset->getContent());
$pb = $this->createProcessBuilder($this->nodeBin
? array($this->nodeBin, $this->coffeeBin)
: array($this->coffeeBin));
$pb->add('-cp');
if ($this->bare) {
$pb->add('--bare');
}
$pb->add($input);
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/PngoutFilter.php 0000666 00000005744 13436754447 0013345 0 ustar 00
*/
class PngoutFilter extends BaseProcessFilter
{
// -c#
const COLOR_GREY = '0';
const COLOR_RGB = '2';
const COLOR_PAL = '3';
const COLOR_GRAY_ALPHA = '4';
const COLOR_RGB_ALPHA = '6';
// -f#
const FILTER_NONE = '0';
const FILTER_X = '1';
const FILTER_Y = '2';
const FILTER_X_Y = '3';
const FILTER_PAETH = '4';
const FILTER_MIXED = '5';
// -s#
const STRATEGY_XTREME = '0';
const STRATEGY_INTENSE = '1';
const STRATEGY_LONGEST_MATCH = '2';
const STRATEGY_HUFFMAN_ONLY = '3';
const STRATEGY_UNCOMPRESSED = '4';
private $pngoutBin;
private $color;
private $filter;
private $strategy;
private $blockSplitThreshold;
/**
* Constructor.
*
* @param string $pngoutBin Path to the pngout binary
*/
public function __construct($pngoutBin = '/usr/bin/pngout')
{
$this->pngoutBin = $pngoutBin;
}
public function setColor($color)
{
$this->color = $color;
}
public function setFilter($filter)
{
$this->filter = $filter;
}
public function setStrategy($strategy)
{
$this->strategy = $strategy;
}
public function setBlockSplitThreshold($blockSplitThreshold)
{
$this->blockSplitThreshold = $blockSplitThreshold;
}
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$pb = $this->createProcessBuilder(array($this->pngoutBin));
if (null !== $this->color) {
$pb->add('-c'.$this->color);
}
if (null !== $this->filter) {
$pb->add('-f'.$this->filter);
}
if (null !== $this->strategy) {
$pb->add('-s'.$this->strategy);
}
if (null !== $this->blockSplitThreshold) {
$pb->add('-b'.$this->blockSplitThreshold);
}
$pb->add($input = tempnam(sys_get_temp_dir(), 'assetic_pngout'));
file_put_contents($input, $asset->getContent());
$output = tempnam(sys_get_temp_dir(), 'assetic_pngout');
unlink($output);
$pb->add($output .= '.png');
$proc = $pb->getProcess();
$code = $proc->run();
if (0 !== $code) {
unlink($input);
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent(file_get_contents($output));
unlink($input);
unlink($output);
}
}
src/Assetic/Filter/PackagerFilter.php 0000666 00000003034 13436754447 0013574 0 ustar 00
*/
class PackagerFilter implements FilterInterface
{
private $packages;
public function __construct(array $packages = array())
{
$this->packages = $packages;
}
public function addPackage($package)
{
$this->packages[] = $package;
}
public function filterLoad(AssetInterface $asset)
{
static $manifest = <<getContent());
$packager = new \Packager(array_merge(array($package), $this->packages));
$content = $packager->build(array(), array(), array('Application'.$hash));
unlink($package.'/package.yml');
unlink($package.'/source.js');
rmdir($package);
$asset->setContent($content);
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/OptiPngFilter.php 0000666 00000003341 13436754447 0013440 0 ustar 00
*/
class OptiPngFilter extends BaseProcessFilter
{
private $optipngBin;
private $level;
/**
* Constructor.
*
* @param string $optipngBin Path to the optipng binary
*/
public function __construct($optipngBin = '/usr/bin/optipng')
{
$this->optipngBin = $optipngBin;
}
public function setLevel($level)
{
$this->level = $level;
}
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$pb = $this->createProcessBuilder(array($this->optipngBin));
if (null !== $this->level) {
$pb->add('-o')->add($this->level);
}
$pb->add('-out')->add($output = tempnam(sys_get_temp_dir(), 'assetic_optipng'));
unlink($output);
$pb->add($input = tempnam(sys_get_temp_dir(), 'assetic_optipng'));
file_put_contents($input, $asset->getContent());
$proc = $pb->getProcess();
$code = $proc->run();
if (0 !== $code) {
unlink($input);
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent(file_get_contents($output));
unlink($input);
unlink($output);
}
}
src/Assetic/Filter/UglifyJsFilter.php 0000666 00000007037 13436754447 0013622 0 ustar 00
*/
class UglifyJsFilter extends BaseNodeFilter
{
private $uglifyjsBin;
private $nodeBin;
private $noCopyright;
private $beautify;
private $unsafe;
private $mangle;
/**
* @param string $uglifyjsBin Absolute path to the uglifyjs executable
* @param string $nodeBin Absolute path to the folder containg node.js executable
*/
public function __construct($uglifyjsBin = '/usr/bin/uglifyjs', $nodeBin = null)
{
$this->uglifyjsBin = $uglifyjsBin;
$this->nodeBin = $nodeBin;
}
/**
* Removes the first block of comments as well
* @param bool $noCopyright True to enable
*/
public function setNoCopyright($noCopyright)
{
$this->noCopyright = $noCopyright;
}
/**
* Output indented code
* @param bool $beautify True to enable
*/
public function setBeautify($beautify)
{
$this->beautify = $beautify;
}
/**
* Enable additional optimizations that are known to be unsafe in some situations.
* @param bool $unsafe True to enable
*/
public function setUnsafe($unsafe)
{
$this->unsafe = $unsafe;
}
/**
* Safely mangle variable and function names for greater file compress.
* @param bool $mangle True to enable
*/
public function setMangle($mangle)
{
$this->mangle = $mangle;
}
/**
* @see Assetic\Filter\FilterInterface::filterLoad()
*/
public function filterLoad(AssetInterface $asset)
{
}
/**
* Run the asset through UglifyJs
*
* @see Assetic\Filter\FilterInterface::filterDump()
*/
public function filterDump(AssetInterface $asset)
{
$pb = $this->createProcessBuilder($this->nodeBin
? array($this->nodeBin, $this->uglifyjsBin)
: array($this->uglifyjsBin));
if ($this->noCopyright) {
$pb->add('--no-copyright');
}
if ($this->beautify) {
$pb->add('--beautify');
}
if ($this->unsafe) {
$pb->add('--unsafe');
}
if (false === $this->mangle) {
$pb->add('--no-mangle');
}
// input and output files
$input = tempnam(sys_get_temp_dir(), 'input');
$output = tempnam(sys_get_temp_dir(), 'output');
file_put_contents($input, $asset->getContent());
$pb->add('-o')->add($output)->add($input);
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
if (file_exists($output)) {
unlink($output);
}
if (127 === $code) {
throw new \RuntimeException('Path to node executable could not be resolved.');
}
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
if (!file_exists($output)) {
throw new \RuntimeException('Error creating output file.');
}
$uglifiedJs = file_get_contents($output);
unlink($output);
$asset->setContent($uglifiedJs);
}
}
src/Assetic/Filter/CssMinFilter.php 0000666 00000003307 13436754447 0013256 0 ustar 00
*/
class CssMinFilter implements FilterInterface
{
private $filters;
private $plugins;
public function __construct()
{
$this->filters = array();
$this->plugins = array();
}
public function setFilters(array $filters)
{
$this->filters = $filters;
}
public function setFilter($name, $value)
{
$this->filters[$name] = $value;
}
public function setPlugins(array $plugins)
{
$this->plugins = $plugins;
}
public function setPlugin($name, $value)
{
$this->plugins[$name] = $value;
}
public function filterLoad(AssetInterface $asset)
{
}
public function filterDump(AssetInterface $asset)
{
$filters = $this->filters;
$plugins = $this->plugins;
if (isset($filters['ImportImports']) && true === $filters['ImportImports']) {
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
if ($root && $path) {
$filters['ImportImports'] = array('BasePath' => dirname($root.'/'.$path));
} else {
unset($filters['ImportImports']);
}
}
$asset->setContent(\CssMin::minify($asset->getContent(), $filters, $plugins));
}
}
src/Assetic/Filter/Sass/ScssFilter.php 0000666 00000001143 13436754447 0013702 0 ustar 00
*/
class ScssFilter extends SassFilter
{
public function __construct($sassPath = '/usr/bin/sass', $rubyPath = null)
{
parent::__construct($sassPath, $rubyPath);
$this->setScss(true);
}
}
src/Assetic/Filter/Sass/SassFilter.php 0000666 00000010027 13436754447 0013701 0 ustar 00
*/
class SassFilter extends BaseProcessFilter
{
const STYLE_NESTED = 'nested';
const STYLE_EXPANDED = 'expanded';
const STYLE_COMPACT = 'compact';
const STYLE_COMPRESSED = 'compressed';
private $sassPath;
private $rubyPath;
private $unixNewlines;
private $scss;
private $style;
private $quiet;
private $debugInfo;
private $lineNumbers;
private $loadPaths = array();
private $cacheLocation;
private $noCache;
private $compass;
public function __construct($sassPath = '/usr/bin/sass', $rubyPath = null)
{
$this->sassPath = $sassPath;
$this->rubyPath = $rubyPath;
$this->cacheLocation = realpath(sys_get_temp_dir());
}
public function setUnixNewlines($unixNewlines)
{
$this->unixNewlines = $unixNewlines;
}
public function setScss($scss)
{
$this->scss = $scss;
}
public function setStyle($style)
{
$this->style = $style;
}
public function setQuiet($quiet)
{
$this->quiet = $quiet;
}
public function setDebugInfo($debugInfo)
{
$this->debugInfo = $debugInfo;
}
public function setLineNumbers($lineNumbers)
{
$this->lineNumbers = $lineNumbers;
}
public function addLoadPath($loadPath)
{
$this->loadPaths[] = $loadPath;
}
public function setCacheLocation($cacheLocation)
{
$this->cacheLocation = $cacheLocation;
}
public function setNoCache($noCache)
{
$this->noCache = $noCache;
}
public function setCompass($compass)
{
$this->compass = $compass;
}
public function filterLoad(AssetInterface $asset)
{
$sassProcessArgs = array($this->sassPath);
if (null !== $this->rubyPath) {
$sassProcessArgs = array_merge(explode(' ', $this->rubyPath), $sassProcessArgs);
}
$pb = $this->createProcessBuilder($sassProcessArgs);
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
if ($root && $path) {
$pb->add('--load-path')->add(dirname($root.'/'.$path));
}
if ($this->unixNewlines) {
$pb->add('--unix-newlines');
}
if (true === $this->scss || (null === $this->scss && 'scss' == pathinfo($path, PATHINFO_EXTENSION))) {
$pb->add('--scss');
}
if ($this->style) {
$pb->add('--style')->add($this->style);
}
if ($this->quiet) {
$pb->add('--quiet');
}
if ($this->debugInfo) {
$pb->add('--debug-info');
}
if ($this->lineNumbers) {
$pb->add('--line-numbers');
}
foreach ($this->loadPaths as $loadPath) {
$pb->add('--load-path')->add($loadPath);
}
if ($this->cacheLocation) {
$pb->add('--cache-location')->add($this->cacheLocation);
}
if ($this->noCache) {
$pb->add('--no-cache');
}
if ($this->compass) {
$pb->add('--compass');
}
// input
$pb->add($input = tempnam(sys_get_temp_dir(), 'assetic_sass'));
file_put_contents($input, $asset->getContent());
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/Filter/LessFilter.php 0000666 00000006042 13436754447 0012767 0 ustar 00
*/
class LessFilter extends BaseNodeFilter
{
private $nodeBin;
private $compress;
/**
* Load Paths
*
* A list of paths which less will search for includes.
*
* @var array
*/
protected $loadPaths = array();
/**
* Constructor.
*
* @param string $nodeBin The path to the node binary
* @param array $nodePaths An array of node paths
*/
public function __construct($nodeBin = '/usr/bin/node', array $nodePaths = array())
{
$this->nodeBin = $nodeBin;
$this->setNodePaths($nodePaths);
}
public function setCompress($compress)
{
$this->compress = $compress;
}
/**
* Adds a path where less will search for includes
*
* @param string $path Load path (absolute)
*/
public function addLoadPath($path)
{
$this->loadPaths[] = $path;
}
public function filterLoad(AssetInterface $asset)
{
static $format = <<<'EOF'
var less = require('less');
var sys = require(process.binding('natives').util ? 'util' : 'sys');
new(less.Parser)(%s).parse(%s, function(e, tree) {
if (e) {
less.writeError(e);
process.exit(2);
}
try {
sys.print(tree.toCSS(%s));
} catch (e) {
less.writeError(e);
process.exit(3);
}
});
EOF;
$root = $asset->getSourceRoot();
$path = $asset->getSourcePath();
// parser options
$parserOptions = array();
if ($root && $path) {
$parserOptions['paths'] = array(dirname($root.'/'.$path));
$parserOptions['filename'] = basename($path);
}
foreach ($this->loadPaths as $loadPath) {
$parserOptions['paths'][] = $loadPath;
}
// tree options
$treeOptions = array();
if (null !== $this->compress) {
$treeOptions['compress'] = $this->compress;
}
$pb = $this->createProcessBuilder();
$pb->inheritEnvironmentVariables();
$pb->add($this->nodeBin)->add($input = tempnam(sys_get_temp_dir(), 'assetic_less'));
file_put_contents($input, sprintf($format,
json_encode($parserOptions),
json_encode($asset->getContent()),
json_encode($treeOptions)
));
$proc = $pb->getProcess();
$code = $proc->run();
unlink($input);
if (0 !== $code) {
throw FilterException::fromProcess($proc)->setInput($asset->getContent());
}
$asset->setContent($proc->getOutput());
}
public function filterDump(AssetInterface $asset)
{
}
}
src/Assetic/AssetWriter.php 0000666 00000005632 13436754447 0011746 0 ustar 00
* @author Johannes M. Schmitt
*/
class AssetWriter
{
private $dir;
private $varValues;
/**
* Constructor.
*
* @param string $dir The base web directory
* @param array $varValues
*
* @throws \InvalidArgumentException if a variable value is not a string
*/
public function __construct($dir, array $varValues = array())
{
foreach ($varValues as $var => $values) {
foreach ($values as $value) {
if (!is_string($value)) {
throw new \InvalidArgumentException(sprintf('All variable values must be strings, but got %s for variable "%s".', json_encode($value), $var));
}
}
}
$this->dir = $dir;
$this->varValues = $varValues;
}
public function writeManagerAssets(AssetManager $am)
{
foreach ($am->getNames() as $name) {
$this->writeAsset($am->get($name));
}
}
public function writeAsset(AssetInterface $asset)
{
foreach ($this->getCombinations($asset->getVars()) as $combination) {
$asset->setValues($combination);
static::write($this->dir.'/'.PathUtils::resolvePath(
$asset->getTargetPath(), $asset->getVars(), $asset->getValues()),
$asset->dump());
}
}
private function getCombinations(array $vars)
{
if (!$vars) {
return array(array());
}
$combinations = array();
$nbValues = array();
foreach ($this->varValues as $var => $values) {
if (!in_array($var, $vars, true)) {
continue;
}
$nbValues[$var] = count($values);
}
for ($i=array_product($nbValues),$c=$i*2; $i<$c; $i++) {
$k = $i;
$combination = array();
foreach ($vars as $var) {
$combination[$var] = $this->varValues[$var][$k % $nbValues[$var]];
$k = intval($k/$nbValues[$var]);
}
$combinations[] = $combination;
}
return $combinations;
}
protected static function write($path, $contents)
{
if (!is_dir($dir = dirname($path)) && false === @mkdir($dir, 0777, true)) {
throw new \RuntimeException('Unable to create directory '.$dir);
}
if (false === @file_put_contents($path, $contents)) {
throw new \RuntimeException('Unable to write file '.$path);
}
}
}
src/Assetic/Util/TraversableString.php 0000666 00000001556 13436754447 0014051 0 ustar 00
*/
class TraversableString implements \IteratorAggregate, \Countable
{
private $one;
private $many;
public function __construct($one, array $many)
{
$this->one = $one;
$this->many = $many;
}
public function getIterator()
{
return new \ArrayIterator($this->many);
}
public function count()
{
return count($this->many);
}
public function __toString()
{
return (string) $this->one;
}
}
src/Assetic/Util/PathUtils.php 0000666 00000001722 13436754447 0012320 0 ustar 00
*/
abstract class PathUtils
{
public static function resolvePath($path, array $vars, array $values)
{
$map = array();
foreach ($vars as $var) {
if (false === strpos($path, '{'.$var.'}')) {
continue;
}
if (!isset($values[$var])) {
throw new \InvalidArgumentException(sprintf('The path "%s" contains the variable "%s", but was not given any value for it.', $path, $var));
}
$map['{'.$var.'}'] = $values[$var];
}
return strtr($path, $map);
}
final private function __construct() { }
}
src/Assetic/FilterManager.php 0000666 00000002616 13436754447 0012211 0 ustar 00
*/
class FilterManager
{
private $filters = array();
public function set($alias, FilterInterface $filter)
{
$this->checkName($alias);
$this->filters[$alias] = $filter;
}
public function get($alias)
{
if (!isset($this->filters[$alias])) {
throw new \InvalidArgumentException(sprintf('There is no "%s" filter.', $alias));
}
return $this->filters[$alias];
}
public function has($alias)
{
return isset($this->filters[$alias]);
}
public function getNames()
{
return array_keys($this->filters);
}
/**
* Checks that a name is valid.
*
* @param string $name An asset name candidate
*
* @throws \InvalidArgumentException If the asset name is invalid
*/
protected function checkName($name)
{
if (!ctype_alnum(str_replace('_', '', $name))) {
throw new \InvalidArgumentException(sprintf('The name "%s" is invalid.', $name));
}
}
}
src/Assetic/Asset/AssetInterface.php 0000666 00000007547 13436754447 0013460 0 ustar 00
*/
interface AssetInterface
{
/**
* Ensures the current asset includes the supplied filter.
*
* @param FilterInterface $filter A filter
*/
public function ensureFilter(FilterInterface $filter);
/**
* Returns an array of filters currently applied.
*
* @return array An array of filters
*/
public function getFilters();
/**
* Clears all filters from the current asset.
*/
public function clearFilters();
/**
* Loads the asset into memory and applies load filters.
*
* You may provide an additional filter to apply during load.
*
* @param FilterInterface $additionalFilter An additional filter
*/
public function load(FilterInterface $additionalFilter = null);
/**
* Applies dump filters and returns the asset as a string.
*
* You may provide an additional filter to apply during dump.
*
* Dumping an asset should not change its state.
*
* If the current asset has not been loaded yet, it should be
* automatically loaded at this time.
*
* @param FilterInterface $additionalFilter An additional filter
*
* @return string The filtered content of the current asset
*/
public function dump(FilterInterface $additionalFilter = null);
/**
* Returns the loaded content of the current asset.
*
* @return string The content
*/
public function getContent();
/**
* Sets the content of the current asset.
*
* Filters can use this method to change the content of the asset.
*
* @param string $content The asset content
*/
public function setContent($content);
/**
* Returns an absolute path or URL to the source asset's root directory.
*
* This value should be an absolute path to a directory in the filesystem,
* an absolute URL with no path, or null.
*
* For example:
*
* * '/path/to/web'
* * 'http://example.com'
* * null
*
* @return string|null The asset's root
*/
public function getSourceRoot();
/**
* Returns the relative path for the source asset.
*
* This value can be combined with the asset's source root (if both are
* non-null) to get something compatible with file_get_contents().
*
* For example:
*
* * 'js/main.js'
* * 'main.js'
* * null
*
* @return string|null The source asset path
*/
public function getSourcePath();
/**
* Returns the URL for the current asset.
*
* @return string|null A web URL where the asset will be dumped
*/
public function getTargetPath();
/**
* Sets the URL for the current asset.
*
* @param string $targetPath A web URL where the asset will be dumped
*/
public function setTargetPath($targetPath);
/**
* Returns the time the current asset was last modified.
*
* @return integer|null A UNIX timestamp
*/
public function getLastModified();
/**
* Returns an array of variable names for this asset.
*
* @return array
*/
public function getVars();
/**
* Sets the values for the asset's variables.
*
* @param array $values
*/
public function setValues(array $values);
/**
* Returns the current values for this asset.
*
* @return array an array of strings
*/
public function getValues();
}
src/Assetic/Asset/AssetCollectionInterface.php 0000666 00000003260 13436754447 0015460 0 ustar 00
*/
interface AssetCollectionInterface extends AssetInterface, \Traversable
{
/**
* Returns all child assets.
*
* @return array An array of AssetInterface objects
*/
public function all();
/**
* Adds an asset to the current collection.
*
* @param AssetInterface $asset An asset
*/
public function add(AssetInterface $asset);
/**
* Removes a leaf.
*
* @param AssetInterface $leaf The leaf to remove
* @param Boolean $graceful Whether the failure should return false or throw an exception
*
* @return Boolean Whether the asset has been found
*
* @throws \InvalidArgumentException If the asset cannot be found
*/
public function removeLeaf(AssetInterface $leaf, $graceful = false);
/**
* Replaces an existing leaf with a new one.
*
* @param AssetInterface $needle The current asset to replace
* @param AssetInterface $replacement The new asset
* @param Boolean $graceful Whether the failure should return false or throw an exception
*
* @return Boolean Whether the asset has been found
*
* @throws \InvalidArgumentException If the asset cannot be found
*/
public function replaceLeaf(AssetInterface $needle, AssetInterface $replacement, $graceful = false);
}
src/Assetic/Asset/AssetCollection.php 0000666 00000013027 13436754447 0013641 0 ustar 00
*/
class AssetCollection implements \IteratorAggregate, AssetCollectionInterface
{
private $assets;
private $filters;
private $sourceRoot;
private $targetPath;
private $content;
private $clones;
private $vars;
private $values;
/**
* Constructor.
*
* @param array $assets Assets for the current collection
* @param array $filters Filters for the current collection
* @param string $sourceRoot The root directory
* @param array $vars
*/
public function __construct($assets = array(), $filters = array(), $sourceRoot = null, array $vars = array())
{
$this->assets = array();
foreach ($assets as $asset) {
$this->add($asset);
}
$this->filters = new FilterCollection($filters);
$this->sourceRoot = $sourceRoot;
$this->clones = new \SplObjectStorage();
$this->vars = $vars;
$this->values = array();
}
public function all()
{
return $this->assets;
}
public function add(AssetInterface $asset)
{
$this->assets[] = $asset;
}
public function removeLeaf(AssetInterface $needle, $graceful = false)
{
foreach ($this->assets as $i => $asset) {
$clone = isset($this->clones[$asset]) ? $this->clones[$asset] : null;
if (in_array($needle, array($asset, $clone), true)) {
unset($this->clones[$asset], $this->assets[$i]);
return true;
}
if ($asset instanceof AssetCollectionInterface && $asset->removeLeaf($needle, true)) {
return true;
}
}
if ($graceful) {
return false;
}
throw new \InvalidArgumentException('Leaf not found.');
}
public function replaceLeaf(AssetInterface $needle, AssetInterface $replacement, $graceful = false)
{
foreach ($this->assets as $i => $asset) {
$clone = isset($this->clones[$asset]) ? $this->clones[$asset] : null;
if (in_array($needle, array($asset, $clone), true)) {
unset($this->clones[$asset]);
$this->assets[$i] = $replacement;
return true;
}
if ($asset instanceof AssetCollectionInterface && $asset->replaceLeaf($needle, $replacement, true)) {
return true;
}
}
if ($graceful) {
return false;
}
throw new \InvalidArgumentException('Leaf not found.');
}
public function ensureFilter(FilterInterface $filter)
{
$this->filters->ensure($filter);
}
public function getFilters()
{
return $this->filters->all();
}
public function clearFilters()
{
$this->filters->clear();
}
public function load(FilterInterface $additionalFilter = null)
{
// loop through leaves and load each asset
$parts = array();
foreach ($this as $asset) {
$asset->load($additionalFilter);
$parts[] = $asset->getContent();
}
$this->content = implode("\n", $parts);
}
public function dump(FilterInterface $additionalFilter = null)
{
// loop through leaves and dump each asset
$parts = array();
foreach ($this as $asset) {
$parts[] = $asset->dump($additionalFilter);
}
return implode("\n", $parts);
}
public function getContent()
{
return $this->content;
}
public function setContent($content)
{
$this->content = $content;
}
public function getSourceRoot()
{
return $this->sourceRoot;
}
public function getSourcePath()
{
}
public function getTargetPath()
{
return $this->targetPath;
}
public function setTargetPath($targetPath)
{
$this->targetPath = $targetPath;
}
/**
* Returns the highest last-modified value of all assets in the current collection.
*
* @return integer|null A UNIX timestamp
*/
public function getLastModified()
{
if (!count($this->assets)) {
return;
}
$mtime = 0;
foreach ($this as $asset) {
$assetMtime = $asset->getLastModified();
if ($assetMtime > $mtime) {
$mtime = $assetMtime;
}
}
return $mtime;
}
/**
* Returns an iterator for looping recursively over unique leaves.
*/
public function getIterator()
{
return new \RecursiveIteratorIterator(new AssetCollectionFilterIterator(new AssetCollectionIterator($this, $this->clones)));
}
public function getVars()
{
return $this->vars;
}
public function setValues(array $values)
{
$this->values = $values;
foreach ($this as $asset) {
$asset->setValues(array_intersect_key($values, array_flip($asset->getVars())));
}
}
public function getValues()
{
return $this->values;
}
}
src/Assetic/Asset/HttpAsset.php 0000666 00000004624 13436754447 0012470 0 ustar 00
*/
class HttpAsset extends BaseAsset
{
private $sourceUrl;
private $ignoreErrors;
/**
* Constructor.
*
* @param string $sourceUrl The source URL
* @param array $filters An array of filters
* @param Boolean $ignoreErrors
* @param array $vars
*
* @throws \InvalidArgumentException If the first argument is not an URL
*/
public function __construct($sourceUrl, $filters = array(), $ignoreErrors = false, array $vars = array())
{
if (0 === strpos($sourceUrl, '//')) {
$sourceUrl = 'http:'.$sourceUrl;
} elseif (false === strpos($sourceUrl, '://')) {
throw new \InvalidArgumentException(sprintf('"%s" is not a valid URL.', $sourceUrl));
}
$this->sourceUrl = $sourceUrl;
$this->ignoreErrors = $ignoreErrors;
list($scheme, $url) = explode('://', $sourceUrl, 2);
list($host, $path) = explode('/', $url, 2);
parent::__construct($filters, $scheme.'://'.$host, $path, $vars);
}
public function load(FilterInterface $additionalFilter = null)
{
if (false === $content = @file_get_contents(PathUtils::resolvePath(
$this->sourceUrl, $this->getVars(), $this->getValues()))
) {
if ($this->ignoreErrors) {
return;
}
throw new \RuntimeException(sprintf('Unable to load asset from URL "%s"', $this->sourceUrl));
}
$this->doLoad($content, $additionalFilter);
}
public function getLastModified()
{
if (false !== @file_get_contents($this->sourceUrl, false, stream_context_create(array('http' => array('method' => 'HEAD'))))) {
foreach ($http_response_header as $header) {
if (0 === stripos($header, 'Last-Modified: ')) {
list(, $mtime) = explode(':', $header, 2);
return strtotime(trim($mtime));
}
}
}
}
}
src/Assetic/Asset/AssetCache.php 0000666 00000010154 13436754447 0012547 0 ustar 00
*/
class AssetCache implements AssetInterface
{
private $asset;
private $cache;
public function __construct(AssetInterface $asset, CacheInterface $cache)
{
$this->asset = $asset;
$this->cache = $cache;
}
public function ensureFilter(FilterInterface $filter)
{
$this->asset->ensureFilter($filter);
}
public function getFilters()
{
return $this->asset->getFilters();
}
public function clearFilters()
{
$this->asset->clearFilters();
}
public function load(FilterInterface $additionalFilter = null)
{
$cacheKey = self::getCacheKey($this->asset, $additionalFilter, 'load');
if ($this->cache->has($cacheKey)) {
$this->asset->setContent($this->cache->get($cacheKey));
return;
}
$this->asset->load($additionalFilter);
$this->cache->set($cacheKey, $this->asset->getContent());
}
public function dump(FilterInterface $additionalFilter = null)
{
$cacheKey = self::getCacheKey($this->asset, $additionalFilter, 'dump');
if ($this->cache->has($cacheKey)) {
return $this->cache->get($cacheKey);
}
$content = $this->asset->dump($additionalFilter);
$this->cache->set($cacheKey, $content);
return $content;
}
public function getContent()
{
return $this->asset->getContent();
}
public function setContent($content)
{
$this->asset->setContent($content);
}
public function getSourceRoot()
{
return $this->asset->getSourceRoot();
}
public function getSourcePath()
{
return $this->asset->getSourcePath();
}
public function getTargetPath()
{
return $this->asset->getTargetPath();
}
public function setTargetPath($targetPath)
{
$this->asset->setTargetPath($targetPath);
}
public function getLastModified()
{
return $this->asset->getLastModified();
}
public function getVars()
{
return $this->asset->getVars();
}
public function setValues(array $values)
{
$this->asset->setValues($values);
}
public function getValues()
{
return $this->asset->getValues();
}
/**
* Returns a cache key for the current asset.
*
* The key is composed of everything but an asset's content:
*
* * source root
* * source path
* * target url
* * last modified
* * filters
*
* @param AssetInterface $asset The asset
* @param FilterInterface $additionalFilter Any additional filter being applied
* @param string $salt Salt for the key
*
* @return string A key for identifying the current asset
*/
private static function getCacheKey(AssetInterface $asset, FilterInterface $additionalFilter = null, $salt = '')
{
if ($additionalFilter) {
$asset = clone $asset;
$asset->ensureFilter($additionalFilter);
}
$cacheKey = $asset->getSourceRoot();
$cacheKey .= $asset->getSourcePath();
$cacheKey .= $asset->getTargetPath();
$cacheKey .= $asset->getLastModified();
foreach ($asset->getFilters() as $filter) {
if ($filter instanceof HashableInterface) {
$cacheKey .= $filter->hash();
} else {
$cacheKey .= serialize($filter);
}
}
if ($values = $asset->getValues()) {
asort($values);
$cacheKey .= serialize($values);
}
return md5($cacheKey.$salt);
}
}
src/Assetic/Asset/GlobAsset.php 0000666 00000005137 13436754447 0012434 0 ustar 00
*/
class GlobAsset extends AssetCollection
{
private $globs;
private $initialized;
/**
* Constructor.
*
* @param string|array $globs A single glob path or array of paths
* @param array $filters An array of filters
* @param string $root The root directory
* @param array $vars
*/
public function __construct($globs, $filters = array(), $root = null, array $vars = array())
{
$this->globs = (array) $globs;
$this->initialized = false;
parent::__construct(array(), $filters, $root, $vars);
}
public function all()
{
if (!$this->initialized) {
$this->initialize();
}
return parent::all();
}
public function load(FilterInterface $additionalFilter = null)
{
if (!$this->initialized) {
$this->initialize();
}
parent::load($additionalFilter);
}
public function dump(FilterInterface $additionalFilter = null)
{
if (!$this->initialized) {
$this->initialize();
}
return parent::dump($additionalFilter);
}
public function getLastModified()
{
if (!$this->initialized) {
$this->initialize();
}
return parent::getLastModified();
}
public function getIterator()
{
if (!$this->initialized) {
$this->initialize();
}
return parent::getIterator();
}
public function setValues(array $values)
{
parent::setValues($values);
$this->initialized = false;
}
/**
* Initializes the collection based on the glob(s) passed in.
*/
private function initialize()
{
foreach ($this->globs as $glob) {
$glob = PathUtils::resolvePath($glob, $this->getVars(), $this->getValues());
if (false !== $paths = glob($glob)) {
foreach ($paths as $path) {
if (is_file($path)) {
$this->add(new FileAsset($path, array(), $this->getSourceRoot()));
}
}
}
}
$this->initialized = true;
}
}
src/Assetic/Asset/FileAsset.php 0000666 00000004520 13436754447 0012423 0 ustar 00
*/
class FileAsset extends BaseAsset
{
private $source;
/**
* Constructor.
*
* @param string $source An absolute path
* @param array $filters An array of filters
* @param string $sourceRoot The source asset root directory
* @param string $sourcePath The source asset path
* @param array $vars
*
* @throws \InvalidArgumentException If the supplied root doesn't match the source when guessing the path
*/
public function __construct($source, $filters = array(), $sourceRoot = null, $sourcePath = null, array $vars = array())
{
if (null === $sourceRoot) {
$sourceRoot = dirname($source);
if (null === $sourcePath) {
$sourcePath = basename($source);
}
} elseif (null === $sourcePath) {
if (0 !== strpos($source, $sourceRoot)) {
throw new \InvalidArgumentException(sprintf('The source "%s" is not in the root directory "%s"', $source, $sourceRoot));
}
$sourcePath = substr($source, strlen($sourceRoot) + 1);
}
$this->source = $source;
parent::__construct($filters, $sourceRoot, $sourcePath, $vars);
}
public function load(FilterInterface $additionalFilter = null)
{
$source = PathUtils::resolvePath($this->source, $this->getVars(), $this->getValues());
if (!is_file($source)) {
throw new \RuntimeException(sprintf('The source file "%s" does not exist.', $source));
}
$this->doLoad(file_get_contents($source), $additionalFilter);
}
public function getLastModified()
{
$source = PathUtils::resolvePath($this->source, $this->getVars(), $this->getValues());
if (!is_file($source)) {
throw new \RuntimeException(sprintf('The source file "%s" does not exist.', $source));
}
return filemtime($source);
}
}
src/Assetic/Asset/Iterator/AssetCollectionFilterIterator.php 0000666 00000004477 13436754447 0020323 0 ustar 00
*/
class AssetCollectionFilterIterator extends \RecursiveFilterIterator
{
private $visited;
private $sources;
/**
* Constructor.
*
* @param AssetCollectionIterator $iterator The inner iterator
* @param array $visited An array of visited asset objects
* @param array $sources An array of visited source strings
*/
public function __construct(AssetCollectionIterator $iterator, array $visited = array(), array $sources = array())
{
parent::__construct($iterator);
$this->visited = $visited;
$this->sources = $sources;
}
/**
* Determines whether the current asset is a duplicate.
*
* De-duplication is performed based on either strict equality or by
* matching sources.
*
* @return Boolean Returns true if we have not seen this asset yet
*/
public function accept()
{
$asset = $this->getInnerIterator()->current(true);
$duplicate = false;
// check strict equality
if (in_array($asset, $this->visited, true)) {
$duplicate = true;
} else {
$this->visited[] = $asset;
}
// check source
$sourceRoot = $asset->getSourceRoot();
$sourcePath = $asset->getSourcePath();
if ($sourceRoot && $sourcePath) {
$source = $sourceRoot.'/'.$sourcePath;
if (in_array($source, $this->sources)) {
$duplicate = true;
} else {
$this->sources[] = $source;
}
}
return !$duplicate;
}
/**
* Passes visited objects and source URLs to the child iterator.
*/
public function getChildren()
{
return new self($this->getInnerIterator()->getChildren(), $this->visited, $this->sources);
}
}
src/Assetic/Asset/Iterator/AssetCollectionIterator.php 0000666 00000005261 13436754447 0017145 0 ustar 00
*/
class AssetCollectionIterator implements \RecursiveIterator
{
private $assets;
private $filters;
private $output;
private $clones;
public function __construct(AssetCollectionInterface $coll, \SplObjectStorage $clones)
{
$this->assets = $coll->all();
$this->filters = $coll->getFilters();
$this->output = $coll->getTargetPath();
$this->clones = $clones;
if (false === $pos = strrpos($this->output, '.')) {
$this->output .= '_*';
} else {
$this->output = substr($this->output, 0, $pos).'_*'.substr($this->output, $pos);
}
}
/**
* Returns a copy of the current asset with filters and a target URL applied.
*
* @param Boolean $raw Returns the unmodified asset if true
* @return \Assetic\Asset\AssetInterface
*/
public function current($raw = false)
{
$asset = current($this->assets);
if ($raw) {
return $asset;
}
// clone once
if (!isset($this->clones[$asset])) {
$clone = $this->clones[$asset] = clone $asset;
// generate a target path based on asset name
$name = sprintf('%s_%d', pathinfo($asset->getSourcePath(), PATHINFO_FILENAME) ?: 'part', $this->key() + 1);
$clone->setTargetPath(str_replace('*', $name, $this->output));
} else {
$clone = $this->clones[$asset];
}
// cascade filters
foreach ($this->filters as $filter) {
$clone->ensureFilter($filter);
}
return $clone;
}
public function key()
{
return key($this->assets);
}
public function next()
{
return next($this->assets);
}
public function rewind()
{
return reset($this->assets);
}
public function valid()
{
return false !== current($this->assets);
}
public function hasChildren()
{
return current($this->assets) instanceof AssetCollectionInterface;
}
/**
* @uses current()
*/
public function getChildren()
{
return new self($this->current(), $this->clones);
}
}
src/Assetic/Asset/BaseAsset.php 0000666 00000010040 13436754447 0012410 0 ustar 00
*/
abstract class BaseAsset implements AssetInterface
{
private $filters;
private $sourceRoot;
private $sourcePath;
private $targetPath;
private $content;
private $loaded;
private $vars;
private $values;
/**
* Constructor.
*
* @param array $filters Filters for the asset
* @param string $sourceRoot The root directory
* @param string $sourcePath The asset path
* @param array $vars
*/
public function __construct($filters = array(), $sourceRoot = null, $sourcePath = null, array $vars = array())
{
$this->filters = new FilterCollection($filters);
$this->sourceRoot = $sourceRoot;
$this->sourcePath = $sourcePath;
$this->vars = $vars;
$this->values = array();
$this->loaded = false;
}
public function __clone()
{
$this->filters = clone $this->filters;
}
public function ensureFilter(FilterInterface $filter)
{
$this->filters->ensure($filter);
}
public function getFilters()
{
return $this->filters->all();
}
public function clearFilters()
{
$this->filters->clear();
}
/**
* Encapsulates asset loading logic.
*
* @param string $content The asset content
* @param FilterInterface $additionalFilter An additional filter
*/
protected function doLoad($content, FilterInterface $additionalFilter = null)
{
$filter = clone $this->filters;
if ($additionalFilter) {
$filter->ensure($additionalFilter);
}
$asset = clone $this;
$asset->setContent($content);
$filter->filterLoad($asset);
$this->content = $asset->getContent();
$this->loaded = true;
}
public function dump(FilterInterface $additionalFilter = null)
{
if (!$this->loaded) {
$this->load();
}
$filter = clone $this->filters;
if ($additionalFilter) {
$filter->ensure($additionalFilter);
}
$asset = clone $this;
$filter->filterDump($asset);
return $asset->getContent();
}
public function getContent()
{
return $this->content;
}
public function setContent($content)
{
$this->content = $content;
}
public function getSourceRoot()
{
return $this->sourceRoot;
}
public function getSourcePath()
{
return $this->sourcePath;
}
public function getTargetPath()
{
return $this->targetPath;
}
public function setTargetPath($targetPath)
{
if ($this->vars) {
foreach ($this->vars as $var) {
if (false === strpos($targetPath, $var)) {
throw new \RuntimeException(sprintf('The asset target path "%s" must contain the variable "{%s}".', $targetPath, $var));
}
}
}
$this->targetPath = $targetPath;
}
public function getVars()
{
return $this->vars;
}
public function setValues(array $values)
{
foreach ($values as $var => $v) {
if (!in_array($var, $this->vars, true)) {
throw new \InvalidArgumentException(sprintf('The asset with source path "%s" has no variable named "%s".', $this->sourcePath, $var));
}
}
$this->values = $values;
$this->loaded = false;
}
public function getValues()
{
return $this->values;
}
}
src/Assetic/Asset/StringAsset.php 0000666 00000002452 13436754447 0013014 0 ustar 00
*/
class StringAsset extends BaseAsset
{
private $content;
private $lastModified;
/**
* Constructor.
*
* @param string $content The content of the asset
* @param array $filters Filters for the asset
* @param string $sourceRoot The source asset root directory
* @param string $sourcePath The source asset path
*/
public function __construct($content, $filters = array(), $sourceRoot = null, $sourcePath = null)
{
$this->content = $content;
parent::__construct($filters, $sourceRoot, $sourcePath);
}
public function load(FilterInterface $additionalFilter = null)
{
$this->doLoad($this->content, $additionalFilter);
}
public function setLastModified($lastModified)
{
$this->lastModified = $lastModified;
}
public function getLastModified()
{
return $this->lastModified;
}
}
src/Assetic/Asset/AssetReference.php 0000666 00000005431 13436754447 0013444 0 ustar 00
*/
class AssetReference implements AssetInterface
{
private $am;
private $name;
private $filters = array();
public function __construct(AssetManager $am, $name)
{
$this->am = $am;
$this->name = $name;
}
public function ensureFilter(FilterInterface $filter)
{
$this->filters[] = $filter;
}
public function getFilters()
{
$this->flushFilters();
return $this->callAsset(__FUNCTION__);
}
public function clearFilters()
{
$this->filters = array();
$this->callAsset(__FUNCTION__);
}
public function load(FilterInterface $additionalFilter = null)
{
$this->flushFilters();
return $this->callAsset(__FUNCTION__, array($additionalFilter));
}
public function dump(FilterInterface $additionalFilter = null)
{
$this->flushFilters();
return $this->callAsset(__FUNCTION__, array($additionalFilter));
}
public function getContent()
{
return $this->callAsset(__FUNCTION__);
}
public function setContent($content)
{
$this->callAsset(__FUNCTION__, array($content));
}
public function getSourceRoot()
{
return $this->callAsset(__FUNCTION__);
}
public function getSourcePath()
{
return $this->callAsset(__FUNCTION__);
}
public function getTargetPath()
{
return $this->callAsset(__FUNCTION__);
}
public function setTargetPath($targetPath)
{
$this->callAsset(__FUNCTION__, array($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__, array($values));
}
// private
private function callAsset($method, $arguments = array())
{
$asset = $this->am->get($this->name);
return call_user_func_array(array($asset, $method), $arguments);
}
private function flushFilters()
{
$asset = $this->am->get($this->name);
while ($filter = array_shift($this->filters)) {
$asset->ensureFilter($filter);
}
}
}
src/Assetic/Factory/Resource/FileResource.php 0000666 00000001725 13436754447 0015256 0 ustar 00
*/
class FileResource implements ResourceInterface
{
private $path;
/**
* Constructor.
*
* @param string $path The path to a file
*/
public function __construct($path)
{
$this->path = $path;
}
public function isFresh($timestamp)
{
return file_exists($this->path) && filemtime($this->path) <= $timestamp;
}
public function getContent()
{
return file_exists($this->path) ? file_get_contents($this->path) : '';
}
public function __toString()
{
return $this->path;
}
}
src/Assetic/Factory/Resource/DirectoryResource.php 0000666 00000006171 13436754447 0016343 0 ustar 00
*/
class DirectoryResource implements IteratorResourceInterface
{
private $path;
private $pattern;
/**
* Constructor.
*
* @param string $path A directory path
* @param string $pattern A filename pattern
*/
public function __construct($path, $pattern = null)
{
if (DIRECTORY_SEPARATOR != substr($path, -1)) {
$path .= DIRECTORY_SEPARATOR;
}
$this->path = $path;
$this->pattern = $pattern;
}
public function isFresh($timestamp)
{
if (!is_dir($this->path) || filemtime($this->path) > $timestamp) {
return false;
}
foreach ($this as $resource) {
if (!$resource->isFresh($timestamp)) {
return false;
}
}
return true;
}
/**
* Returns the combined content of all inner resources.
*/
public function getContent()
{
$content = array();
foreach ($this as $resource) {
$content[] = $resource->getContent();
}
return implode("\n", $content);
}
public function __toString()
{
return $this->path;
}
public function getIterator()
{
return is_dir($this->path)
? new DirectoryResourceIterator($this->getInnerIterator())
: new \EmptyIterator();
}
protected function getInnerIterator()
{
return new DirectoryResourceFilterIterator(new \RecursiveDirectoryIterator($this->path, \RecursiveDirectoryIterator::FOLLOW_SYMLINKS), $this->pattern);
}
}
/**
* An iterator that converts file objects into file resources.
*
* @author Kris Wallsmith
* @access private
*/
class DirectoryResourceIterator extends \RecursiveIteratorIterator
{
public function current()
{
return new FileResource(parent::current()->getPathname());
}
}
/**
* Filters files by a basename pattern.
*
* @author Kris Wallsmith
* @access private
*/
class DirectoryResourceFilterIterator extends \RecursiveFilterIterator
{
protected $pattern;
public function __construct(\RecursiveDirectoryIterator $iterator, $pattern = null)
{
parent::__construct($iterator);
$this->pattern = $pattern;
}
public function accept()
{
$file = $this->current();
$name = $file->getBasename();
if ($file->isDir()) {
return '.' != $name[0];
}
return null === $this->pattern || 0 < preg_match($this->pattern, $name);
}
public function getChildren()
{
return new self(new \RecursiveDirectoryIterator($this->current()->getPathname(), \RecursiveDirectoryIterator::FOLLOW_SYMLINKS), $this->pattern);
}
}
src/Assetic/Factory/Resource/ResourceInterface.php 0000666 00000001752 13436754447 0016277 0 ustar 00
*/
interface ResourceInterface
{
/**
* Checks if a timestamp represents the latest resource.
*
* @param integer $timestamp A UNIX timestamp
*
* @return Boolean True if the timestamp is up to date
*/
public function isFresh($timestamp);
/**
* Returns the content of the resource.
*
* @return string The content
*/
public function getContent();
/**
* Returns a unique string for the current resource.
*
* @return string A unique string to identity the current resource
*/
public function __toString();
}
src/Assetic/Factory/Resource/CoalescingDirectoryResource.php 0000666 00000005246 13436754447 0020335 0 ustar 00
*/
class CoalescingDirectoryResource implements IteratorResourceInterface
{
private $directories;
public function __construct($directories)
{
$this->directories = array();
foreach ($directories as $directory) {
$this->addDirectory($directory);
}
}
public function addDirectory(IteratorResourceInterface $directory)
{
$this->directories[] = $directory;
}
public function isFresh($timestamp)
{
foreach ($this->getFileResources() as $file) {
if (!$file->isFresh($timestamp)) {
return false;
}
}
return true;
}
public function getContent()
{
$parts = array();
foreach ($this->getFileResources() as $file) {
$parts[] = $file->getContent();
}
return implode("\n", $parts);
}
/**
* Returns a string to uniquely identify the current resource.
*
* @return string An identifying string
*/
public function __toString()
{
$parts = array();
foreach ($this->directories as $directory) {
$parts[] = (string) $directory;
}
return implode(',', $parts);
}
public function getIterator()
{
return new \ArrayIterator($this->getFileResources());
}
/**
* Returns the relative version of a filename.
*
* @param ResourceInterface $file The file
* @param ResourceInterface $directory The directory
*
* @return string The name to compare with files from other directories
*/
protected function getRelativeName(ResourceInterface $file, ResourceInterface $directory)
{
return substr((string) $file, strlen((string) $directory));
}
/**
* Performs the coalesce.
*
* @return array An array of file resources
*/
private function getFileResources()
{
$paths = array();
foreach ($this->directories as $directory) {
foreach ($directory as $file) {
$relative = $this->getRelativeName($file, $directory);
if (!isset($paths[$relative])) {
$paths[$relative] = $file;
}
}
}
return array_values($paths);
}
}
src/Assetic/Factory/Resource/IteratorResourceInterface.php 0000666 00000000755 13436754447 0020013 0 ustar 00
*/
interface IteratorResourceInterface extends ResourceInterface, \IteratorAggregate
{
}
src/Assetic/Factory/LazyAssetManager.php 0000666 00000011775 13436754447 0014320 0 ustar 00
*/
class LazyAssetManager extends AssetManager
{
private $factory;
private $loaders;
private $resources;
private $formulae;
private $loaded;
private $loading;
/**
* Constructor.
*
* @param AssetFactory $factory The asset factory
* @param array $loaders An array of loaders indexed by alias
*/
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);
}
}
/**
* Adds a loader to the asset manager.
*
* @param string $alias An alias for the loader
* @param FormulaLoaderInterface $loader A loader
*/
public function setLoader($alias, FormulaLoaderInterface $loader)
{
$this->loaders[$alias] = $loader;
$this->loaded = false;
}
/**
* Adds a resource to the asset manager.
*
* @param ResourceInterface $resource A resource
* @param string $loader The loader alias for this resource
*/
public function addResource(ResourceInterface $resource, $loader)
{
$this->resources[$loader][] = $resource;
$this->loaded = false;
}
/**
* Returns an array of resources.
*
* @return array An array of resources
*/
public function getResources()
{
$resources = array();
foreach ($this->resources as $r) {
$resources = array_merge($resources, $r);
}
return $resources;
}
/**
* Checks for an asset formula.
*
* @param string $name An asset name
*
* @return Boolean If there is a formula
*/
public function hasFormula($name)
{
if (!$this->loaded) {
$this->load();
}
return isset($this->formulae[$name]);
}
/**
* Returns an asset's formula.
*
* @param string $name An asset name
*
* @return array The formula
*
* @throws \InvalidArgumentException If there is no formula by that 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];
}
/**
* Sets a formula on the asset manager.
*
* @param string $name An asset name
* @param array $formula A formula
*/
public function setFormula($name, array $formula)
{
$this->formulae[$name] = $formula;
}
/**
* Loads formulae from resources.
*
* @throws \LogicException If a resource has been added to an invalid loader
*/
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();
}
}
src/Assetic/Factory/Worker/EnsureFilterWorker.php 0000666 00000003242 13436754447 0016146 0 ustar 00
* @todo A better asset-matcher mechanism
*/
class EnsureFilterWorker implements WorkerInterface
{
const CHECK_SOURCE = 1;
const CHECK_TARGET = 2;
private $pattern;
private $filter;
private $flags;
/**
* Constructor.
*
* @param string $pattern A regex for checking the asset's target URL
* @param FilterInterface $filter A filter to apply if the regex matches
* @param integer $flags Flags for what to check
*/
public function __construct($pattern, FilterInterface $filter, $flags = null)
{
if (null === $flags) {
$flags = self::CHECK_SOURCE | self::CHECK_TARGET;
}
$this->pattern = $pattern;
$this->filter = $filter;
$this->flags = $flags;
}
public function process(AssetInterface $asset)
{
if (
(self::CHECK_SOURCE === (self::CHECK_SOURCE & $this->flags) && preg_match($this->pattern, $asset->getSourcePath()))
||
(self::CHECK_TARGET === (self::CHECK_TARGET & $this->flags) && preg_match($this->pattern, $asset->getTargetPath()))
) {
$asset->ensureFilter($this->filter);
}
}
}
src/Assetic/Factory/Worker/WorkerInterface.php 0000666 00000001316 13436754447 0015437 0 ustar 00
*/
interface WorkerInterface
{
/**
* Processes an asset.
*
* @param AssetInterface $asset An asset
*
* @return AssetInterface|null May optionally return a replacement asset
*/
public function process(AssetInterface $asset);
}
src/Assetic/Factory/Worker/CacheBustingWorker.php 0000666 00000003533 13436754447 0016101 0 ustar 00
*/
class CacheBustingWorker implements WorkerInterface
{
const STRATEGY_CONTENT = 1;
const STRATEGY_MODIFICATION = 2;
private $strategy;
public function __construct($strategy = self::STRATEGY_CONTENT)
{
$this->strategy = $strategy;
}
public function process(AssetInterface $asset)
{
$hash = hash_init('sha1');
switch($this->strategy) {
case self::STRATEGY_MODIFICATION:
hash_update($hash, $asset->getLastModified());
break;
case self::STRATEGY_CONTENT:
hash_update($hash, $asset->dump());
break;
}
foreach ($asset as $i => $leaf) {
if ($sourcePath = $leaf->getSourcePath()) {
hash_update($hash, $sourcePath);
} else {
hash_update($hash, $i);
}
}
$hash = substr(hash_final($hash), 0, 7);
$url = $asset->getTargetPath();
$oldExt = pathinfo($url, PATHINFO_EXTENSION);
$newExt = '-'.$hash.'.'.$oldExt;
if (!$oldExt || 0 < preg_match('/'.preg_quote($newExt, '/').'$/', $url)) {
return;
}
$asset->setTargetPath(substr($url, 0, (strlen($oldExt) + 1) * -1).$newExt);
}
public function getStrategy()
{
return $this->strategy;
}
public function setStrategy($strategy)
{
$this->strategy = $strategy;
return $this;
}
}
src/Assetic/Factory/Loader/BasePhpFormulaLoader.php 0000666 00000011540 13436754447 0016301 0 ustar 00
*/
abstract class BasePhpFormulaLoader implements FormulaLoaderInterface
{
protected $factory;
protected $prototypes;
public function __construct(AssetFactory $factory)
{
$this->factory = $factory;
$this->prototypes = array();
foreach ($this->registerPrototypes() as $prototype => $options) {
$this->addPrototype($prototype, $options);
}
}
public function addPrototype($prototype, array $options = array())
{
$tokens = token_get_all('prototypes[$prototype] = array($tokens, $options);
}
public function load(ResourceInterface $resource)
{
if (!$nbProtos = count($this->prototypes)) {
throw new \LogicException('There are no prototypes registered.');
}
$buffers = array_fill(0, $nbProtos, '');
$bufferLevels = array_fill(0, $nbProtos, 0);
$buffersInWildcard = array();
$tokens = token_get_all($resource->getContent());
$calls = array();
while ($token = array_shift($tokens)) {
$current = self::tokenToString($token);
// loop through each prototype (by reference)
foreach (array_keys($this->prototypes) as $i) {
$prototype =& $this->prototypes[$i][0];
$options = $this->prototypes[$i][1];
$buffer =& $buffers[$i];
$level =& $bufferLevels[$i];
if (isset($buffersInWildcard[$i])) {
switch ($current) {
case '(': ++$level; break;
case ')': --$level; break;
}
$buffer .= $current;
if (!$level) {
$calls[] = array($buffer.';', $options);
$buffer = '';
unset($buffersInWildcard[$i]);
}
} elseif ($current == self::tokenToString(current($prototype))) {
$buffer .= $current;
if ('*' == self::tokenToString(next($prototype))) {
$buffersInWildcard[$i] = true;
++$level;
}
} else {
reset($prototype);
unset($buffersInWildcard[$i]);
$buffer = '';
}
}
}
$formulae = array();
foreach ($calls as $call) {
$formulae += call_user_func_array(array($this, 'processCall'), $call);
}
return $formulae;
}
private function processCall($call, array $protoOptions = array())
{
$tmp = tempnam(sys_get_temp_dir(), 'assetic');
file_put_contents($tmp, implode("\n", array(
'registerSetupCode(),
$call,
'echo serialize($_call);',
)));
$args = unserialize(shell_exec('php '.escapeshellarg($tmp)));
unlink($tmp);
$inputs = isset($args[0]) ? self::argumentToArray($args[0]) : array();
$filters = isset($args[1]) ? self::argumentToArray($args[1]) : array();
$options = isset($args[2]) ? $args[2] : array();
if (!isset($options['debug'])) {
$options['debug'] = $this->factory->isDebug();
}
if (!is_array($options)) {
throw new \RuntimeException('The third argument must be omitted, null or an array.');
}
// apply the prototype options
$options += $protoOptions;
if (!isset($options['name'])) {
$options['name'] = $this->factory->generateAssetName($inputs, $filters, $options);
}
return array($options['name'] => array($inputs, $filters, $options));
}
/**
* Returns an array of prototypical calls and options.
*
* @return array Prototypes and options
*/
abstract protected function registerPrototypes();
/**
* Returns setup code for the reflection scriptlet.
*
* @return string Some PHP setup code
*/
abstract protected function registerSetupCode();
protected static function tokenToString($token)
{
return is_array($token) ? $token[1] : $token;
}
protected static function argumentToArray($argument)
{
return is_array($argument) ? $argument : array_filter(array_map('trim', explode(',', $argument)));
}
}
src/Assetic/Factory/Loader/CachedFormulaLoader.php 0000666 00000003716 13436754447 0016134 0 ustar 00
*/
class CachedFormulaLoader implements FormulaLoaderInterface
{
private $loader;
private $configCache;
private $debug;
/**
* Constructor.
*
* When the loader is in debug mode it will ensure the cached formulae
* are fresh before returning them.
*
* @param FormulaLoaderInterface $loader A formula loader
* @param ConfigCache $configCache A config cache
* @param Boolean $debug The debug mode
*/
public function __construct(FormulaLoaderInterface $loader, ConfigCache $configCache, $debug = false)
{
$this->loader = $loader;
$this->configCache = $configCache;
$this->debug = $debug;
}
public function load(ResourceInterface $resources)
{
if (!$resources instanceof IteratorResourceInterface) {
$resources = array($resources);
}
$formulae = array();
foreach ($resources as $resource) {
$id = (string) $resource;
if (!$this->configCache->has($id) || ($this->debug && !$resource->isFresh($this->configCache->getTimestamp($id)))) {
$formulae += $this->loader->load($resource);
$this->configCache->set($id, $formulae);
} else {
$formulae += $this->configCache->get($id);
}
}
return $formulae;
}
}
src/Assetic/Factory/Loader/FormulaLoaderInterface.php 0000666 00000001456 13436754447 0016664 0 ustar 00
*/
interface FormulaLoaderInterface
{
/**
* Loads formulae from a resource.
*
* Formulae should be loaded the same regardless of the current debug
* mode. Debug considerations should happen downstream.
*
* @param ResourceInterface $resource A resource
*
* @return array An array of formulae
*/
public function load(ResourceInterface $resource);
}
src/Assetic/Factory/Loader/FunctionCallsFormulaLoader.php 0000666 00000002103 13436754447 0017516 0 ustar 00
*/
class FunctionCallsFormulaLoader extends BasePhpFormulaLoader
{
protected function registerPrototypes()
{
return array(
'assetic_javascripts(*)' => array('output' => 'js/*.js'),
'assetic_stylesheets(*)' => array('output' => 'css/*.css'),
'assetic_image(*)' => array('output' => 'images/*'),
);
}
protected function registerSetupCode()
{
return <<<'EOF'
function assetic_javascripts()
{
global $_call;
$_call = func_get_args();
}
function assetic_stylesheets()
{
global $_call;
$_call = func_get_args();
}
function assetic_image()
{
global $_call;
$_call = func_get_args();
}
EOF;
}
}
src/Assetic/Factory/AssetFactory.php 0000666 00000025701 13436754447 0013507 0 ustar 00
*/
class AssetFactory
{
private $root;
private $debug;
private $output;
private $workers;
private $am;
private $fm;
/**
* Constructor.
*
* @param string $root The default root directory
* @param Boolean $debug Filters prefixed with a "?" will be omitted in debug mode
*/
public function __construct($root, $debug = false)
{
$this->root = rtrim($root, '/');
$this->debug = $debug;
$this->output = 'assetic/*';
$this->workers = array();
}
/**
* Sets debug mode for the current factory.
*
* @param Boolean $debug Debug mode
*/
public function setDebug($debug)
{
$this->debug = $debug;
}
/**
* Checks if the factory is in debug mode.
*
* @return Boolean Debug mode
*/
public function isDebug()
{
return $this->debug;
}
/**
* Sets the default output string.
*
* @param string $output The default output string
*/
public function setDefaultOutput($output)
{
$this->output = $output;
}
/**
* Adds a factory worker.
*
* @param WorkerInterface $worker A worker
*/
public function addWorker(WorkerInterface $worker)
{
$this->workers[] = $worker;
}
/**
* Returns the current asset manager.
*
* @return AssetManager|null The asset manager
*/
public function getAssetManager()
{
return $this->am;
}
/**
* Sets the asset manager to use when creating asset references.
*
* @param AssetManager $am The asset manager
*/
public function setAssetManager(AssetManager $am)
{
$this->am = $am;
}
/**
* Returns the current filter manager.
*
* @return FilterManager|null The filter manager
*/
public function getFilterManager()
{
return $this->fm;
}
/**
* Sets the filter manager to use when adding filters.
*
* @param FilterManager $fm The filter manager
*/
public function setFilterManager(FilterManager $fm)
{
$this->fm = $fm;
}
/**
* Creates a new asset.
*
* Prefixing a filter name with a question mark will cause it to be
* omitted when the factory is in debug mode.
*
* Available options:
*
* * output: An output string
* * name: An asset name for interpolation in output patterns
* * debug: Forces debug mode on or off for this asset
* * root: An array or string of more root directories
*
* @param array|string $inputs An array of input strings
* @param array|string $filters An array of filter names
* @param array $options An array of options
*
* @return AssetCollection An asset collection
*/
public function createAsset($inputs = array(), $filters = array(), array $options = array())
{
if (!is_array($inputs)) {
$inputs = array($inputs);
}
if (!is_array($filters)) {
$filters = array($filters);
}
if (!isset($options['output'])) {
$options['output'] = $this->output;
}
if (!isset($options['vars'])) {
$options['vars'] = array();
}
if (!isset($options['debug'])) {
$options['debug'] = $this->debug;
}
if (!isset($options['root'])) {
$options['root'] = array($this->root);
} else {
if (!is_array($options['root'])) {
$options['root'] = array($options['root']);
}
$options['root'][] = $this->root;
}
if (!isset($options['name'])) {
$options['name'] = $this->generateAssetName($inputs, $filters, $options);
}
$asset = $this->createAssetCollection(array(), $options);
$extensions = array();
// inner assets
foreach ($inputs as $input) {
if (is_array($input)) {
// nested formula
$asset->add(call_user_func_array(array($this, 'createAsset'), $input));
} else {
$asset->add($this->parseInput($input, $options));
$extensions[pathinfo($input, PATHINFO_EXTENSION)] = true;
}
}
// filters
foreach ($filters as $filter) {
if ('?' != $filter[0]) {
$asset->ensureFilter($this->getFilter($filter));
} elseif (!$options['debug']) {
$asset->ensureFilter($this->getFilter(substr($filter, 1)));
}
}
// append variables
if (!empty($options['vars'])) {
$toAdd = array();
foreach ($options['vars'] as $var) {
if (false !== strpos($options['output'], '{'.$var.'}')) {
continue;
}
$toAdd[] = '{'.$var.'}';
}
if ($toAdd) {
$options['output'] = str_replace('*', '*.'.implode('.', $toAdd), $options['output']);
}
}
// append consensus extension if missing
if (1 == count($extensions) && !pathinfo($options['output'], PATHINFO_EXTENSION) && $extension = key($extensions)) {
$options['output'] .= '.'.$extension;
}
// output --> target url
$asset->setTargetPath(str_replace('*', $options['name'], $options['output']));
// apply workers and return
return $this->applyWorkers($asset);
}
public function generateAssetName($inputs, $filters, $options = array())
{
foreach (array_diff(array_keys($options), array('output', 'debug', 'root')) as $key) {
unset($options[$key]);
}
ksort($options);
return substr(sha1(serialize($inputs).serialize($filters).serialize($options)), 0, 7);
}
/**
* Parses an input string string into an asset.
*
* The input string can be one of the following:
*
* * A reference: If the string starts with an "at" sign it will be interpreted as a reference to an asset in the asset manager
* * An absolute URL: If the string contains "://" or starts with "//" it will be interpreted as an HTTP asset
* * A glob: If the string contains a "*" it will be interpreted as a glob
* * A path: Otherwise the string is interpreted as a filesystem path
*
* Both globs and paths will be absolutized using the current root directory.
*
* @param string $input An input string
* @param array $options An array of options
*
* @return AssetInterface An asset
*/
protected function parseInput($input, array $options = array())
{
if ('@' == $input[0]) {
return $this->createAssetReference(substr($input, 1));
}
if (false !== strpos($input, '://') || 0 === strpos($input, '//')) {
return $this->createHttpAsset($input, $options['vars']);
}
if (self::isAbsolutePath($input)) {
if ($root = self::findRootDir($input, $options['root'])) {
$path = ltrim(substr($input, strlen($root)), '/');
} else {
$path = null;
}
} else {
$root = $this->root;
$path = $input;
$input = $this->root.'/'.$path;
}
if (false !== strpos($input, '*')) {
return $this->createGlobAsset($input, $root, $options['vars']);
}
return $this->createFileAsset($input, $root, $path, $options['vars']);
}
protected function createAssetCollection(array $assets = array(), array $options = array())
{
return new AssetCollection($assets, array(), null, isset($options['vars']) ? $options['vars'] : array());
}
protected function createAssetReference($name)
{
if (!$this->am) {
throw new \LogicException('There is no asset manager.');
}
return new AssetReference($this->am, $name);
}
protected function createHttpAsset($sourceUrl, $vars)
{
return new HttpAsset($sourceUrl, array(), false, $vars);
}
protected function createGlobAsset($glob, $root = null, $vars)
{
return new GlobAsset($glob, array(), $root, $vars);
}
protected function createFileAsset($source, $root = null, $path = null, $vars)
{
return new FileAsset($source, array(), $root, $path, $vars);
}
protected function getFilter($name)
{
if (!$this->fm) {
throw new \LogicException('There is no filter manager.');
}
return $this->fm->get($name);
}
/**
* Filters an asset collection through the factory workers.
*
* Each leaf asset will be processed first, followed by the asset
* collection itself.
*
* @param AssetCollectionInterface $asset An asset collection
*
* @return AssetCollectionInterface
*/
private function applyWorkers(AssetCollectionInterface $asset)
{
foreach ($asset as $leaf) {
foreach ($this->workers as $worker) {
$retval = $worker->process($leaf);
if ($retval instanceof AssetInterface && $leaf !== $retval) {
$asset->replaceLeaf($leaf, $retval);
}
}
}
foreach ($this->workers as $worker) {
$retval = $worker->process($asset);
if ($retval instanceof AssetInterface) {
$asset = $retval;
}
}
return $asset instanceof AssetCollectionInterface ? $asset : $this->createAssetCollection(array($asset));
}
private static function isAbsolutePath($path)
{
return '/' == $path[0] || '\\' == $path[0] || (3 < strlen($path) && ctype_alpha($path[0]) && $path[1] == ':' && ('\\' == $path[2] || '/' == $path[2]));
}
/**
* Loops through the root directories and returns the first match.
*
* @param string $path An absolute path
* @param array $roots An array of root directories
*
* @return string|null The matching root directory, if found
*/
private static function findRootDir($path, array $roots)
{
foreach ($roots as $root) {
if (0 === strpos($path, $root)) {
return $root;
}
}
}
}
src/Assetic/AssetManager.php 0000666 00000003555 13436754447 0012046 0 ustar 00
*/
class AssetManager
{
private $assets = array();
/**
* Gets an asset by name.
*
* @param string $name The asset name
*
* @return AssetInterface The asset
*
* @throws \InvalidArgumentException If there is no asset by that name
*/
public function get($name)
{
if (!isset($this->assets[$name])) {
throw new \InvalidArgumentException(sprintf('There is no "%s" asset.', $name));
}
return $this->assets[$name];
}
/**
* Checks if the current asset manager has a certain asset.
*
* @param string $name an asset name
*
* @return Boolean True if the asset has been set, false if not
*/
public function has($name)
{
return isset($this->assets[$name]);
}
/**
* Registers an asset to the current asset manager.
*
* @param string $name The asset name
* @param AssetInterface $asset The asset
*
* @throws \InvalidArgumentException If tthe asset name is invalid
*/
public function set($name, AssetInterface $asset)
{
if (!ctype_alnum(str_replace('_', '', $name))) {
throw new \InvalidArgumentException(sprintf('The name "%s" is invalid.', $name));
}
$this->assets[$name] = $asset;
}
/**
* Returns an array of asset names.
*
* @return array An array of asset names
*/
public function getNames()
{
return array_keys($this->assets);
}
}
src/Assetic/Exception/Exception.php 0000666 00000000574 13436754447 0013366 0 ustar 00
*/
interface Exception
{
}
src/Assetic/Exception/FilterException.php 0000666 00000003275 13436754447 0014535 0 ustar 00
*/
class FilterException extends \RuntimeException implements Exception
{
private $originalMessage;
private $input;
public static function fromProcess(Process $proc)
{
$message = sprintf("An error occurred while running:\n%s", $proc->getCommandLine());
$errorOutput = $proc->getErrorOutput();
if (!empty($errorOutput)) {
$message .= "\n\nError Output:\n".str_replace("\r", '', $errorOutput);
}
$output = $proc->getOutput();
if (!empty($output)) {
$message .= "\n\nOutput:\n".str_replace("\r", '', $output);
}
return new self($message);
}
public function __construct($message, $code = 0, \Exception $previous = null)
{
parent::__construct($message, $code, $previous);
$this->originalMessage = $message;
}
public function setInput($input)
{
$this->input = $input;
$this->updateMessage();
return $this;
}
public function getInput()
{
return $this->input;
}
private function updateMessage()
{
$message = $this->originalMessage;
if (!empty($this->input)) {
$message .= "\n\nInput:\n".$this->input;
}
$this->message = $message;
}
}
src/Assetic/ValueSupplierInterface.php 0000666 00000001111 13436754447 0014077 0 ustar 00
*/
interface ValueSupplierInterface
{
/**
* Returns a map of values.
*
* @return array
*/
public function getValues();
}
src/Assetic/Extension/Twig/AsseticFilterFunction.php 0000666 00000001231 13436754447 0016616 0 ustar 00 filter = $filter;
parent::__construct($options);
}
public function compile()
{
return sprintf('$this->env->getExtension(\'assetic\')->getFilterInvoker(\'%s\')->invoke', $this->filter);
}
}
src/Assetic/Extension/Twig/ValueContainer.php 0000666 00000003421 13436754447 0015271 0 ustar 00
*/
class ValueContainer implements \ArrayAccess, \IteratorAggregate, \Countable
{
private $values;
private $valueSupplier;
public function __construct(ValueSupplierInterface $valueSupplier)
{
$this->valueSupplier = $valueSupplier;
}
public function offsetExists($offset)
{
$this->initialize();
return array_key_exists($offset, $this->values);
}
public function offsetGet($offset)
{
$this->initialize();
if (!array_key_exists($offset, $this->values)) {
throw new \OutOfRangeException(sprintf('The variable "%s" does not exist.', $offset));
}
return $this->values[$offset];
}
public function offsetSet($offset, $value)
{
throw new \BadMethodCallException('The ValueContainer is read-only.');
}
public function offsetUnset($offset)
{
throw new \BadMethodCallException('The ValueContainer is read-only.');
}
public function getIterator()
{
$this->initialize();
return new \ArrayIterator($this->values);
}
public function count()
{
$this->initialize();
return count($this->values);
}
private function initialize()
{
if (null === $this->values) {
$this->values = $this->valueSupplier->getValues();
}
}
}
src/Assetic/Extension/Twig/AsseticNode.php 0000666 00000012012 13436754447 0014547 0 ustar 00 $body);
$attributes = array_replace(
array('debug' => null, 'combine' => null, 'var_name' => 'asset_url'),
$attributes,
array('asset' => $asset, 'inputs' => $inputs, 'filters' => $filters, 'name' => $name)
);
parent::__construct($nodes, $attributes, $lineno, $tag);
}
public function compile(\Twig_Compiler $compiler)
{
$compiler->addDebugInfo($this);
$combine = $this->getAttribute('combine');
$debug = $this->getAttribute('debug');
if (null === $combine && null !== $debug) {
$combine = !$debug;
}
if (null === $combine) {
$compiler
->write("if (isset(\$context['assetic']['debug']) && \$context['assetic']['debug']) {\n")
->indent()
;
$this->compileDebug($compiler);
$compiler
->outdent()
->write("} else {\n")
->indent()
;
$this->compileAsset($compiler, $this->getAttribute('asset'), $this->getAttribute('name'));
$compiler
->outdent()
->write("}\n")
;
} elseif ($combine) {
$this->compileAsset($compiler, $this->getAttribute('asset'), $this->getAttribute('name'));
} else {
$this->compileDebug($compiler);
}
$compiler
->write('unset($context[')
->repr($this->getAttribute('var_name'))
->raw("]);\n")
;
}
protected function compileDebug(\Twig_Compiler $compiler)
{
$i = 0;
foreach ($this->getAttribute('asset') as $leaf) {
$leafName = $this->getAttribute('name').'_'.$i++;
$this->compileAsset($compiler, $leaf, $leafName);
}
}
protected function compileAsset(\Twig_Compiler $compiler, AssetInterface $asset, $name)
{
if ($vars = $asset->getVars()) {
$compiler->write("// check variable conditions\n");
foreach ($vars as $var) {
$compiler
->write("if (!isset(\$context['assetic']['vars']['$var'])) {\n")
->indent()
->write("throw new \RuntimeException(sprintf('The asset \"".$name."\" expected variable \"".$var."\" to be set, but got only these vars: %s. Did you set-up a value supplier?', isset(\$context['assetic']['vars']) && \$context['assetic']['vars'] ? implode(', ', \$context['assetic']['vars']) : '# none #'));\n")
->outdent()
->write("}\n")
;
}
$compiler->raw("\n");
}
$compiler
->write("// asset \"$name\"\n")
->write('$context[')
->repr($this->getAttribute('var_name'))
->raw('] = ')
;
$this->compileAssetUrl($compiler, $asset, $name);
$compiler
->raw(";\n")
->subcompile($this->getNode('body'))
;
}
protected function compileAssetUrl(\Twig_Compiler $compiler, AssetInterface $asset, $name)
{
if (!$vars = $asset->getVars()) {
$compiler->repr($asset->getTargetPath());
return;
}
$compiler
->raw("strtr(")
->string($asset->getTargetPath())
->raw(", array(");
;
$first = true;
foreach ($vars as $var) {
if (!$first) {
$compiler->raw(", ");
}
$first = false;
$compiler
->string("{".$var."}")
->raw(" => \$context['assetic']['vars']['$var']")
;
}
$compiler
->raw("))")
;
}
}
src/Assetic/Extension/Twig/AsseticTokenParser.php 0000666 00000014306 13436754447 0016127 0 ustar 00 factory = $factory;
$this->tag = $tag;
$this->output = $output;
$this->single = $single;
$this->extensions = $extensions;
}
public function parse(\Twig_Token $token)
{
$inputs = array();
$filters = array();
$name = null;
$attributes = array(
'output' => $this->output,
'var_name' => 'asset_url',
'vars' => array(),
);
$stream = $this->parser->getStream();
while (!$stream->test(\Twig_Token::BLOCK_END_TYPE)) {
if ($stream->test(\Twig_Token::STRING_TYPE)) {
// '@jquery', 'js/src/core/*', 'js/src/extra.js'
$inputs[] = $stream->next()->getValue();
} elseif ($stream->test(\Twig_Token::NAME_TYPE, 'filter')) {
// filter='yui_js'
$stream->next();
$stream->expect(\Twig_Token::OPERATOR_TYPE, '=');
$filters = array_merge($filters, array_filter(array_map('trim', explode(',', $stream->expect(\Twig_Token::STRING_TYPE)->getValue()))));
} elseif ($stream->test(\Twig_Token::NAME_TYPE, 'output')) {
// output='js/packed/*.js' OR output='js/core.js'
$stream->next();
$stream->expect(\Twig_Token::OPERATOR_TYPE, '=');
$attributes['output'] = $stream->expect(\Twig_Token::STRING_TYPE)->getValue();
} elseif ($stream->test(\Twig_Token::NAME_TYPE, 'name')) {
// name='core_js'
$stream->next();
$stream->expect(\Twig_Token::OPERATOR_TYPE, '=');
$name = $stream->expect(\Twig_Token::STRING_TYPE)->getValue();
} elseif ($stream->test(\Twig_Token::NAME_TYPE, 'as')) {
// as='the_url'
$stream->next();
$stream->expect(\Twig_Token::OPERATOR_TYPE, '=');
$attributes['var_name'] = $stream->expect(\Twig_Token::STRING_TYPE)->getValue();
} elseif ($stream->test(\Twig_Token::NAME_TYPE, 'debug')) {
// debug=true
$stream->next();
$stream->expect(\Twig_Token::OPERATOR_TYPE, '=');
$attributes['debug'] = 'true' == $stream->expect(\Twig_Token::NAME_TYPE, array('true', 'false'))->getValue();
} elseif ($stream->test(\Twig_Token::NAME_TYPE, 'combine')) {
// combine=true
$stream->next();
$stream->expect(\Twig_Token::OPERATOR_TYPE, '=');
$attributes['combine'] = 'true' == $stream->expect(\Twig_Token::NAME_TYPE, array('true', 'false'))->getValue();
} elseif ($stream->test(\Twig_Token::NAME_TYPE, 'vars')) {
// vars=['locale','browser']
$stream->next();
$stream->expect(\Twig_Token::OPERATOR_TYPE, '=');
$stream->expect(\Twig_Token::PUNCTUATION_TYPE, '[');
while ($stream->test(\Twig_Token::STRING_TYPE)) {
$attributes['vars'][] = $stream->expect(\Twig_Token::STRING_TYPE)->getValue();
if (!$stream->test(\Twig_Token::PUNCTUATION_TYPE, ',')) {
break;
}
$stream->next();
}
$stream->expect(\Twig_Token::PUNCTUATION_TYPE, ']');
} elseif ($stream->test(\Twig_Token::NAME_TYPE, $this->extensions)) {
// an arbitrary configured attribute
$key = $stream->next()->getValue();
$stream->expect(\Twig_Token::OPERATOR_TYPE, '=');
$attributes[$key] = $stream->expect(\Twig_Token::STRING_TYPE)->getValue();
} else {
$token = $stream->getCurrent();
throw new \Twig_Error_Syntax(sprintf('Unexpected token "%s" of value "%s"', \Twig_Token::typeToEnglish($token->getType(), $token->getLine()), $token->getValue()), $token->getLine());
}
}
$stream->expect(\Twig_Token::BLOCK_END_TYPE);
$body = $this->parser->subparse(array($this, 'testEndTag'), true);
$stream->expect(\Twig_Token::BLOCK_END_TYPE);
if ($this->single && 1 < count($inputs)) {
$inputs = array_slice($inputs, -1);
}
if (!$name) {
$name = $this->factory->generateAssetName($inputs, $filters, $attributes);
}
$asset = $this->factory->createAsset($inputs, $filters, $attributes + array('name' => $name));
return $this->createNode($asset, $body, $inputs, $filters, $name, $attributes, $token->getLine(), $this->getTag());
}
public function getTag()
{
return $this->tag;
}
public function testEndTag(\Twig_Token $token)
{
return $token->test(array('end'.$this->getTag()));
}
protected function createNode(AssetInterface $asset, \Twig_NodeInterface $body, array $inputs, array $filters, $name, array $attributes = array(), $lineno = 0, $tag = null)
{
return new AsseticNode($asset, $body, $inputs, $filters, $name, $attributes, $lineno, $tag);
}
}
src/Assetic/Extension/Twig/TwigFormulaLoader.php 0000666 00000006237 13436754447 0015751 0 ustar 00
*/
class TwigFormulaLoader implements FormulaLoaderInterface
{
private $twig;
public function __construct(\Twig_Environment $twig)
{
$this->twig = $twig;
}
public function load(ResourceInterface $resource)
{
try {
$tokens = $this->twig->tokenize($resource->getContent(), (string) $resource);
$nodes = $this->twig->parse($tokens);
} catch (\Exception $e) {
return array();
}
return $this->loadNode($nodes);
}
/**
* Loads assets from the supplied node.
*
* @param \Twig_Node $node
*
* @return array An array of asset formulae indexed by name
*/
private function loadNode(\Twig_Node $node)
{
$formulae = array();
if ($node instanceof AsseticNode) {
$formulae[$node->getAttribute('name')] = array(
$node->getAttribute('inputs'),
$node->getAttribute('filters'),
array(
'output' => $node->getAttribute('asset')->getTargetPath(),
'name' => $node->getAttribute('name'),
'debug' => $node->getAttribute('debug'),
'combine' => $node->getAttribute('combine'),
'vars' => $node->getAttribute('vars'),
),
);
} elseif ($node instanceof \Twig_Node_Expression_Function) {
$name = version_compare(\Twig_Environment::VERSION, '1.2.0-DEV', '<')
? $node->getNode('name')->getAttribute('name')
: $node->getAttribute('name');
if ($this->twig->getFunction($name) instanceof AsseticFilterFunction) {
$arguments = array();
foreach ($node->getNode('arguments') as $argument) {
$arguments[] = eval('return '.$this->twig->compile($argument).';');
}
$invoker = $this->twig->getExtension('assetic')->getFilterInvoker($name);
$inputs = isset($arguments[0]) ? (array) $arguments[0] : array();
$filters = $invoker->getFilters();
$options = array_replace($invoker->getOptions(), isset($arguments[1]) ? $arguments[1] : array());
if (!isset($options['name'])) {
$options['name'] = $invoker->getFactory()->generateAssetName($inputs, $filters, $options);
}
$formulae[$options['name']] = array($inputs, $filters, $options);
}
}
foreach ($node as $child) {
if ($child instanceof \Twig_Node) {
$formulae += $this->loadNode($child);
}
}
return $formulae;
}
}
src/Assetic/Extension/Twig/AsseticFilterInvoker.php 0000666 00000002473 13436754447 0016457 0 ustar 00
*/
class AsseticFilterInvoker
{
private $factory;
private $filters;
private $options;
public function __construct($factory, $filter)
{
$this->factory = $factory;
if (is_array($filter) && isset($filter['filter'])) {
$this->filters = (array) $filter['filter'];
$this->options = isset($filter['options']) ? (array) $filter['options'] : array();
} else {
$this->filters = (array) $filter;
$this->options = array();
}
}
public function getFactory()
{
return $this->factory;
}
public function getFilters()
{
return $this->filters;
}
public function getOptions()
{
return $this->options;
}
public function invoke($input, array $options = array())
{
$asset = $this->factory->createAsset($input, $this->filters, $options + $this->options);
return $asset->getTargetPath();
}
}
src/Assetic/Extension/Twig/AsseticExtension.php 0000666 00000004143 13436754447 0015644 0 ustar 00 factory = $factory;
$this->functions = array();
$this->valueSupplier = $valueSupplier;
foreach ($functions as $function => $options) {
if (is_integer($function) && is_string($options)) {
$this->functions[$options] = array('filter' => $options);
} else {
$this->functions[$function] = $options + array('filter' => $function);
}
}
}
public function getTokenParsers()
{
return array(
new AsseticTokenParser($this->factory, 'javascripts', 'js/*.js'),
new AsseticTokenParser($this->factory, 'stylesheets', 'css/*.css'),
new AsseticTokenParser($this->factory, 'image', 'images/*', true),
);
}
public function getFunctions()
{
$functions = array();
foreach ($this->functions as $function => $filter) {
$functions[$function] = new AsseticFilterFunction($function);
}
return $functions;
}
public function getGlobals()
{
return array(
'assetic' => array(
'debug' => $this->factory->isDebug(),
'vars' => null !== $this->valueSupplier ? new ValueContainer($this->valueSupplier) : array(),
),
);
}
public function getFilterInvoker($function)
{
return new AsseticFilterInvoker($this->factory, $this->functions[$function]);
}
public function getName()
{
return 'assetic';
}
}
src/Assetic/Extension/Twig/TwigResource.php 0000666 00000002170 13436754447 0014774 0 ustar 00
*/
class TwigResource implements ResourceInterface
{
private $loader;
private $name;
public function __construct(\Twig_LoaderInterface $loader, $name)
{
$this->loader = $loader;
$this->name = $name;
}
public function getContent()
{
try {
return $this->loader->getSource($this->name);
} catch (\Twig_Error_Loader $e) {
return '';
}
}
public function isFresh($timestamp)
{
try {
return $this->loader->isFresh($this->name, $timestamp);
} catch (\Twig_Error_Loader $e) {
return false;
}
}
public function __toString()
{
return $this->name;
}
}
composer.json 0000666 00000006104 13436754447 0007314 0 ustar 00 {
"name": "kriswallsmith/assetic",
"minimum-stability": "dev",
"description": "Asset Management for PHP",
"keywords": [ "assets", "compression", "minification" ],
"homepage": "https://github.com/kriswallsmith/assetic",
"type": "library",
"license": "MIT",
"authors": [
{
"name": "Kris Wallsmith",
"email": "kris.wallsmith@gmail.com",
"homepage": "http://kriswallsmith.net/"
}
],
"require": {
"php": ">=5.3.1",
"symfony/process": ">=2.1.0,<2.3-dev"
},
"require-dev": {
"phpunit/phpunit": "3.7.*",
"twig/twig": ">=1.6.0,<2.0",
"leafo/lessphp": "*",
"leafo/scssphp": "*",
"ptachoire/cssembed": "*",
"leafo/scssphp-compass": "*",
"cssmin/cssmin": "*",
"mrclay/minify": "*",
"kamicane/packager": "*",
"joliclic/javascript-packer": "*"
},
"minimum-stability": "dev",
"suggest": {
"twig/twig": "Assetic provides the integration with the Twig templating engine",
"leafo/lessphp": "Assetic provides the integration with the lessphp LESS compiler",
"leafo/scssphp": "Assetic provides the integration with the scssphp SCSS compiler",
"ptachoire/cssembed": "Assetic provides the integration with phpcssembed to embed data uris",
"leafo/scssphp-compass": "Assetic provides the integration with the SCSS compass plugin"
},
"autoload": {
"psr-0": { "Assetic": "src/" },
"files": [ "src/functions.php" ]
},
"config": {
"bin-dir": "bin"
},
"extra": {
"branch-alias": {
"dev-master": "1.1-dev"
}
},
"repositories": [
{
"type": "package",
"package": {
"name": "cssmin/cssmin",
"version": "3.0.1",
"dist": { "url": "http://cssmin.googlecode.com/files/cssmin-v3.0.1.php", "type": "file" },
"autoload": { "classmap": [ "cssmin-v3.0.1.php" ] }
}
},
{
"type": "package",
"package": {
"name": "mrclay/minify",
"version": "2.1.5",
"dist": { "url": "http://minify.googlecode.com/files/minify-2.1.5.zip", "type": "zip" },
"autoload": { "classmap": [ "min/lib/" ] }
}
},
{
"type": "package",
"package": {
"name": "kamicane/packager",
"version": "1.0",
"dist": { "url": "https://github.com/kamicane/packager/archive/1.0.zip", "type": "zip" },
"autoload": { "classmap": [ "." ] }
}
},
{
"type": "package",
"package": {
"name": "joliclic/javascript-packer",
"version": "1.1",
"dist": { "url": "http://joliclic.free.fr/php/javascript-packer/telechargement.php?id=2&action=telecharger", "type": "zip" },
"autoload": { "classmap": [ "class.JavaScriptPacker.php" ] }
}
}
]
}