class Twig_Node_Module in Zircon Profile 8.0

Represents a module node.

Consider this class as being final. If you need to customize the behavior of the generated class, consider adding nodes to the following nodes: display_start, display_end, constructor_start, constructor_end, and class_end.

@author Fabien Potencier <[e-mail]>

Hierarchy

• class \Twig_Node implements Twig_NodeInterface
  • class \Twig_Node_Module

File

vendor/twig/twig/lib/Twig/Node/Module.php, line 22

class Twig_Node_Module extends Twig_Node {
  public function __construct(Twig_NodeInterface $body, Twig_Node_Expression $parent = null, Twig_NodeInterface $blocks, Twig_NodeInterface $macros, Twig_NodeInterface $traits, $embeddedTemplates, $filename) {

    // embedded templates are set as attributes so that they are only visited once by the visitors
    parent::__construct(array(
      'parent' => $parent,
      'body' => $body,
      'blocks' => $blocks,
      'macros' => $macros,
      'traits' => $traits,
      'display_start' => new Twig_Node(),
      'display_end' => new Twig_Node(),
      'constructor_start' => new Twig_Node(),
      'constructor_end' => new Twig_Node(),
      'class_end' => new Twig_Node(),
    ), array(
      'filename' => $filename,
      'index' => null,
      'embedded_templates' => $embeddedTemplates,
    ), 1);
  }
  public function setIndex($index) {
    $this
      ->setAttribute('index', $index);
  }
  public function compile(Twig_Compiler $compiler) {
    $this
      ->compileTemplate($compiler);
    foreach ($this
      ->getAttribute('embedded_templates') as $template) {
      $compiler
        ->subcompile($template);
    }
  }
  protected function compileTemplate(Twig_Compiler $compiler) {
    if (!$this
      ->getAttribute('index')) {
      $compiler
        ->write('<?php');
    }
    $this
      ->compileClassHeader($compiler);
    if (count($this
      ->getNode('blocks')) || count($this
      ->getNode('traits')) || null === $this
      ->getNode('parent') || $this
      ->getNode('parent') instanceof Twig_Node_Expression_Constant || count($this
      ->getNode('constructor_start')) || count($this
      ->getNode('constructor_end'))) {
      $this
        ->compileConstructor($compiler);
    }
    $this
      ->compileGetParent($compiler);
    $this
      ->compileDisplay($compiler);
    $compiler
      ->subcompile($this
      ->getNode('blocks'));
    $this
      ->compileMacros($compiler);
    $this
      ->compileGetTemplateName($compiler);
    $this
      ->compileIsTraitable($compiler);
    $this
      ->compileDebugInfo($compiler);
    $this
      ->compileClassFooter($compiler);
  }
  protected function compileGetParent(Twig_Compiler $compiler) {
    if (null === ($parent = $this
      ->getNode('parent'))) {
      return;
    }
    $compiler
      ->write("protected function doGetParent(array \$context)\n", "{\n")
      ->indent()
      ->addDebugInfo($parent)
      ->write('return ');
    if ($parent instanceof Twig_Node_Expression_Constant) {
      $compiler
        ->subcompile($parent);
    }
    else {
      $compiler
        ->raw('$this->loadTemplate(')
        ->subcompile($parent)
        ->raw(', ')
        ->repr($compiler
        ->getFilename())
        ->raw(', ')
        ->repr($this
        ->getNode('parent')
        ->getLine())
        ->raw(')');
    }
    $compiler
      ->raw(";\n")
      ->outdent()
      ->write("}\n\n");
  }
  protected function compileClassHeader(Twig_Compiler $compiler) {
    $compiler
      ->write("\n\n")
      ->write('/* ' . str_replace('*/', '* /', $this
      ->getAttribute('filename')) . " */\n")
      ->write('class ' . $compiler
      ->getEnvironment()
      ->getTemplateClass($this
      ->getAttribute('filename'), $this
      ->getAttribute('index')))
      ->raw(sprintf(" extends %s\n", $compiler
      ->getEnvironment()
      ->getBaseTemplateClass()))
      ->write("{\n")
      ->indent();
  }
  protected function compileConstructor(Twig_Compiler $compiler) {
    $compiler
      ->write("public function __construct(Twig_Environment \$env)\n", "{\n")
      ->indent()
      ->subcompile($this
      ->getNode('constructor_start'))
      ->write("parent::__construct(\$env);\n\n");

    // parent
    if (null === ($parent = $this
      ->getNode('parent'))) {
      $compiler
        ->write("\$this->parent = false;\n\n");
    }
    elseif ($parent instanceof Twig_Node_Expression_Constant) {
      $compiler
        ->addDebugInfo($parent)
        ->write('$this->parent = $this->loadTemplate(')
        ->subcompile($parent)
        ->raw(', ')
        ->repr($compiler
        ->getFilename())
        ->raw(', ')
        ->repr($this
        ->getNode('parent')
        ->getLine())
        ->raw(");\n");
    }
    $countTraits = count($this
      ->getNode('traits'));
    if ($countTraits) {

      // traits
      foreach ($this
        ->getNode('traits') as $i => $trait) {
        $this
          ->compileLoadTemplate($compiler, $trait
          ->getNode('template'), sprintf('$_trait_%s', $i));
        $compiler
          ->addDebugInfo($trait
          ->getNode('template'))
          ->write(sprintf("if (!\$_trait_%s->isTraitable()) {\n", $i))
          ->indent()
          ->write("throw new Twig_Error_Runtime('Template \"'.")
          ->subcompile($trait
          ->getNode('template'))
          ->raw(".'\" cannot be used as a trait.');\n")
          ->outdent()
          ->write("}\n")
          ->write(sprintf("\$_trait_%s_blocks = \$_trait_%s->getBlocks();\n\n", $i, $i));
        foreach ($trait
          ->getNode('targets') as $key => $value) {
          $compiler
            ->write(sprintf('if (!isset($_trait_%s_blocks[', $i))
            ->string($key)
            ->raw("])) {\n")
            ->indent()
            ->write("throw new Twig_Error_Runtime(sprintf('Block ")
            ->string($key)
            ->raw(' is not defined in trait ')
            ->subcompile($trait
            ->getNode('template'))
            ->raw(".'));\n")
            ->outdent()
            ->write("}\n\n")
            ->write(sprintf('$_trait_%s_blocks[', $i))
            ->subcompile($value)
            ->raw(sprintf('] = $_trait_%s_blocks[', $i))
            ->string($key)
            ->raw(sprintf(']; unset($_trait_%s_blocks[', $i))
            ->string($key)
            ->raw("]);\n\n");
        }
      }
      if ($countTraits > 1) {
        $compiler
          ->write("\$this->traits = array_merge(\n")
          ->indent();
        for ($i = 0; $i < $countTraits; ++$i) {
          $compiler
            ->write(sprintf('$_trait_%s_blocks' . ($i == $countTraits - 1 ? '' : ',') . "\n", $i));
        }
        $compiler
          ->outdent()
          ->write(");\n\n");
      }
      else {
        $compiler
          ->write("\$this->traits = \$_trait_0_blocks;\n\n");
      }
      $compiler
        ->write("\$this->blocks = array_merge(\n")
        ->indent()
        ->write("\$this->traits,\n")
        ->write("array(\n");
    }
    else {
      $compiler
        ->write("\$this->blocks = array(\n");
    }

    // blocks
    $compiler
      ->indent();
    foreach ($this
      ->getNode('blocks') as $name => $node) {
      $compiler
        ->write(sprintf("'%s' => array(\$this, 'block_%s'),\n", $name, $name));
    }
    if ($countTraits) {
      $compiler
        ->outdent()
        ->write(")\n");
    }
    $compiler
      ->outdent()
      ->write(");\n")
      ->outdent()
      ->subcompile($this
      ->getNode('constructor_end'))
      ->write("}\n\n");
  }
  protected function compileDisplay(Twig_Compiler $compiler) {
    $compiler
      ->write("protected function doDisplay(array \$context, array \$blocks = array())\n", "{\n")
      ->indent()
      ->subcompile($this
      ->getNode('display_start'))
      ->subcompile($this
      ->getNode('body'));
    if (null !== ($parent = $this
      ->getNode('parent'))) {
      $compiler
        ->addDebugInfo($parent);
      if ($parent instanceof Twig_Node_Expression_Constant) {
        $compiler
          ->write('$this->parent');
      }
      else {
        $compiler
          ->write('$this->getParent($context)');
      }
      $compiler
        ->raw("->display(\$context, array_merge(\$this->blocks, \$blocks));\n");
    }
    $compiler
      ->subcompile($this
      ->getNode('display_end'))
      ->outdent()
      ->write("}\n\n");
  }
  protected function compileClassFooter(Twig_Compiler $compiler) {
    $compiler
      ->subcompile($this
      ->getNode('class_end'))
      ->outdent()
      ->write("}\n");
  }
  protected function compileMacros(Twig_Compiler $compiler) {
    $compiler
      ->subcompile($this
      ->getNode('macros'));
  }
  protected function compileGetTemplateName(Twig_Compiler $compiler) {
    $compiler
      ->write("public function getTemplateName()\n", "{\n")
      ->indent()
      ->write('return ')
      ->repr($this
      ->getAttribute('filename'))
      ->raw(";\n")
      ->outdent()
      ->write("}\n\n");
  }
  protected function compileIsTraitable(Twig_Compiler $compiler) {

    // A template can be used as a trait if:
    //   * it has no parent
    //   * it has no macros
    //   * it has no body
    //
    // Put another way, a template can be used as a trait if it
    // only contains blocks and use statements.
    $traitable = null === $this
      ->getNode('parent') && 0 === count($this
      ->getNode('macros'));
    if ($traitable) {
      if ($this
        ->getNode('body') instanceof Twig_Node_Body) {
        $nodes = $this
          ->getNode('body')
          ->getNode(0);
      }
      else {
        $nodes = $this
          ->getNode('body');
      }
      if (!count($nodes)) {
        $nodes = new Twig_Node(array(
          $nodes,
        ));
      }
      foreach ($nodes as $node) {
        if (!count($node)) {
          continue;
        }
        if ($node instanceof Twig_Node_Text && ctype_space($node
          ->getAttribute('data'))) {
          continue;
        }
        if ($node instanceof Twig_Node_BlockReference) {
          continue;
        }
        $traitable = false;
        break;
      }
    }
    if ($traitable) {
      return;
    }
    $compiler
      ->write("public function isTraitable()\n", "{\n")
      ->indent()
      ->write(sprintf("return %s;\n", $traitable ? 'true' : 'false'))
      ->outdent()
      ->write("}\n\n");
  }
  protected function compileDebugInfo(Twig_Compiler $compiler) {
    $compiler
      ->write("public function getDebugInfo()\n", "{\n")
      ->indent()
      ->write(sprintf("return %s;\n", str_replace("\n", '', var_export(array_reverse($compiler
      ->getDebugInfo(), true), true))))
      ->outdent()
      ->write("}\n");
  }
  protected function compileLoadTemplate(Twig_Compiler $compiler, $node, $var) {
    if ($node instanceof Twig_Node_Expression_Constant) {
      $compiler
        ->write(sprintf('%s = $this->loadTemplate(', $var))
        ->subcompile($node)
        ->raw(', ')
        ->repr($compiler
        ->getFilename())
        ->raw(', ')
        ->repr($node
        ->getLine())
        ->raw(");\n");
    }
    else {
      throw new LogicException('Trait templates can only be constant nodes');
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Twig_Node::$attributes	protected	property
Twig_Node::$lineno	protected	property
Twig_Node::$nodes	protected	property
Twig_Node::$tag	protected	property
Twig_Node::count	public	function
Twig_Node::getAttribute	public	function	Gets an attribute value by name.
Twig_Node::getIterator	public	function
Twig_Node::getLine	public	function	Overrides Twig_NodeInterface::getLine
Twig_Node::getNode	public	function	Gets a node by name.
Twig_Node::getNodeTag	public	function	Overrides Twig_NodeInterface::getNodeTag
Twig_Node::hasAttribute	public	function	Returns true if the attribute is defined.
Twig_Node::hasNode	public	function	Returns true if the node with the given name exists.
Twig_Node::removeAttribute	public	function	Removes an attribute by name.
Twig_Node::removeNode	public	function	Removes a node by name.
Twig_Node::setAttribute	public	function	Sets an attribute by name to a value.
Twig_Node::setNode	public	function	Sets a node.
Twig_Node::toXml Deprecated	public	function
Twig_Node::__toString	public	function
Twig_Node_Module::compile	public	function	Compiles the node to PHP. Overrides Twig_Node::compile
Twig_Node_Module::compileClassFooter	protected	function
Twig_Node_Module::compileClassHeader	protected	function
Twig_Node_Module::compileConstructor	protected	function
Twig_Node_Module::compileDebugInfo	protected	function
Twig_Node_Module::compileDisplay	protected	function
Twig_Node_Module::compileGetParent	protected	function
Twig_Node_Module::compileGetTemplateName	protected	function
Twig_Node_Module::compileIsTraitable	protected	function
Twig_Node_Module::compileLoadTemplate	protected	function
Twig_Node_Module::compileMacros	protected	function
Twig_Node_Module::compileTemplate	protected	function
Twig_Node_Module::setIndex	public	function
Twig_Node_Module::__construct	public	function	Constructor. Overrides Twig_Node::__construct