twig_ruby 0.0.1 → 0.0.2

data/lib/twig/node/expression/binary/concat.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class Concat < Binary::Base
+          def compile(compiler)
+            compiler.
+              raw('(').
+              subcompile(nodes[:left]).
+              raw(').to_s + (').
+              subcompile(nodes[:right]).
+              raw(').to_s')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/elvis.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class Elvis < Binary::Base
+          include OperatorEscape
+
+          def initialize(left, right, lineno)
+            super
+
+            nodes[:test] = left.dup
+            left.attributes[:always_defined] = true
+          end
+
+          def compile(compiler)
+            compiler.
+              raw('(::Twig::Extension::Core.bool(').
+              subcompile(nodes[:test]).
+              raw(') ? (').
+              subcompile(nodes[:left]).
+              raw(') : (').
+              subcompile(nodes[:right]).
+              raw('))')
+          end
+
+          def operand_names_to_escape
+            %i[left right]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/ends_with.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class EndsWith < Binary::Base
+          def compile(compiler)
+            left = compiler.var_name
+            right = compiler.var_name
+
+            compiler.
+              raw("(#{left} = ").
+              subcompile(nodes[:left]).
+              raw(').respond_to?(:end_with?) && ').
+              raw("(#{right} = ").
+              subcompile(nodes[:right]).
+              raw(").respond_to?(:end_with?) && (#{left}.end_with?(#{right}))")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/floor_div.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class FloorDiv < Binary::Base
+          def compile(compiler)
+            compiler.raw('(')
+            super
+            compiler.raw(').floor.to_i')
+          end
+
+          def operator(compiler)
+            compiler.raw('/')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/has_every.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class HasEvery < Binary::Base
+          def compile(compiler)
+            compiler.
+              raw('::Twig::Extension::Core.array_every?(').
+              subcompile(nodes[:left]).
+              raw(', ').
+              subcompile(nodes[:right]).
+              raw(')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/has_some.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class HasSome < Binary::Base
+          def compile(compiler)
+            compiler.
+              raw('::Twig::Extension::Core.array_some?(').
+              subcompile(nodes[:left]).
+              raw(', ').
+              subcompile(nodes[:right]).
+              raw(')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/in.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class In < Binary::Base
+          def compile(compiler)
+            compiler.
+              raw('::Twig::Extension::Core.in_filter(').
+              subcompile(nodes[:left]).
+              raw(', ').
+              subcompile(nodes[:right]).
+              raw(')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/matches.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class Matches < Binary::Base
+          def compile(compiler)
+            compiler.
+              raw('::Twig::Extension::Core.matches(').
+              subcompile(nodes[:right]).
+              raw(', ').
+              subcompile(nodes[:left]).
+              raw(')')
+          end
+
+          def operator(compiler)
+            compiler.raw('')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/not_in.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class NotIn < Binary::Base
+          def compile(compiler)
+            compiler.
+              raw('!::Twig::Extension::Core.in_filter(').
+              subcompile(nodes[:left]).
+              raw(', ').
+              subcompile(nodes[:right]).
+              raw(')')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/null_coalesce.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class NullCoalesce < Binary::Base
+          include OperatorEscape
+
+          def initialize(left, right, lineno)
+            super
+
+            test = Test::Defined.new(left.dup, TwigTest.new('defined'), Node::Empty.new, left.lineno)
+
+            unless left.is_a?(Expression::BlockReference)
+              test = Binary::And.new(
+                test,
+                Unary::Not.new(
+                  Test::Null.new(left, TwigTest.new('null'), Node::Empty.new, left.lineno),
+                  left.lineno
+                ),
+                left.lineno
+              )
+            end
+
+            left.attributes[:always_defined] = true
+            nodes[:test] = test
+          end
+
+          # @param [Compiler] compiler
+          def compile(compiler)
+            compiler.
+              raw('((').
+              subcompile(nodes[:test]).
+              raw(') ? (').
+              subcompile(nodes[:left]).
+              raw(') : (').
+              subcompile(nodes[:right]).
+              raw('))')
+          end
+
+          def operand_names_to_escape
+            %i[left right]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/or.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class Or < Boolean
+          def operator(compiler)
+            compiler.raw('||')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/starts_with.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class StartsWith < Binary::Base
+          def compile(compiler)
+            left = compiler.var_name
+            right = compiler.var_name
+
+            compiler.
+              raw("(#{left} = ").
+              subcompile(nodes[:left]).
+              raw(').respond_to?(:start_with?) && ').
+              raw("(#{right} = ").
+              subcompile(nodes[:right]).
+              raw(").respond_to?(:start_with?) && (#{left}.start_with?(#{right}))")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/binary/xor.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'boolean'
+
+module Twig
+  module Node
+    module Expression
+      module Binary
+        class Xor < Boolean
+          def operator(compiler)
+            compiler.raw('^')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      # Represents a block reference node
+      class BlockReference < Expression::Base
+        include SupportDefinedTest
+
+        # @param [String] name
+        # @param [String, nil] template
+        # @param [Integer] lineno
+        def initialize(name, template, lineno)
+          nodes = { name: }
+          nodes[:template] = template unless template.nil?
+
+          super(nodes, { output: false }, lineno)
+        end
+
+        def compile(compiler)
+          if define_test_enabled?
+            compile_template_call(compiler, 'block?')
+          else
+            compile_template_call(compiler, 'render_block')
+          end
+        end
+
+        private
+
+        def compile_template_call(compiler, method)
+          if nodes.key?(:template)
+            compiler.
+              write('load(').
+              subcompile(nodes[:template]).
+              raw(', ').
+              repr(lineno).
+              raw(').unwrap')
+          else
+            compiler.write('self')
+          end
+
+          compiler.raw(".#{method}")
+
+          compile_block_arguments(compiler)
+        end
+
+        def compile_block_arguments(compiler)
+          compiler.
+            raw('(').
+            subcompile(nodes[:name]).
+            raw(', context')
+
+          unless nodes.key?(:template)
+            compiler.raw(', blocks')
+          end
+
+          compiler.raw(')')
+        end
+      end
+    end
+  end
+end

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

@@ -4,23 +4,143 @@ module Twig
   module Node
     module Expression
       class Call < Expression::Base
+        def compile(compiler)
+          compile_callable(compiler)
+        end
+
         private
 
         # @param [Compiler] compiler
         def compile_callable(compiler)
-          callable = attributes[:twig_callable].callable
+          argument_nodes = [nodes.key?(:node) ? nodes[:node] : nil, *nodes[:arguments].nodes.values]
+          has_spread = argument_nodes.any? { |node| node.is_a?(Unary::Spread) }
+
+          if has_spread
+            compiler.
+              raw('::Twig::Runtime::ArgumentSpreader.new(').
+              raw(callable_method).
+              raw(').call')
+          else
+            compiler.
+              raw(callable_method).
+              raw('.call')
+          end
 
           compiler.
-            raw("env.extension(%q[#{callable[0].class.name}]).#{callable[1]}")
+            raw("(\n").
+            indent.
+            write('')
 
           compile_arguments(compiler)
+
+          compiler.
+            raw("\n").
+            outdent.
+            write(')')
+        end
+
+        # @return [String]
+        def callable_method
+          # @type [Twig::Callable] callable
+          twig_callable = attributes[:twig_callable]
+          callable = twig_callable.callable
+
+          case callable
+          when ::Array
+            if callable[0] == :runtime
+              _, klass, method = callable
+
+              "env.runtime(%q[#{klass}]).method(:#{method})"
+            else
+              extension, method = callable[0, 2]
+              extension = extension.class.name if extension.is_a?(Extension::Base)
+
+              "env.extension(%q[#{extension.delete_prefix('::')}]).method(:#{method})"
+            end
+          when ::Method
+            # Instance method
+            if callable.receiver.is_a?(Extension::Base)
+              "env.extension(%q[#{callable.owner.name}]).method(:#{callable.name})"
+              # Class method
+            else
+              "#{callable.receiver.name}.method(:#{callable.name})"
+            end
+          when ::Proc
+            "env.#{attributes[:type]}(%q[#{twig_callable.dynamic_name}]).callable"
+          else
+            raise "Callable not supported: #{callable.inspect}"
+          end
         end
 
         def compile_arguments(compiler)
-          compiler.
-            raw('(').
-            subcompile(nodes[:node]).
-            raw(')')
+          first = true
+          # @type [Twig::Callable] callable
+          callable = attributes.fetch(:twig_callable, nil)
+
+          callable&.arguments&.each do |argument|
+            compiler.raw(', ') unless first
+
+            compiler.string(argument)
+
+            first = false
+          end
+
+          if callable&.needs_charset?
+            compiler.raw(', ') unless first
+            compiler.raw('env.charset')
+            first = false
+          end
+
+          if callable&.needs_environment?
+            compiler.raw(', ') unless first
+            compiler.raw('env')
+            first = false
+          end
+
+          if callable&.needs_context?
+            compiler.raw(', ') unless first
+            compiler.raw('context')
+            first = false
+          end
+
+          if nodes.key?(:node)
+            compiler.raw(', ') unless first
+
+            compiler.
+              subcompile(nodes[:node])
+
+            first = false
+          end
+
+          # Only callables that come through without are helper methods, which still
+          # can't be determined at compile time for Rails
+          if callable
+            positional, kwargs = Util::CallableArgumentsExtractor.
+              new(self, callable, compiler.environment).
+              extract_arguments(nodes[:arguments])
+          else
+            positional, kwargs = nodes[:arguments].nodes.partition do |key, node|
+              key.is_a?(Integer) || node.is_a?(Unary::Spread)
+            end.map(&:to_h)
+
+            positional = positional.values
+          end
+
+          positional.each do |node|
+            compiler.raw(', ') unless first
+            compiler.subcompile(node)
+
+            first = false
+          end
+
+          kwargs.each do |key, node|
+            compiler.raw(', ') unless first
+            compiler.
+              raw("'#{key}': ").
+              subcompile(node)
+
+            first = false
+          end
         end
       end
     end

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

@@ -4,12 +4,14 @@ module Twig
   module Node
     module Expression
       class Constant < Expression::Base
+        include Expression::SupportDefinedTest
+
         def initialize(value, lineno)
           super({}, { value: }, lineno)
         end
 
         def compile(compiler)
-          compiler.repr(attributes[:value])
+          compiler.repr(define_test_enabled? || attributes[:value])
         end
       end
     end

data/lib/twig/node/expression/filter/default.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Filter
+        # Returns the value or the default value when it is undefined or empty.
+        #
+        # {{ var.foo|default('foo item on var is not defined') }}
+        class Default < Expression::Filter
+          # @param [Expression::Base] node
+          # @param [TwigFilter] filter
+          # @param [Node::Base] arguments
+          # @param [Integer] lineno
+          def initialize(node, filter, arguments, lineno)
+            name = filter.name
+            default = Expression::Filter.new(node, filter, arguments, node.lineno)
+
+            if name == 'default' && (node.is_a?(Variable::Context) || node.is_a?(GetAttribute))
+              test = Test::Defined.new(node.dup, TwigTest.new('defined'), Empty.new, node.lineno)
+              false_case = arguments.empty? ? Expression::Constant.new('', node.lineno) : arguments.nodes[0]
+              node = Ternary.new(test, default, false_case, node.lineno)
+            else
+              node = default
+            end
+
+            super
+          end
+
+          def compile(compiler)
+            compiler.subcompile(nodes[:node])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twig/node/expression/filter/raw.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Filter
+        class Raw < Expression::Filter
+          # @param [Expression::Base] node
+          # @param [TwigFilter|nil] filter
+          # @param [Node::Base|nil] arguments
+          # @param [Integer] lineno
+          def initialize(node, filter = nil, arguments = nil, lineno = nil)
+            super(
+              node,
+              filter || TwigFilter.new('raw', nil, { is_safe: [:all] }),
+              arguments || Node::Empty.new,
+              lineno || node.lineno
+            )
+          end
+
+          def compile(compiler)
+            compiler.
+              raw('((tmp = ').
+              subcompile(nodes[:node]).
+              raw(').respond_to?(:html_safe) ? tmp.html_safe : tmp)')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,10 +21,10 @@ module Twig
             arguments:,
           }, {
             name:,
-            type: 'filter',
+            type: :filter,
           }, lineno)
 
-          if filter.is_a?(Filter)
+          if filter.is_a?(TwigFilter)
             attributes[:twig_callable] = filter
           end
         end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    module Expression
+      class Function < Call
+        include SupportDefinedTest
+
+        # @param [TwigFunction] function
+        # @param [Node::Base] arguments
+        # @param [Integer] lineno
+        def initialize(function, arguments, lineno)
+          super({ arguments: }, {
+            name: function.name,
+            type: :function,
+            twig_callable: function,
+            is_defined_test: false,
+          }, lineno)
+        end
+
+        def enable_defined_test
+          if attributes[:name] == 'constant'
+            super
+          end
+        end
+
+        def compile(compiler)
+          if attributes[:name] == 'constant' && define_test_enabled?
+            nodes[:arguments].nodes[:defined_test] = Expression::Constant.new(true, lineno)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end