Descarga assetic - Descarga de código fuente assetic

assetic

assetic es un marco de gestión de activos para PHP mantenido por el equipo de Winter CMS.

asseticAssetAssetCollection; use assetic AssetFileAsset; use assetic AssetGlobAsset; $js = new AssetCollection(array( new GlobAsset('/path/to/js/*'), new FileAsset('/path/to/another.js'), )); // the code is merged when the asset is dumped echo $js->dump();">

 <?php

use assetic  Asset  AssetCollection ;
use assetic  Asset  FileAsset ;
use assetic  Asset  GlobAsset ;

$ js = new AssetCollection ( array (
    new GlobAsset ( ' /path/to/js/* ' ),
    new FileAsset ( ' /path/to/another.js ' ),
));

// the code is merged when the asset is dumped
echo $ js -> dump ();

Activos

Un activo assetic es algo con contenido filtrable que se puede cargar y descargar. Un activo también incluye metadatos, algunos de los cuales pueden manipularse y otros son inmutables.

Propiedad	Accesorio	mutador
contenido	obtener contenido	establecer contenido
tiempo	obtenerLastModified	n / A
raíz fuente	getSourceRoot	n / A
ruta de origen	getSourcePath	n / A
ruta de destino	obtener ruta de destino	establecerRutaDestino

La propiedad "ruta de destino" indica dónde se debe descartar un activo (o una colección de activos).

Filtros

Se pueden aplicar filtros para manipular activos.

asseticAssetAssetCollection; use assetic AssetFileAsset; use assetic AssetGlobAsset; use assetic FilterLessFilter; use assetic FilterUglifyCssFilter; $css = new AssetCollection(array( new FileAsset('/path/to/src/styles.less', array(new LessFilter())), new GlobAsset('/path/to/css/*'), ), array( new UglifyCssFilter('/path/to/uglifycss'), )); // this will echo CSS compiled by LESS and compressed by uglifycss echo $css->dump();">

 <?php

use assetic  Asset  AssetCollection ;
use assetic  Asset  FileAsset ;
use assetic  Asset  GlobAsset ;
use assetic  Filter  LessFilter ;
use assetic  Filter  UglifyCssFilter ;

$ css = new AssetCollection ( array (
    new FileAsset ( ' /path/to/src/styles.less ' , array ( new LessFilter ())),
    new GlobAsset ( ' /path/to/css/* ' ),
), array (
    new UglifyCssFilter ( ' /path/to/uglifycss ' ),
));

// this will echo CSS compiled by LESS and compressed by uglifycss
echo $ css -> dump ();

Los filtros aplicados a la colección se aplicarán en cascada a cada hoja de activo si la iteras.

 <?php

foreach ( $ css as $ leaf ) {
    // each leaf is compressed by uglifycss
    echo $ leaf -> dump ();
}

El núcleo proporciona los siguientes filtros en el espacio de nombres assetic Filter :

CoffeeScriptFilter : compila CoffeeScript en Javascript
CssImportFilter : hojas de estilo importadas en línea
CSSMinFilter : minimiza CSS
CssRewriteFilter : corrige las URL relativas en los recursos CSS al pasar a una nueva URL
GoogleClosureCompilerApiFilter : compila Javascript usando la API del compilador de cierre de Google
HandlebarsFilter : compila plantillas de Manillares en Javascript
JavaScriptMinifierFilter : minimiza Javascript
JpegoptimFilter : optimiza tus archivos JPEG
JpegtranFilter : optimiza tus archivos JPEG
LessFilter : analiza LESS en CSS (usando less.js con node.js)
LessphpFilter : analiza LESS en CSS (usando lessphp)
OptiPngFilter : optimiza tus PNG
PackerFilter : comprime Javascript usando Packer de Dean Edwards
PhpCssEmbedFilter : incorpora datos de imagen en su hoja de estilo
ReactJsxFilter : compila React JSX en JavaScript
ScssphpFilter : analiza SCSS en CSS
SeparatorFilter : inserta un separador entre activos para evitar errores de fusión
StylesheetMinifyFilter : comprime archivos CSS de hojas de estilo
StylusFilter : analiza STYL en CSS
TailwindCssFilter : crea una hoja de estilo CSS Tailwind utilizando la utilidad CLI independiente Tailwind CSS
TypeScriptFilter : analiza TypeScript en Javascript
UglifyCssFilter : minimiza CSS
UglifyJs2Filter : minimiza Javascript
UglifyJs3Filter : minimiza Javascript

Administrador de activos

Se proporciona un administrador de activos para organizar los activos.

asseticAssetManager; use assetic AssetFileAsset; use assetic AssetGlobAsset; $am = new AssetManager(); $am->set('jquery', new FileAsset('/path/to/jquery.js')); $am->set('base_css', new GlobAsset('/path/to/css/*'));">

 <?php

use assetic  AssetManager ;
use assetic  Asset  FileAsset ;
use assetic  Asset  GlobAsset ;

$ am = new AssetManager ();
$ am -> set ( ' jquery ' , new FileAsset ( ' /path/to/jquery.js ' ));
$ am -> set ( ' base_css ' , new GlobAsset ( ' /path/to/css/* ' ));

El administrador de activos también se puede utilizar para hacer referencia a activos y evitar duplicaciones.

asseticAssetAssetCollection; use assetic AssetAssetReference; use assetic AssetFileAsset; $am->set('my_plugin', new AssetCollection(array( new AssetReference($am, 'jquery'), new FileAsset('/path/to/jquery.plugin.js'), )));">

 <?php

use assetic  Asset  AssetCollection ;
use assetic  Asset  AssetReference ;
use assetic  Asset  FileAsset ;

$ am -> set ( ' my_plugin ' , new AssetCollection ( array (
    new AssetReference ( $ am , ' jquery ' ),
    new FileAsset ( ' /path/to/jquery.plugin.js ' ),
)));

Administrador de filtros

También se proporciona un administrador de filtros para organizar los filtros.

asseticFilterManager; use assetic FilterScssFilter; use assetic FilterCssMinFilter; $fm = new FilterManager(); $fm->set('sass', new ScssFilter('/path/to/parser/scss')); $fm->set('cssmin', new CssMinFilter());">

 <?php

use assetic  FilterManager ;
use assetic  Filter  ScssFilter ;
use assetic  Filter  CssMinFilter ;

$ fm = new FilterManager ();
$ fm -> set ( ' sass ' , new ScssFilter ( ' /path/to/parser/scss ' ));
$ fm -> set ( ' cssmin ' , new CssMinFilter ());

Fábrica de activos

Si prefieres no crear todos estos objetos a mano, puedes utilizar la fábrica de activos, que hará la mayor parte del trabajo por ti.

asseticFactoryAssetFactory; $factory = new AssetFactory('/path/to/asset/directory/'); $factory->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 '?cssmin', // don't use this filter in debug mode )); echo $css->dump();">

 <?php

use assetic  Factory  AssetFactory ;

$ factory = new AssetFactory ( ' /path/to/asset/directory/ ' );
$ factory -> 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
    ' ?cssmin ' ,        // don't use this filter in debug mode
));

echo $ css -> dump ();

AssetFactory se construye con un directorio raíz que se utiliza como directorio base para las rutas relativas de activos.

Prefijar un nombre de filtro con un signo de interrogación, como está cssmin aquí, hará que ese filtro se omita cuando la fábrica esté en modo de depuración.

También puede registrar trabajadores en la fábrica y todos los activos creados por ella se pasarán al método process() del trabajador antes de ser devueltos. Consulte Eliminación de caché a continuación para ver un ejemplo.

Volcar activos a archivos estáticos

Puede volcar todos los activos que contiene un AssetManager en archivos de un directorio. Probablemente estará debajo de la raíz de documentos de su servidor web para que los archivos puedan entregarse estáticamente.

asseticAssetWriter; $writer = new AssetWriter('/path/to/web'); $writer->writeManagerAssets($am);">

 <?php

use assetic  AssetWriter ;

$ writer = new AssetWriter ( ' /path/to/web ' );
$ writer -> writeManagerAssets ( $ am );

Esto hará uso de la ruta de destino de los activos.

Eliminación de caché

Si entrega sus activos desde archivos estáticos como se acaba de describir, puede usar CacheBustingWorker para reescribir las rutas de destino de los activos. Insertará un identificador antes de la extensión del nombre de archivo que es único para una versión particular del activo.

Este identificador se basa en la hora de modificación del activo y también tendrá en cuenta los activos dependientes si los filtros aplicados lo admiten.

asseticFactoryAssetFactory; use assetic FactoryWorkerCacheBustingWorker; $factory = new AssetFactory('/path/to/asset/directory/'); $factory->setAssetManager($am); $factory->setFilterManager($fm); $factory->setDebug(true); $factory->addWorker(new CacheBustingWorker()); $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();">

 <?php

use assetic  Factory  AssetFactory ;
use assetic  Factory  Worker  CacheBustingWorker ;

$ factory = new AssetFactory ( ' /path/to/asset/directory/ ' );
$ factory -> setAssetManager ( $ am );
$ factory -> setFilterManager ( $ fm );
$ factory -> setDebug ( true );
$ factory -> addWorker ( new CacheBustingWorker ());

$ 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 ();

Almacenamiento en caché interno

Se proporciona un mecanismo de almacenamiento en caché simple para evitar trabajo innecesario.

asseticAssetAssetCache; use assetic AssetFileAsset; use assetic CacheFilesystemCache; use assetic FilterJavaScriptMinifierFilter; $jsMinifier = new JavaScriptMinifierFilter(); $js = new AssetCache( new FileAsset('/path/to/some.js', array($jsMinifier)), new FilesystemCache('/path/to/cache') ); // the JavaScriptMinifierFilter compressor will only run on the first call $js->dump(); $js->dump(); $js->dump();">

 <?php

use assetic  Asset  AssetCache ;
use assetic  Asset  FileAsset ;
use assetic  Cache  FilesystemCache ;
use assetic  Filter  JavaScriptMinifierFilter ;

$ jsMinifier = new JavaScriptMinifierFilter ();
$ js = new AssetCache (
    new FileAsset ( ' /path/to/some.js ' , array ( $ jsMinifier )),
    new FilesystemCache ( ' /path/to/cache ' )
);

// the JavaScriptMinifierFilter compressor will only run on the first call
$ js -> dump ();
$ js -> dump ();
$ js -> dump ();

Ramita

Para utilizar la extensión assetic Twig, debe registrarla en su entorno Twig:

 <?php

$ twig -> addExtension ( new assetic Extension ( $ factory ));

Una vez implementada, la extensión expone hojas de estilo y una etiqueta de JavaScript con una sintaxis similar a la que utiliza la fábrica de activos:

 {% stylesheets '/path/to/sass/main.sass' filter = 'sass,?yui_css' output = 'css/all.css' %}
    < link href = " {{ asset_url }} " type = " text/css " rel = " stylesheet " />
{% endstylesheets %}

Este ejemplo representará un elemento link en la página que incluye una URL donde se puede encontrar el recurso filtrado.

Cuando la extensión está en modo de depuración, esta misma etiqueta representará múltiples elementos link , uno para cada activo al que hace referencia el glob css/src/*.sass . Los filtros especificados se seguirán aplicando, a menos que estén marcados como opcionales mediante el símbolo ? prefijo.

Este comportamiento también se puede desencadenar estableciendo un atributo debug en la etiqueta:

 {% stylesheets 'css/*' debug = true %} ... {% stylesheets %}

Estos activos deben escribirse en el directorio web para que estas URL no devuelvan errores 404.

asseticAssetWriter; use assetic ExtensionTwigTwigFormulaLoader; use assetic ExtensionTwigTwigResource; use assetic FactoryLazyAssetManager; $am = new LazyAssetManager($factory); // enable loading assets from twig templates $am->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);">

 <?php

use assetic  AssetWriter ;
use assetic  Extension  Twig  TwigFormulaLoader ;
use assetic  Extension  Twig  TwigResource ;
use assetic  Factory  LazyAssetManager ;

$ am = new LazyAssetManager ( $ factory );

// enable loading assets from twig templates
$ am -> 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 );