twig_ruby 0.0.1 → 0.0.2

data/lib/twig/node/module.rb

@@ -3,21 +3,36 @@
 module Twig
   module Node
     class Module < Node::Base
-      def initialize(body, parent, blocks, source)
+      # @param [Node::Body] body
+      def initialize(body, parent, blocks, macros, traits, embedded_templates, source)
         nodes = {
           body:,
           blocks:,
+          macros:,
+          traits:,
         }
         nodes[:parent] = parent if parent
 
-        super(nodes)
+        super(
+          nodes,
+          {
+            index: nil,
+            embedded_templates:,
+          },
+          1
+        )
 
         self.source_context = source
       end
 
+      def index=(index)
+        attributes[:index] = index
+      end
+
       def compile(compiler)
+        class_name = compiler.environment.template_class(source_context.name, attributes[:index])
         class_begin = <<~CLASS
-          class Twig::#{compiler.environment.template_class(source_context.name)} < ::Twig::Template
+          class Twig::#{class_name} < ::Twig::Template
         CLASS
 
         class_end = <<~CLASS
@@ -26,48 +41,288 @@ module Twig
 
         compiler.
           raw(class_begin).
-          indent.
-          write("def call(context = {}, blocks = {})\n").
           indent
 
+        compile_constructor(compiler)
+        compile_get_parent(compiler)
+
+        compiler.
+          write("private def call(context = {}, blocks = {})\n").
+          indent.
+          write("unless context.is_a?(::Twig::Runtime::Context)\n").
+          indent.
+          write("context = ::Twig::Runtime::Context.new(context)\n").
+          outdent.
+          write("end\n").
+          write("macros = @macros.dup\n")
+
+        compiler.
+          subcompile(nodes[:body])
+
         if nodes.key?(:parent)
+          parent = nodes[:parent]
+          compiler.add_debug_info(parent)
+
+          if parent.is_a?(Expression::Constant)
+            compiler.
+              write('@parent = load(').
+              subcompile(parent).
+              raw(', ').
+              repr(parent.lineno).
+              raw(")\n").
+              write('@parent')
+          else
+            compiler.write('get_parent(context)')
+          end
+
           compiler.
-            write('load_template(').
-            subcompile(nodes[:parent]).
-            raw(").render(context, block_list.merge(blocks));\n")
+            raw(".unwrap.render_with_blocks(context, self.blocks.merge(blocks));\n")
+        end
+
+        compiler.
+          write("context.output_buffer\n").
+          outdent.
+          write("end\n\n")
+
+        # Blocks
+        compiler.
+          subcompile(nodes[:blocks])
+
+        # Macros
+        compiler.
+          subcompile(nodes[:macros])
+
+        compile_get_template_name(compiler)
+        compile_traitable(compiler)
+        compile_debug_info(compiler)
+        compile_get_source_context(compiler)
+
+        compiler.
+          outdent.
+          raw(class_end)
+
+        attributes[:embedded_templates].nodes.each_value do |template|
+          compiler.subcompile(template)
+        end
+      end
+
+      private
+
+      # @param [Compiler] compiler
+      def compile_constructor(compiler)
+        compiler.
+          write("def initialize(*, **)\n").
+          indent.
+          write("super\n\n").
+          write("@source = source_context\n")
+
+        unless nodes.key?(:parent)
+          compiler.write("@parent = false\n")
+        end
+
+        traits_count = nodes[:traits].length
+
+        if traits_count.positive?
+          nodes[:traits].nodes.each do |i, trait|
+            node = trait.nodes[:template]
+
+            compiler.
+              add_debug_info(node).
+              write("_trait_#{i} = load(").
+              subcompile(node).
+              raw(', ').
+              repr(node.lineno).
+              raw(")\n").
+              write("unless _trait_#{i}.unwrap.traitable?\n").
+              indent.
+              write(%q[raise ::Twig::Error::Runtime.new('Template "' + ]).
+              subcompile(node).
+              raw(%q(+ '" cannot be used as a trait.', )).
+              repr(node.lineno).
+              raw(", @source)\n").
+              outdent.
+              write("end\n").
+              write("_trait_#{i}_blocks = _trait_#{i}.unwrap.blocks.dup\n\n")
+
+            trait.nodes[:targets].nodes.each do |key, value|
+              compiler.
+                write("unless _trait_#{i}_blocks.key?(").
+                string(key).
+                raw(".to_sym)\n").
+                indent.
+                write('raise ::Twig::Error::Runtime.new("Block \"#{').
+                string(key).
+                raw('}\" is not defined in trait \"#{').
+                subcompile(node).
+                raw('}\".", ').
+                repr(node.lineno).
+                raw(", @source)\n").
+                outdent.
+                write("end\n\n").
+
+                write("_trait_#{i}_blocks[").
+                subcompile(value).
+                raw(".to_sym] = _trait_#{i}_blocks[").
+                symbol(key).
+                raw("]\n").
+                write("_trait_#{i}_blocks.delete(").
+                symbol(key).
+                raw(")\n").
+                write('@trait_aliases[').
+                subcompile(value).
+                raw('.to_sym] = ').
+                symbol(key).
+                raw("\n\n")
+            end
+          end
+
+          if traits_count > 1
+            trait_names = (0...traits_count).map { |i| "_trait_#{i}_blocks" }
+
+            compiler.
+              write("@traits = {}.merge(#{trait_names.join(', ')})\n\n")
+          else
+            compiler.
+              write("@traits = _trait_0_blocks\n\n")
+          end
+
+          compiler.
+            write("@blocks = @traits.merge({\n")
         else
           compiler.
-            subcompile(nodes[:body])
+            write("@blocks = {\n")
+        end
+
+        compiler.indent
+
+        nodes[:blocks].nodes.each_key do |name|
+          compiler.
+            write("#{name}: [self, 'block_#{name}'],\n")
+        end
+
+        compiler.outdent
+
+        if traits_count.positive?
+          compiler.
+            write("})\n")
+        else
+          compiler.
+            write("}\n")
         end
 
         compiler.
-          write("@output_buffer\n").
           outdent.
-          write("end\n\n").
-          subcompile(nodes[:blocks]).
-          outdent
+          write("end\n\n")
+      end
+
+      # @param [Compiler] compiler
+      def compile_get_parent(compiler)
+        unless nodes.key?(:parent)
+          return
+        end
+
+        parent = nodes[:parent]
 
         compiler.
+          write("private def do_get_parent(context)\n").
           indent.
-          write("def block_list\n").
-          indent.
-          write("{\n").
-          indent
+          add_debug_info(parent).
+          write('')
 
-        nodes[:blocks].nodes.each_value do |block|
+        if parent.is_a?(Node::Expression::Constant)
+          compiler.subcompile(parent)
+        else
           compiler.
-            write("#{block.attributes[:name]}: self,\n")
+            raw('load(').
+            subcompile(parent).
+            raw(', ').
+            repr(parent.lineno).
+            raw(')')
         end
 
         compiler.
+          raw("\n").
           outdent.
-          write("}\n").
+          write("end\n\n")
+      end
+
+      def compile_get_template_name(compiler)
+        compiler.
+          write("def template_name\n").
+          indent.
+          write('').
+          repr(source_context.name).
+          raw("\n").
           outdent.
-          write("end\n").
-          outdent
+          write("end\n\n")
+      end
+
+      def compile_traitable(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 = !nodes.key?(:parent) && nodes[:macros].empty?
+
+        if traitable
+          body_node = nodes[:body].nodes[0]
+
+          if body_node.empty?
+            body_node = Node::Nodes.new({ 0 => body_node })
+          end
+
+          body_node.nodes.each_value do |node|
+            if node.length.positive?
+              traitable = false
+              break
+            end
+          end
+        end
+
+        if traitable
+          return
+        end
 
         compiler.
-          raw(class_end)
+          write("def traitable?\n").
+          indent.
+          write("false\n").
+          outdent.
+          write("end\n\n")
+      end
+
+      def compile_debug_info(compiler)
+        compiler.
+          write("def self.debug_info\n").
+          indent.
+          write('').
+          repr(compiler.debug_info.to_a.reverse.to_h).
+          raw("\n").
+          outdent.
+          write("end\n\n")
+      end
+
+      def compile_get_source_context(compiler)
+        compiler.
+          write("def source_context\n").
+          indent.
+          write("self.class.source_context\n").
+          outdent.
+          write("end\n\n").
+          write("def self.source_context\n").
+          indent.
+          write('::Twig::Source.new(').
+          string(compiler.environment.debug? ? source_context.code : '').
+          raw(', ').
+          string(source_context.name).
+          raw(', ').
+          string(source_context.path).
+          raw(")\n").
+          outdent.
+          write("end\n")
       end
     end
   end

data/lib/twig/node/output.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Output; end
+  end
+end

data/lib/twig/node/print.rb

@@ -3,13 +3,16 @@
 module Twig
   module Node
     class Print < Node::Base
+      include Output
+
       def initialize(expr, lineno)
         super({ expr: }, {}, lineno)
       end
 
       def compile(compiler)
         compiler.
-          write('@output_buffer.append = ').
+          add_debug_info(self).
+          write('context.output_buffer.append = ').
           subcompile(nodes[:expr]).
           raw(";\n")
       end

data/lib/twig/node/set.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Set < Node::Base
+      # @param [Boolean] capture
+      # @param [Node::Base] names
+      # @param [Node::Base] values
+      # @param [Integer] lineno
+      def initialize(capture, names, values, lineno)
+        safe = false
+
+        if capture
+          safe = true
+          capture = false
+
+          if values.is_a?(Nodes) && values.nodes.empty?
+            values = Expression::Constant.new('', values.lineno)
+          elsif values.is_a?(Text)
+            values = Expression::Constant.new(values.attributes[:data], values.lineno)
+          elsif values.is_a?(Print) && values.nodes[:expr].is_a?(Expression::Constant)
+            values = values.nodes[:expr]
+          else
+            values = Capture.new(values, values.lineno)
+            capture = true
+          end
+        end
+
+        super({ names:, values: }, { capture:, safe: }, lineno)
+      end
+
+      def compile(compiler)
+        compiler.add_debug_info(self)
+
+        if nodes[:names].length > 1
+          compiler.write('')
+
+          nodes[:names].nodes.each do |i, node|
+            compiler.raw(', ') if i.positive?
+            compiler.subcompile(node)
+          end
+
+          compiler.raw(' = ')
+
+          nodes[:values].nodes.each do |i, node|
+            compiler.raw(', ') if i.positive?
+            compiler.
+              raw('(').
+              subcompile(node).
+              raw(')')
+
+            if attributes[:safe]
+              compiler.raw('.html_safe')
+            end
+          end
+        else
+          compiler.
+            subcompile(nodes[:names], raw: false).
+            raw(' = (').
+            subcompile(nodes[:values]).
+            raw(')')
+
+          if attributes[:safe]
+            compiler.raw('.html_safe')
+          end
+        end
+
+        compiler.raw("\n")
+      end
+    end
+  end
+end

data/lib/twig/node/text.rb

@@ -3,6 +3,8 @@
 module Twig
   module Node
     class Text < Node::Base
+      include Output
+
       # @param [String] data
       # @param [Integer] lineno
       def initialize(data, lineno = 0)
@@ -11,7 +13,8 @@ module Twig
 
       def compile(compiler)
         compiler.
-          write('@output_buffer.safe_append = ').
+          add_debug_info(self).
+          write('context.output_buffer.safe_append = ').
           string(attributes[:data]).
           raw(";\n")
       end

data/lib/twig/node/with.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class With < Node::Base
+      # @param [Node::Base] body
+      # @param [Node::Base|nil] variables
+      # @param [Boolean] only
+      # @param [Integer] lineno
+      def initialize(body, variables, only, lineno)
+        nodes = { body: }
+        nodes[:variables] = variables unless variables.nil?
+
+        super(nodes, { only: }, lineno)
+      end
+
+      def compile(compiler)
+        compiler.
+          add_debug_info(self).
+          write("context.push_stack\n")
+
+        if nodes.key?(:variables)
+          if attributes[:only]
+            compiler.write("context.clear\n")
+          end
+
+          var_name = compiler.var_name
+
+          compiler.
+            write("#{var_name} = ").
+            subcompile(nodes[:variables]).
+            write("\n").
+            write("unless #{var_name}.is_a?(::Hash) || #{var_name} == []\n").
+            indent.
+            write("raise ::Twig::Error::Syntax.new('Variables passed to the \"with\" tag must be a mapping.',").
+            repr(nodes[:variables].lineno).
+            raw(", source_context)\n").
+            outdent.
+            write("end\n").
+            write("context.merge!(env.globals)\n").
+            write("context.merge!(#{var_name})\n")
+        end
+
+        compiler.
+          subcompile(nodes[:body]).
+          write("context.pop_stack\n")
+      end
+    end
+  end
+end

data/lib/twig/node/yield.rb

@@ -10,7 +10,8 @@ module Twig
 
       def compile(compiler)
         compiler.
-          write('@output_buffer.append = (').
+          add_debug_info(self).
+          write('context.output_buffer.append = (').
           subcompile(nodes[:expr]).
           raw(' do')
 
@@ -21,6 +22,8 @@ module Twig
 
         compiler.
           raw("\n").
+          indent.
+          write("context.buffer_and_return do\n").
           indent
 
         if attributes.key?(:arguments)
@@ -46,6 +49,8 @@ module Twig
         end
 
         compiler.
+          outdent.
+          write("end.to_s.html_safe\n").
           outdent.
           write("end);\n")
       end

data/lib/twig/node_traverser.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Twig
+  class NodeTraverser
+    def initialize(env, visitors = [])
+      @env = env
+      @visitors = {}
+
+      visitors.each { |visitor| add_visitor(visitor) }
+    end
+
+    # @param [NodeVisitor::Base]
+    def add_visitor(visitor)
+      @visitors[visitor.priority] ||= []
+      @visitors[visitor.priority] << visitor
+    end
+
+    # Traverses a node and calls the registered visitors.
+    # @param [Node::Base] node
+    def traverse(node)
+      @visitors = @visitors.sort.to_h
+
+      @visitors.each_value do |visitors|
+        visitors.each do |visitor|
+          node = traverse_for_visitor(visitor, node)
+        end
+      end
+
+      node
+    end
+
+    private
+
+    # @param [NodeVisitor::Base] visitor
+    # @param [Node::Base] node
+    def traverse_for_visitor(visitor, node)
+      node = visitor.enter_node(node, @env)
+
+      node.nodes.each do |k, n|
+        if (m = traverse_for_visitor(visitor, n)).nil?
+          node.nodes.delete(k)
+        elsif m != n
+          node.nodes[k] = m
+        end
+      end
+
+      visitor.leave_node(node, @env)
+    end
+  end
+end

data/lib/twig/node_visitor/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Twig
+  module NodeVisitor
+    class Base
+      # Called before child nodes are visited.
+      #
+      # @param [Node::Base] node
+      # @param [Environment] env
+      # @return [Node::Base] The modified node
+      def enter_node(node, env)
+        raise NotImplementedError, "Method #{__method__} must be implemented"
+      end
+
+      # Called after child nodes are visited.
+      #
+      # @param [Node::Base] node
+      # @param [Environment] env
+      # @return [Node::Base, nil] The modified node or nil if the node must be removed
+      def leave_node(node, env)
+        raise NotImplementedError, "Method #{__method__} must be implemented"
+      end
+
+      # @return [Integer] The priority level
+      def priority
+        0
+      end
+    end
+  end
+end