twig_ruby 0.0.1 → 0.0.2

data/lib/twig/node/expression/unary/not.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Unary
+        class Not < Unary::Base
+          def compile(compiler)
+            compiler.
+              raw('!::Twig::Extension::Core.bool(').
+              subcompile(nodes[:node]).
+              raw(')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/unary/spread.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Unary
+        class Spread < Unary::Base
+          def compile(compiler)
+            compiler.
+              raw('::Twig::Runtime::Spread.new(').
+              subcompile(nodes[:node]).
+              raw(')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/unary/string_cast.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Unary
+        class StringCast < Unary::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw('.to_s)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/variable/assign_template.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Variable
+        class AssignTemplate < Expression::Base
+          # @param [Variable::Template] var
+          # @param [Boolean] global
+          def initialize(var, global: true)
+            super({ var: }, { global: }, var.lineno)
+          end
+
+          def compile(compiler)
+            # @var [Template] var
+            var = nodes[:var]
+
+            compiler.
+              add_debug_info(self).
+              write('macros[').
+              string(var.name(compiler)).
+              raw('] = ')
+
+            if attributes[:global]
+              compiler.
+                raw('@macros[').
+                string(var.name(compiler)).
+                raw('] = ')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/variable/local.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Variable
+        class Local < Expression::Base
+          RESERVED_NAMES = %w[varargs context macros blocks self].freeze
+
+          # @param [String|Integer|nil]
+          def initialize(name, lineno)
+            if %w[true false none null nil].include?(name.to_s.downcase)
+              raise Error::Syntax.new("You cannot assign a value to \"#{name}\".", lineno)
+            end
+
+            # Convert to integer if name is an integer or consists of digits only
+            if !name.nil? && (name.is_a?(Integer) || name == name.to_i.to_s)
+              name = name.to_i
+            elsif RESERVED_NAMES.include?(name)
+              name = "\u035C#{name}"
+            end
+
+            super({}, { name: }, lineno)
+          end
+
+          def compile(compiler)
+            attributes[:name] = compiler.var_name if attributes[:name].nil?
+
+            compiler.raw(attributes[:name].to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/variable/template.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Variable
+        class Template < Expression::Base
+          RESERVED_NAMES = %w[varargs context macros blocks self].freeze
+
+          # @param [String, Integer, nil] name
+          # @param [Integer] lineno
+          def initialize(name, lineno)
+            if name && %w[true false none null nil].include?(name.to_s.downcase)
+              raise Error::Syntax.new("You cannot assign a value to \"#{name}\".", lineno)
+            end
+
+            # Convert to integer if name is an integer or consists of digits only
+            if !name.nil? && (name.is_a?(Integer) || name == name.to_i.to_s)
+              name = name.to_i
+            elsif RESERVED_NAMES.include?(name)
+              name = "\u035C#{name}"
+            end
+
+            super({}, { name: }, lineno)
+          end
+
+          # @param [Compiler] compiler
+          # @return [String]
+          def name(compiler)
+            if attributes[:name].nil?
+              attributes[:name] = compiler.var_name
+            end
+
+            attributes[:name]
+          end
+
+          # @param [Compiler] compiler
+          def compile(compiler)
+            name_value = name(compiler)
+
+            if name_value == '_self'
+              compiler.raw('self')
+            else
+              compiler.
+                raw('macros[').
+                string(name_value).
+                raw(']')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/for.rb

@@ -4,6 +4,10 @@ module Twig
   module Node
     class For < Node::Base
       def initialize(key_target, value_target, seq, if_expr, body, else_expr, lineno)
+        unless if_expr.nil?
+          body = If.new(Nodes.new(AutoHash.new.add(if_expr, body)), nil, lineno)
+        end
+
         loop = ForLoop.new(lineno)
         body = Nodes.new(AutoHash.new.add(body, loop))
 
@@ -22,27 +26,40 @@ module Twig
       end
 
       def compile(compiler)
+        iteration_var = compiler.var_name
+        function_var = compiler.var_name
+
         compiler.
-          write("context.push_stack\n").
-          write('context[:_seq] = ::Twig::Extension::Core.ensure_hash(').
+          add_debug_info(self).
+          write("#{iteration_var} = ::Twig::Runtime::LoopIterator.new(").
           subcompile(nodes[:seq]).
-          raw(")\n")
+          raw(")\n").
+          write("#{function_var} = lambda do |iterator, context, blocks, recurse, depth|\n").
+          indent.
+          write("parent = context.dup\n")
 
-        # @todo Missing some more loops stuff here
+        if attributes[:with_loop]
+          compiler.
+            write('context[:loop] = ::Twig::Runtime::LoopContext.new(').
+            raw("iterator, parent, blocks, recurse, depth)\n")
+        end
 
         if nodes.key?(:else_expr)
           compiler.write("context[:_iterated] = false\n")
         end
 
+        key_var = compiler.var_name
+        value_var = compiler.var_name
+
         compiler.
-          write("context[:_seq].each do |k, v|\n").
+          write("iterator.each do |#{key_var}, #{value_var}|\n").
           indent.
           write('').
           subcompile(nodes[:key_target]).
-          raw(" = k\n").
+          raw(" = #{key_var}\n").
           write('').
           subcompile(nodes[:value_target]).
-          raw(" = v\n\n").
+          raw(" = #{value_var}\n").
           subcompile(nodes[:body]).
           outdent.
           write("end\n")
@@ -57,7 +74,20 @@ module Twig
         end
 
         compiler.
-          write("context.pop_stack\n")
+          write("context.remove!(:#{nodes[:key_target].attributes[:name]}, ").
+          raw(":#{nodes[:value_target].attributes[:name]}")
+
+        if attributes[:with_loop]
+          compiler.raw(', :loop')
+        end
+
+        compiler.
+          raw(")\n").
+          write("context.keep!(parent.keys)\n").
+          write("context.merge!(parent, overwrite: false)\n").
+          outdent.
+          write("end\n").
+          write("#{function_var}.call(#{iteration_var}, context, blocks, #{function_var}, 0)\n")
       end
     end
   end

data/lib/twig/node/for_loop.rb

@@ -11,28 +11,6 @@ module Twig
         if attributes.key?(:else_expr)
           compiler.write("context[:_iterated] = true\n")
         end
-
-        # @todo if with loop
-        compiler.
-          write("context[:loop] = {\n").
-          write("  index0: 0,\n").
-          write("  index: 1,\n").
-          write("  first: true,\n").
-          write("}\n")
-
-        if attributes.key?(:with_loop)
-          compiler.
-            write("context[:loop][:index0] += 1\n").
-            write("context[:loop][:index] += 1\n").
-            write("context[:loop][:first] = false\n").
-            write("if context[:loop].key?(:revindex0) && context[:loop].key?(:revindex)\n").
-            indent.
-            write("context[:loop][:revindex0] -= 1\n").
-            write("context[:loop][:revindex] -= 1\n").
-            write("context[:loop][:last] = (context[:loop][:revindex0] == 0)\n").
-            outdent.
-            write("end\n")
-        end
       end
     end
   end

data/lib/twig/node/if.rb

@@ -11,6 +11,8 @@ module Twig
       end
 
       def compile(compiler)
+        compiler.add_debug_info(self)
+
         (0...nodes[:tests].nodes.length).step(2).each do |i|
           if i.zero?
             compiler.
@@ -23,8 +25,9 @@ module Twig
           end
 
           compiler.
+            raw('::Twig::Extension::Core.bool(').
             subcompile(nodes[:tests].nodes[i]).
-            raw(")\n").
+            raw("))\n").
             indent
 
           if nodes[:tests].nodes.key?(i + 1)

data/lib/twig/node/import.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Import < Node::Base
+      # @param [Expression::Base] expr
+      # @param [Expression::Base, Expression::Variable::AssignTemplate] var
+      # @param [Integer] lineno
+      def initialize(expr, var, lineno)
+        super({ expr:, var: }, {}, lineno)
+      end
+
+      # @param [Compiler] compiler
+      def compile(compiler)
+        compiler.subcompile(nodes[:var])
+
+        if nodes[:expr].is_a?(Expression::Variable::Context) && nodes[:expr].attributes[:name] == '_self'
+          compiler.raw('self')
+        else
+          compiler.
+            raw('load(').
+            subcompile(nodes[:expr]).
+            raw(', ').
+            repr(lineno).
+            raw(').unwrap')
+        end
+
+        compiler.raw("\n")
+      end
+    end
+  end
+end

data/lib/twig/node/include.rb

@@ -3,6 +3,8 @@
 module Twig
   module Node
     class Include < Node::Base
+      include Output
+
       # @param [Expression::Base] expr
       # @param [Expression::Base, nil] variables
       # @param [Boolean] only
@@ -19,9 +21,37 @@ module Twig
       end
 
       def compile(compiler)
+        compiler.add_debug_info(self)
+
         if attributes[:ignore_missing]
-          # @todo
-          raise 'not implemented yet'
+          template = compiler.var_name
+
+          compiler.
+            write("begin\n").
+            indent.
+            write("#{template} = ")
+
+          add_get_template(compiler, template)
+
+          compiler.
+            raw("\n").
+            outdent.
+            write("rescue ::Twig::Error::Loader => e\n").
+            indent.
+            write("# ignore missing template\n").
+            write("#{template} = nil\n").
+            outdent.
+            write("end\n").
+            write("if #{template}\n").
+            indent.
+            write("#{template}.render_with_blocks(")
+
+          add_template_arguments(compiler)
+
+          compiler.
+            raw(");\n").
+            outdent.
+            write("end\n")
         else
           compiler.
             write('')
@@ -41,13 +71,11 @@ module Twig
       private
 
       # @param [Compiler] compiler
-      def add_get_template(compiler)
+      def add_get_template(compiler, template = '')
         compiler.
-          raw('load_template(').
+          raw('load(').
           subcompile(nodes[:expr]).
           raw(', ').
-          repr(template_name).
-          raw(', ').
           repr(lineno).
           raw(')')
       end
@@ -55,7 +83,7 @@ module Twig
       # @param [Compiler] compiler
       def add_template_arguments(compiler)
         if !nodes.key?(:variables)
-          compiler.raw(attributes[:only] == false ? 'context' : '{}')
+          compiler.raw(attributes[:only] == false ? 'context' : 'context.only({})')
         elsif attributes[:only] == false
           compiler.
             raw('context.merge(').
@@ -63,7 +91,9 @@ module Twig
             raw(')')
         else
           compiler.
-            subcompile(nodes[:variables])
+            raw('context.only(').
+            subcompile(nodes[:variables]).
+            raw(')')
         end
       end
     end

data/lib/twig/node/macro.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    # Represents a macro node.
+    class Macro < Node::Base
+      VARARGS_NAME = 'varargs'
+
+      # @param [String] name
+      # @param [Body] body
+      # @param [Expression::Hash] arguments
+      # @param [Integer] lineno
+      def initialize(name, body, arguments, lineno)
+        arguments.key_value_pairs.each do |key, value|
+          next unless "\u035C#{VARARGS_NAME}" == key.attributes[:name]
+
+          raise Error::Syntax.new(
+            "The argument \"#{VARARGS_NAME}\" in macro \"#{name}\" cannot be defined because the variable " \
+            "\"#{VARARGS_NAME}\" is reserved for arbitrary arguments.",
+            value.lineno,
+            value.source_context
+          )
+        end
+
+        super({ body: body, arguments: arguments }, { name: name }, lineno)
+      end
+
+      # @param [Compiler] compiler
+      def compile(compiler)
+        compiler.
+          add_debug_info(self).
+          write("def macro_#{attributes[:name]}(call_context, ")
+
+        arguments = nodes[:arguments]
+        arguments.key_value_pairs.each do |key, value|
+          compiler.
+            subcompile(key).
+            raw(': ').
+            subcompile(value).
+            raw(', ')
+        end
+
+        compiler.
+          raw('**varargs').
+          raw(")\n").
+          write("  macros = @macros\n").
+          write("  context = ::Twig::Runtime::Context.new({\n")
+
+        arguments.key_value_pairs.each do |pair|
+          key = pair[0]
+          var = key.attributes[:name]
+          if var.start_with?("\u035C")
+            var = var[("\u035C".length)..]
+          end
+          compiler.
+            write('    ').
+            string(var).
+            raw(' => ').
+            subcompile(key).
+            raw(",\n")
+        end
+
+        capture_node = Node::Capture.new(nodes[:body], nodes[:body].lineno)
+
+        compiler.
+          write('    ').
+          string(VARARGS_NAME).
+          raw(' => ').
+          raw("varargs,\n").
+          write("  }.merge(env.globals), call_context:)\n\n").
+          write("  blocks = {}\n\n").
+          write('  ').
+          subcompile(capture_node).
+          raw("\n").
+          write("end\n\n")
+      end
+    end
+  end
+end