Download assetic - download de código-fonte assetic

assetic

assetic é uma estrutura de gerenciamento de ativos para PHP mantida pela equipe 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 ();

Ativos

Um ativo assetic é algo com conteúdo filtrável que pode ser carregado e despejado. Um ativo também inclui metadados, alguns dos quais podem ser manipulados e outros imutáveis.

Propriedade	Acessador	Mutador
contente	getContent	setContent
mtime	getLastModified	n / D
raiz de origem	getSourceRoot	n / D
caminho de origem	getSourcePath	n / D
caminho de destino	getTargetPath	definirTargetPath

A propriedade "caminho de destino" indica onde um ativo (ou uma coleção de ativos) deve ser despejado.

Filtros

Filtros podem ser aplicados para manipular ativos.

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

Os filtros aplicados à coleção serão distribuídos em cascata para cada folha de ativo se você iterar sobre ela.

 <?php

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

O núcleo fornece os seguintes filtros no namespace assetic Filter :

CoffeeScriptFilter : compila CoffeeScript em Javascript
CssImportFilter : inline folhas de estilo importadas
CSSMinFilter : minimiza CSS
CssRewriteFilter : corrige URLs relativos em ativos CSS ao mover para um novo URL
GoogleClosureCompilerApiFilter : compila Javascript usando a API Google Closure Compiler
HandlebarsFilter : compila modelos de guiador em Javascript
JavaScriptMinifierFilter : minimiza Javascript
JpegoptimFilter : otimize seus JPEGs
JpegtranFilter : otimize seus JPEGs
LessFilter : analisa LESS em CSS (usando less.js com node.js)
LessphpFilter : analisa LESS em CSS (usando lessphp)
OptiPngFilter : otimize seus PNGs
PackerFilter : compacta Javascript usando Packer de Dean Edwards
PhpCssEmbedFilter : incorpora dados de imagem em sua folha de estilo
ReactJsxFilter : compila React JSX em JavaScript
ScssphpFilter : analisa SCSS em CSS
SeparatorFilter : insere um separador entre ativos para evitar falhas de mesclagem
StylesheetMinifyFilter : compacta arquivos CSS de folhas de estilo
StylusFilter : analisa STYL em CSS
TailwindCssFilter : cria uma folha de estilo Tailwind CSS usando o utilitário CLI autônomo Tailwind CSS
TypeScriptFilter : analisa TypeScript em Javascript
UglifyCssFilter : minimiza CSS
UglifyJs2Filter : minimiza Javascript
UglifyJs3Filter : minimiza Javascript

Gerente de Ativos

Um gerenciador de ativos é fornecido para organizar ativos.

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/* ' ));

O gerenciador de ativos também pode ser usado para fazer referência a ativos para evitar duplicação.

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 ' ),
)));

Gerenciador de filtros

Um gerenciador de filtros também é fornecido para organizar 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 ativos

Se preferir não criar todos esses objetos manualmente, você pode usar a fábrica de ativos, que fará a maior parte do trabalho para você.

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

O AssetFactory é construído com um diretório raiz que é usado como diretório base para caminhos relativos de ativos.

Prefixar um nome de filtro com um ponto de interrogação, como cssmin está aqui, fará com que esse filtro seja omitido quando a fábrica estiver no modo de depuração.

Você também pode cadastrar Trabalhadores na fábrica e todos os ativos criados por ela serão passados para o método process() do trabalhador antes de serem retornados. Consulte Bloqueio de cache abaixo para ver um exemplo.

Despejando ativos em arquivos estáticos

Você pode despejar todos os ativos que um AssetManager mantém em arquivos em um diretório. Provavelmente estará abaixo da raiz do documento do seu servidor web para que os arquivos possam ser servidos estaticamente.

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

 <?php

use assetic  AssetWriter ;

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

Isso fará uso do caminho de destino dos ativos.

Rebentamento de cache

Se você fornecer seus ativos a partir de arquivos estáticos conforme descrito, poderá usar o CacheBustingWorker para reescrever os caminhos de destino dos ativos. Ele irá inserir um identificador antes da extensão do nome do arquivo que é exclusivo para uma versão específica do ativo.

Esse identificador é baseado no horário de modificação do ativo e também levará em consideração os ativos dependentes se os filtros aplicados o suportarem.

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

Cache interno

Um mecanismo de cache simples é fornecido para evitar trabalho desnecessário.

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

Galho

Para usar a extensão assetic Twig você deve registrá-la em seu ambiente Twig:

 <?php

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

Uma vez instalada, a extensão expõe folhas de estilo e uma tag javascripts com uma sintaxe semelhante à usada pela fábrica de ativos:

 {% 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 exemplo renderizará um elemento link na página que inclui um URL onde o ativo filtrado pode ser encontrado.

Quando a extensão estiver no modo de depuração, essa mesma tag renderizará vários elementos link , um para cada ativo referenciado pelo glob css/src/*.sass . Os filtros especificados ainda serão aplicados, a menos que sejam marcados como opcionais usando o ? prefixo.

Esse comportamento também pode ser acionado definindo um atributo debug na tag:

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

Esses ativos precisam ser gravados no diretório da web para que essas URLs não retornem erros 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 );