twig_ruby 0.0.1 → 0.0.2

data/lib/twig/node/expression/get_attribute.rb

@@ -4,25 +4,69 @@ module Twig
   module Node
     module Expression
       class GetAttribute < Expression::Base
+        include SupportDefinedTest
+
         def initialize(node, attribute, arguments, type, lineno)
           nodes = { node:, attribute: }
           nodes[:arguments] = arguments if arguments
 
-          super(nodes, { type: }, lineno)
+          super(nodes, { type:, ignore_strict_check: false }, lineno)
+        end
+
+        def enable_defined_test
+          super
+          change_ignore_strict_check(self)
         end
 
         def compile(compiler)
-          var = compiler.var_name
+          compiler.
+            raw('::Twig::Extension::Core.get_attribute(env, source_context, ')
+
+          if attributes[:ignore_strict_check]
+            nodes[:node].attributes[:ignore_strict_check] = true
+          end
 
           compiler.
-            raw("(#{var} = ").
             subcompile(nodes[:node]).
-            raw("\n").
-            write("::Twig::Extension::Core.get_attribute(#{var}, ").
+            raw(', ').
             subcompile(nodes[:attribute]).
             raw(', ').
-            repr(attributes[:type]).
-            raw('))')
+            repr(attributes[:type])
+
+          if nodes.key?(:arguments)
+            compiler.
+              raw(', arguments: ').
+              subcompile(nodes[:arguments])
+          end
+
+          if define_test_enabled?
+            compiler.
+              raw(', defined_test: true')
+          end
+
+          if attributes[:ignore_strict_check]
+            compiler.
+              raw(', ignore_strict_check: true')
+          end
+
+          compiler.
+            raw(', lineno: ').
+            repr(lineno).
+            raw(')')
+        end
+
+        private
+
+        # @param [GetAttribute] node]
+        def change_ignore_strict_check(node)
+          node.attributes[:optimizable] = false
+          node.attributes[:ignore_strict_check] = true
+
+          object_node = node.nodes[:node]
+
+          if object_node.is_a?(GetAttribute)
+            change_ignore_strict_check(object_node)
+          end
         end
       end
     end

data/lib/twig/node/expression/hash.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Hash < Expression::Base
+        include Expression::SupportDefinedTest
+
+        def initialize(elements, lineno)
+          super(elements, {}, lineno)
+
+          @index = -1
+        end
+
+        # @param [Expression::Base] value
+        # @param [Expression::Base|nil] key
+        def add_element(value, key = nil)
+          if key.nil?
+            @index += 1
+            key = Constant.new(@index, value.lineno)
+          end
+
+          nodes.add(key, value)
+        end
+
+        def compile(compiler)
+          if define_test_enabled?
+            return compiler.repr(true)
+          end
+
+          compiler.
+            raw('{').
+            indent
+
+          first = true
+
+          key_value_pairs.each do |key, value|
+            unless first
+              compiler.raw(', ')
+            end
+
+            first = false
+
+            unless value.is_a?(Expression::Unary::HashSpread)
+              case key
+              when Variable::Context
+                key = Unary::StringCast.new(key, key.lineno)
+              when Variable::Local
+                key_value = key.attributes[:name]
+                key = Constant.new(key_value, key.lineno)
+              when Constant
+                key.attributes[:value]
+              end
+
+              compiler.
+                subcompile(key).
+                raw(' => ')
+            end
+
+            compiler.
+              subcompile(value)
+          end
+
+          compiler.
+            outdent.
+            raw('}')
+        end
+
+        def key_value_pairs
+          nodes.each_value.each_slice(2)
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/helper_method.rb

@@ -3,27 +3,15 @@
 module Twig
   module Node
     module Expression
-      class HelperMethod < Expression::Base
-        def initialize(name, args, lineno)
-          super({ args: }, { name: }, lineno)
+      class HelperMethod < Call
+        def initialize(name, arguments, lineno)
+          super({ arguments: }, { name: }, lineno)
         end
 
-        def compile(compiler)
-          compiler.
-            raw("@call_context.#{attributes[:name]}(")
+        private
 
-          nodes[:args].nodes.each do |key, value|
-            unless key.is_a?(Integer)
-              compiler.raw("#{key}: ")
-            end
-
-            compiler.
-              subcompile(value).
-              raw(',')
-          end
-
-          compiler.
-            raw(')')
+        def callable_method
+          "context.call_context.method(:#{attributes[:name]})"
         end
       end
     end

data/lib/twig/node/expression/macro_reference.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      # Represents a macro call node.
+      class MacroReference < Expression::Base
+        include SupportDefinedTest
+
+        # @param [Variable::Template] template
+        # @param [String] name
+        # @param [Expression::Base] arguments
+        # @param [Integer] lineno
+        def initialize(template, name, arguments, lineno)
+          super({ template:, arguments: }, { name: }, lineno)
+        end
+
+        # @param [Compiler] compiler
+        def compile(compiler)
+          if define_test_enabled?
+            compiler.
+              subcompile(nodes[:template]).
+              raw('.macro?(').
+              repr(attributes[:name]).
+              raw(', context').
+              raw(')')
+            return
+          end
+
+          compiler.
+            subcompile(nodes[:template]).
+            raw('.render_macro(').
+            repr(attributes[:name]).
+            raw(', context, ').
+            subcompile(nodes[:arguments]).
+            raw(', ').
+            repr(lineno).
+            raw(', source_context)')
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/name.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'support_defined_test'
+
 module Twig
   module Node
     module Expression
       class Name < Expression::Base
+        include Expression::SupportDefinedTest
+
         SPECIAL_VARS = {
-          '_self' => 'get_template_name',
+          '_self' => 'template_name',
           '_context' => 'context',
           '_charset' => 'env.charset',
         }.freeze
@@ -17,19 +21,49 @@ module Twig
             name:,
             is_defined_test: false,
             ignore_strict_check: false,
-            alwways_defined: false,
+            always_defined: false,
           }, lineno)
         end
 
         def compile(compiler)
           name = attributes[:name]
 
-          compiler.
-            raw("(context.key?(:#{name})").
-            raw(" ? context[:#{name}]").
-            raw(' : raise("#{').
-            string(name).
-            raw('} does not exist"))')
+          compiler.add_debug_info(self)
+
+          if attributes[:name][0] == '@'
+            check = "context.call_context.instance_variable_defined?('#{name}')"
+            get = "context.call_context.instance_variable_get('#{name}')"
+          else
+            check = "context.key?(:#{name})"
+            get = "context[:#{name}]"
+          end
+
+          if define_test_enabled?
+            if attributes[:always_defined] || SPECIAL_VARS.key?(name)
+              compiler.repr(true)
+            else
+              compiler.raw(check)
+            end
+          elsif SPECIAL_VARS.key?(name)
+            compiler.raw(SPECIAL_VARS[name])
+          elsif attributes[:always_defined]
+            compiler.
+              raw(get)
+          elsif attributes[:ignore_strict_check] || !compiler.environment.strict_variables?
+            compiler.
+              raw('(').
+              raw(get).
+              raw(' || nil)')
+          else
+            compiler.
+              raw("(#{check}").
+              raw(" ? #{get}").
+              raw(' : raise(::Twig::Error::Runtime.new("Variable \"#{').
+              string(name).
+              raw('}\" does not exist.", ').
+              repr(lineno).
+              raw(', source_context)))')
+          end
         end
       end
     end

data/lib/twig/node/expression/operator_escape.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module OperatorEscape
+        def operand_names_to_escape
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/parent.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      # Represents a parent node
+      class Parent < Expression::Base
+        # @param [String] name
+        # @param [Integer] lineno
+        def initialize(name, lineno)
+          super({}, { output: false, name: }, lineno)
+        end
+
+        def compile(compiler)
+          if attributes[:output]
+            compiler.add_debug_info(self)
+            raise NotImplementedError
+          else
+            compiler.
+              raw('render_parent_block(').
+              string(attributes[:name]).
+              raw(', context, blocks)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/support_defined_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module SupportDefinedTest
+        def enable_defined_test
+          self.defined_test = true
+        end
+
+        def define_test_enabled?
+          defined_test
+        end
+
+        private
+
+        # @param [Boolean] defined_test
+        # @return [Boolean]
+        attr_accessor :defined_test
+      end
+    end
+  end
+end

data/lib/twig/node/expression/ternary.rb

@@ -4,6 +4,8 @@ module Twig
   module Node
     module Expression
       class Ternary < Expression::Base
+        include OperatorEscape
+
         def initialize(test, left, right, lineno)
           super({
             test:,
@@ -14,7 +16,7 @@ module Twig
 
         def compile(compiler)
           compiler.
-            raw('((').
+            raw('(::Twig::Extension::Core.bool(').
             subcompile(nodes[:test]).
             raw(') ? (').
             subcompile(nodes[:left]).
@@ -22,6 +24,10 @@ module Twig
             subcompile(nodes[:right]).
             raw('))')
         end
+
+        def operand_names_to_escape
+          %i[left right]
+        end
       end
     end
   end

data/lib/twig/node/expression/test/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        class Base < Call
+          # @param [Node::Expression::Base] node
+          # @param [TwigTest] test
+          # @param [Node::Base] arguments
+          # @param [Integer] lineno
+          def initialize(node, test, arguments, lineno)
+            super({
+              node:,
+              arguments: arguments || Node::Empty.new,
+            }, {
+              name: test.name,
+              type: :test,
+              twig_callable: test,
+            }, lineno)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/constant.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if a variable is the exact same value as a constant.
+        #
+        #    {% if post.status is constant('Post::PUBLISHED') %}
+        #      the status attribute is exactly the same as Post::PUBLISHED
+        #    {% endif %}
+        #
+        class Constant < Test::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw(' == ::Twig::Extension::Core.constant(')
+
+            compiler.
+              subcompile(nodes[:arguments].nodes[0])
+
+            if nodes[:arguments].nodes.key?(1)
+              compiler.
+                raw(', ').
+                subcompile(nodes[:arguments].nodes[1])
+            end
+
+            compiler.raw('))')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/defined.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if an expression is defined
+        #
+        #  {{ var is defined }}
+        class Defined < Test::Base
+          # @param [Node::Expression::Base] node
+          # @param [TwigTest] name
+          # @param [Node::Base] arguments
+          # @param [Integer] lineno
+          def initialize(node, name, arguments, lineno)
+            unless node.is_a?(SupportDefinedTest)
+              raise Error::Syntax.new('The "defined" test only works with simple variables.', lineno)
+            end
+
+            node.enable_defined_test
+
+            super
+          end
+
+          def compile(compiler)
+            compiler.
+              subcompile(nodes[:node])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/divisible_by.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if a number is divisible by another.
+        #
+        #  {{ var is divisible by(3) }}
+        class DivisibleBy < Test::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw(' % ').
+              subcompile(nodes[:arguments].nodes[0]).
+              raw(' == 0)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/even.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if a number is even.
+        #
+        #  {{ var is even }}
+        class Even < Test::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw(' % 2 == 0)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/iterable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if a variable is iterable
+        #
+        #  {{ var is iterable }}
+        class Iterable < Test::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw(').respond_to?(:each)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/mapping.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if a variable is a mapping (Hash)
+        #
+        #  {{ var is mapping }}
+        class Mapping < Test::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw(').is_a?(Hash)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/null.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if a variable is null.
+        #
+        #  {{ var is null }}
+        class Null < Test::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw(' == nil)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/odd.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if a number is odd.
+        #
+        #  {{ var is odd }}
+        class Odd < Test::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw(' % 2 != 0)')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/same_as.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if a variable is the same as another.
+        #
+        #  {{ var is same as(other) }}
+        class SameAs < Test::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw(' == ').
+              subcompile(nodes[:arguments].nodes[0]).
+              raw(')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/test/sequence.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Test
+        # Checks if a variable is a sequence (array)
+        #
+        #  {{ var is sequence }}
+        class Sequence < Test::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:node]).
+              raw(').is_a?(Array)')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -33,9 +33,11 @@ module Twig
         end
 
         OPERATORS = {
-          Not: '!',
           Neg: '-',
           Pos: '+',
+          Spread: '(not rendered)',
+          ArraySpread: '*',
+          HashSpread: '**',
         }.freeze
 
         # Lots of simple operator classes can just be generated dynamically