How to import multiple macros? - symfony

Question

I want to elegantly import multiple macros from a single place.
I created a file called "macros.twig" and have included it into my template:
{% include "_includes/macros" %}
Within that file, I hoped to import all my available macros like so:
{% import "_includes/macros/snippets" as snippets %}
{% import "_includes/macros/timestamp" as timestamp %}
{% import "_includes/macros/telephone" as telephone %}
{% import "_includes/macros/subscribe" as subscribe %}
{% import "_includes/macros/image" as image %}
{% import "_includes/macros/admin" as admin %}
This sort-of modular approach was suppose to make it easier to manage the macros I want to use globally; without cluttering the head of my main layout.
Currently, when I call a macro this way, I get a "Variable "subscribe" does not exist" error.
What's the preferred method of importing multiple macros at one time?
Thanks

Answer 1

macro tag in Twig is a kind of function you can use to avoid code repetition and is meant for a single template with {% import _self as macro %} or to be shared between some different templates for a group of controllers using the same view variables.
If you need to use a function globally in twig you better create a \Twig_SimpleFunction.
see http://twig.sensiolabs.org/doc/advanced.html#functions and http://symfony.com/doc/current/cookbook/templating/twig_extension.html
Edited based on comment
Anyway you could have something like this to autoload macro :
<?php
// src/AppBundle/Twig/MacroAutoloadExtension.php
namespace AppBundle\Twig;
class MacroAutoloadExtension extends \Twig_Extension
{
public function getFunctions()
{
return array(
// "*"" is used to get "template_macro" as $macro as third argument
new \Twig_SimpleFunction('macro_*', array($this, 'getMacro'), array(
'needs_environment' => true, // $env first argument will render the macro
'needs_context' => true, // $context second argument an array of view vars
'is_safe' => array('html'), // function returns escaped html
'is_variadic' => true, // and takes any number of arguments
))
);
}
public function getMacro(\Twig_Environment $env, array $context, $macro, array $vars = array())
{
list($name, $func) = explode('_', $macro);
$notInContext = 0; // helps generate unique context key
$varToContextKey = function ($var) use (&$context, $name, $func, &$notInContext) {
if (false !== $idx = array_search($var, $context, true)) {
return $idx;
}
// else the var does not belong to context
$key = '_'.$name.'_'.$func.'_'.++$notInContext;
$context[$key] = $var;
return $key;
};
$args = implode(', ', array_map($varToContextKey, $vars));
$twig = <<<EOT
{% import '_includes/macros/$name.twig' as $name %}
{{ $name.$func($args) }}
EOT;
try {
$html = $env->createTemplate($twig)->render($context);
} catch (\Twig_Error $e) {
$e->setTemplateFile(sprintf('_includes/macro/%s.twig', $name));
throw $e;
}
return $html;
}
public function getName()
{
return 'macro_autoload_extension';
}
}
Register the extension :
# app/config/sevices.yml
services:
...
app.macro_autoload_extension:
class: AppBundle\Twig\MacroAutoloadExtension
public: false
tags:
- { name: twig.extension }
Write some macros :
{# app/Resources/views/_includes/macros/list.twig #}
{% macro ol(array) %}
{% if array is iterable %}
<ol>
{% for item in array %}
<li>
{% if item is iterable %}
{% for sub_item in item %}{{ macro_list_ul(sub_item) }}{% endfor %}
{% else %}
{{ item }}
{% endif %}
</li>
{% endfor %}
</ol>
{% else %}
<ol><li>{{ array }}</li></ol>
{% endif %}
{% endmacro %}
{% macro ul(array) %}
{% if array is iterable %}
<ul>
{% for key, item in array %}
{{ key }}:
{% if item is iterable %}
{% for sub_item in item %}{{ macro_list_ul(sub_item) }}{% endfor %}
{% else %}{{ item }}{% endif %}
{% endfor %}
</ul>
{% else %}
<ul><li>{{ array }}</li></ul>
{% endif %}
{% endmacro %}
Then you can use everywhere in you views :
{{ macro_list_ol(['un', 'deux', 'trois']) }}
or:
{% set hash = { 'one': 1, 'two': 'deux', 'posts': posts } %}
{{ macro_list_ul(hash) }}
Bonus
Usually when you import macro in a template (one file) with _self or from another template, if you need a macro in a set tag, the macro is not available since set tag has a different scope than _self (even if it shares context) :
{# /app/Resources/views/includes/macro/outer.html.twig #}
{% macro function(args) %}
...
{% endmacro %}
plus
{# /app/Resources/views/Bundle/Controller/action.html.twig #}
{% macro inner_macro(arg1, arg2) %}
{# render something #}
{# cannot access context of this view, only args #}
{% endmacro %}
{% import _self as inner %}
{% import '/includes/macro/outer_macro.html.twig' as outer %} {# cannot access context either %}
...
{% set some_var %}
{# can access context but neither outer or inner #}
{{ inner.inner_macro('yes', 64) }} {# will not work #}
{# you need to do import _self as inner again %}
{# this is fix by both my answer and the one by #KalZekdor #}
{{ macro_outer_function(var_from_context) }} {# will work #}
{% endset %}
{{ some_var }}
You can even call macro from macro without using import.
Update
I created a gist

Answer 2

This was a bit difficult for me, as well, but I put together a nice bundle with an Event Listener that autoloads the macros.
namespace App\Common\UIExtensionBundle\Listeners;
use Symfony\Component\HttpKernel\Event\GetResponseEvent;
use Symfony\Bundle\TwigBundle\TwigEngine;
class UIExtenderListener
{
private $macroNamespace = 'ui';
public function __construct(\Twig_Environment $oTwig, $aMacros)
{
$this->twig = $oTwig;
//Macros
$this->macros = $aMacros;
}
public function onKernelRequest(GetResponseEvent $oEvent)
{
$templates = [];
foreach ($this->macros as $macro => $template)
{
$templates[$macro] = $this->twig->loadTemplate($template);
}
$this->twig->addGlobal($this->macroNamespace, $templates);
}
}
The services.xml for the bundle:
<?xml version="1.0" ?>
<container xmlns="http://symfony.com/schema/dic/services"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
<parameters>
<parameter key="uiext.macros" type="collection">
<parameter key="test">UIXBundle:ui:test.html.twig</parameter>
<parameter key="list">UIXBundle:ui:list.html.twig</parameter>
<parameter key="entity">UIXBundle:ui:entity.html.twig</parameter>
</parameter>
</parameters>
<services>
<service id="uiext.extender" class="App\Common\UIExtensionBundle\Listeners\UIExtenderListener" scope="container">
<tag name="kernel.event_listener" event="kernel.request" method="onKernelRequest" priority="1000" />
<argument type="service" id="twig"/>
<argument>%uiext.macros%</argument>
</service>
</services>
</container>
Here's the views\ui\list.html.twig file:
{% macro ol(arr) %}
<ol>
{% for item in arr %}
<li>{{ item }}</li>
{% endfor %}
</ol>
{% endmacro %}
{% macro ul(arr) %}
<ul>
{% for item in arr %}
<li>{{ item }}</li>
{% endfor %}
</ul>
{% endmacro %}
Then, from any twig template, just add {{ ui.list.ul(listArr) }}