twig_ruby 0.0.1 → 0.0.3

data/lib/twig/token_parser/macro.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    # Defines a macro.
+    #
+    # {% macro input(name, value, type, size) %}
+    #  <input type="{{ type|default('text') }}" name="{{ name }}" value="{{ value|e }}" size="{{ size|default(20) }}" />
+    # {% endmacro %}
+    #
+    class Macro < Base
+      def parse(token)
+        lineno = token.lineno
+        stream = parser.stream
+        name = stream.expect(Token::NAME_TYPE).value
+        arguments = parse_definition
+
+        stream.expect(Token::BLOCK_END_TYPE)
+        parser.push_local_scope
+        body = parser.subparse(method(:decide_block_end), drop_needle: true)
+
+        if (token = stream.next_if(Token::NAME_TYPE))
+          value = token.value
+
+          if value != name
+            raise Error::Syntax.new(
+              "Expected endmacro for macro \"#{name}\" (but \"#{value}\" given).",
+              stream.current.lineno,
+              stream.source_context
+            )
+          end
+        end
+
+        parser.pop_local_scope
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        parser.set_macro(name, Node::Macro.new(name, Node::Body.new({ 0 => body }), arguments, lineno))
+
+        Node::Empty.new(lineno)
+      end
+
+      def decide_block_end(token)
+        token.test('endmacro')
+      end
+
+      def tag
+        'macro'
+      end
+
+      private
+
+      def parse_definition
+        arguments = Node::Expression::Hash.new({}, parser.current_token.lineno)
+        stream = parser.stream
+        stream.expect(Token::OPERATOR_TYPE, '(', 'A list of arguments must begin with an opening parenthesis')
+
+        until stream.test(Token::PUNCTUATION_TYPE, ')')
+          unless arguments.empty?
+            stream.expect(Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma')
+
+            # if the comma above was a trailing comma, early exit the argument parse loop
+            break if stream.test(Token::PUNCTUATION_TYPE, ')')
+          end
+
+          token = stream.expect(Token::NAME_TYPE, nil, 'An argument must be a name')
+          name = Node::Expression::Variable::Local.new(token.value, parser.current_token.lineno)
+
+          if (token = stream.next_if(Token::OPERATOR_TYPE, '=')) ||
+             (token = stream.next_if(Token::PUNCTUATION_TYPE, ':'))
+            default = parser.parse_expression
+          else
+            default = Node::Expression::Constant.new(nil, parser.current_token.lineno)
+            default.attributes[:is_implicit] = true
+          end
+
+          unless check_constant_expression(default)
+            raise Error::Syntax.new(
+              'A default value for an argument must be a constant (a boolean, a string, a number, ' \
+              'a sequence, or a mapping).',
+              token.lineno,
+              stream.source
+            )
+          end
+
+          arguments.add_element(default, name)
+        end
+
+        stream.expect(Token::PUNCTUATION_TYPE, ')', 'A list of arguments must be closed by a parenthesis')
+
+        arguments
+      end
+
+      # checks that the node only contains "constant" elements
+      def check_constant_expression(node)
+        return false unless node.is_a?(Node::Expression::Constant) ||
+                            node.is_a?(Node::Expression::Array) ||
+                            node.is_a?(Node::Expression::Hash) ||
+                            node.is_a?(Node::Expression::Unary::Neg) ||
+                            node.is_a?(Node::Expression::Unary::Pos)
+
+        node.nodes.each_value do |n|
+          return false unless check_constant_expression(n)
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/twig/token_parser/set.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    # Defines a variable.
+    #
+    #  {% set foo = 'foo' %}
+    #  {% set foo = [1, 2] %}
+    #  {% set foo = {'foo': 'bar'} %}
+    #  {% set foo = 'foo' ~ 'bar' %}
+    #  {% set foo, bar = 'foo', 'bar' %}
+    #  {% set foo %}Some content{% endset %}
+    class Set < Base
+      def parse(token)
+        lineno = token.lineno
+        stream = parser.stream
+        names = parse_assignment_expression
+        capture = false
+
+        if stream.next_if(Token::OPERATOR_TYPE, '=')
+          values = parse_multi_target_expression
+
+          stream.expect(Token::BLOCK_END_TYPE)
+
+          if names.length != values.length
+            raise Error::Syntax.new(
+              'When using set, you must have the same number of variables and assignments',
+              stream.current.lineno,
+              stream.source
+            )
+          end
+        else
+          capture = true
+
+          if names.length > 1
+            raise Error::Syntax.new(
+              'When using set with a block, you cannot have a multi-target',
+              stream.current.lineno,
+              stream.source
+            )
+          end
+
+          stream.expect(Token::BLOCK_END_TYPE)
+          values = parser.subparse(method(:decide_block_end), drop_needle: true)
+          stream.expect(Token::BLOCK_END_TYPE)
+        end
+
+        Node::Set.new(capture, names, values, lineno)
+      end
+
+      def tag
+        'set'
+      end
+
+      private
+
+      def decide_block_end(token)
+        token.test('endset')
+      end
+
+      def parse_multi_target_expression
+        targets = AutoHash.new
+
+        loop do
+          targets << parser.parse_expression
+
+          unless parser.stream.next_if(Token::PUNCTUATION_TYPE, ',')
+            break
+          end
+        end
+
+        Node::Nodes.new(targets)
+      end
+    end
+  end
+end

data/lib/twig/token_parser/use.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    # Imports blocks defined in another template into the current template.
+    #
+    # {% extends "base.html" %}
+    # {% use "blocks.html" %}
+    #
+    # {% block title %}{% endblock %}
+    class Use < Base
+      def parse(token)
+        template = parser.parse_expression
+        stream = parser.stream
+
+        unless template.is_a?(Node::Expression::Constant)
+          raise Error::Syntax.new(
+            'The template references in a "use" statement must be a string.',
+            stream.current.lineno,
+            stream.source
+          )
+        end
+
+        targets = {}
+
+        if stream.next_if('with')
+          loop do
+            aliased = name = stream.expect(Token::NAME_TYPE).value
+
+            if stream.next_if('as')
+              aliased = stream.expect(Token::NAME_TYPE).value
+            end
+
+            targets[name] = Node::Expression::Constant.new(aliased, -1)
+
+            unless stream.next_if(Token::PUNCTUATION_TYPE, ',')
+              break
+            end
+          end
+        end
+
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        parser.add_trait(Node::Nodes.new({ template:, targets: Node::Nodes.new(targets) }))
+
+        Node::Empty.new(token.lineno)
+      end
+
+      def tag
+        'use'
+      end
+    end
+  end
+end

data/lib/twig/token_parser/with.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    # Creates a nested scope
+    class With < Base
+      def parse(token)
+        stream = parser.stream
+
+        variables = nil
+        only = false
+
+        unless stream.test(Token::BLOCK_END_TYPE)
+          variables = parser.parse_expression
+          only = !stream.next_if(Token::NAME_TYPE, 'only').nil?
+        end
+
+        stream.expect(Token::BLOCK_END_TYPE)
+        body = parser.subparse(method(:decide_with_end), drop_needle: true)
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        Node::With.new(body, variables, only, token.lineno)
+      end
+
+      def tag
+        'with'
+      end
+
+      private
+
+      def decide_with_end(token)
+        token.test('endwith')
+      end
+    end
+  end
+end

data/lib/twig/token_parser/yield.rb

@@ -6,13 +6,13 @@ module Twig
       def parse(token)
         stream = parser.stream
         lineno = token.lineno
-        expr = parser.expression_parser.parse_expression
+        expr = parser.parse_expression
         arguments = []
 
         stream.expect(Token::NAME_TYPE, 'do')
 
-        if stream.next_if(Token::PUNCTUATION_TYPE, '|')
-          until stream.test(Token::PUNCTUATION_TYPE, '|')
+        if stream.next_if(Token::OPERATOR_TYPE, '|')
+          until stream.test(Token::OPERATOR_TYPE, '|')
             unless arguments.empty?
               stream.expect(Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma')
             end
@@ -20,11 +20,11 @@ module Twig
             arguments.push(stream.expect(Token::NAME_TYPE).value)
           end
 
-          stream.expect(Token::PUNCTUATION_TYPE, '|')
+          stream.expect(Token::OPERATOR_TYPE, '|')
         end
 
         stream.expect(Token::BLOCK_END_TYPE)
-        body = parser.subparse(decide_yield_end, drop_needle: true)
+        body = parser.subparse(method(:decide_yield_end), drop_needle: true)
         stream.expect(Token::BLOCK_END_TYPE)
 
         Node::Yield.new(expr, body, arguments, lineno)
@@ -36,8 +36,8 @@ module Twig
 
       private
 
-      def decide_yield_end
-        ->(token) { token.test('endyield') }
+      def decide_yield_end(token)
+        token.test('endyield')
       end
     end
   end

data/lib/twig/token_stream.rb

@@ -39,8 +39,14 @@ module Twig
       token = current
 
       unless token.test(type, value)
+        expected = Token.type_to_english(type)
+        unexpected = Token.type_to_english(token.type)
+        token_value = token.value.empty? ? '' : " of value \"#{token.value}\""
+        value = " with value \"#{value}\"" if value
+        message = "#{message} " if message
+
         raise Error::Syntax.new(
-          "Expected #{type}(#{value}) but got #{token.type}(#{token.value}) #{message}".rstrip,
+          "#{message}Unexpected token \"#{unexpected}\"#{token_value} (\"#{expected}\" expected#{value}).",
           token.lineno,
           source
         )
@@ -51,6 +57,16 @@ module Twig
       token
     end
 
+    # @param [Integer] number
+    # @return [Token]
+    def look(number = 1)
+      unless tokens.length >= @current + number
+        raise Error::Syntax.new('Unexpected end of template.', tokens[@current].lineno, source)
+      end
+
+      tokens[@current + number]
+    end
+
     def test(primary, secondary = nil)
       current.test(primary, secondary)
     end
@@ -66,8 +82,12 @@ module Twig
     def debug
       tokens.
         map(&:debug).
-        map { |type, value| "#{type}(#{value})" }.
-        join("\n")
+        map { |type, value| "#{type}(#{value})" }
+    end
+
+    # @param [Array<Token>] tokens
+    def inject(tokens)
+      @tokens.insert(@current, *tokens)
     end
   end
 end

data/lib/twig/twig_filter.rb

@@ -14,6 +14,26 @@ module Twig
       }.merge(@options)
     end
 
+    # @param [Node::Base] filter_args
+    def safe(filter_args)
+      return @options[:is_safe] unless @options[:is_safe].nil?
+      return @options[:is_safe_callback].call(filter_args) unless @options[:is_safe_callback].nil?
+
+      []
+    end
+
+    def preserves_safety
+      @options[:preserves_safety] || []
+    end
+
+    def pre_escape
+      @options[:pre_escape]
+    end
+
+    def type
+      :filter
+    end
+
     def node_class
       @options[:node_class]
     end

data/lib/twig/twig_function.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Twig
+  class TwigFunction < Callable
+    def initialize(name, callable = nil, options = {})
+      super
+
+      @options = {
+        is_safe: nil,
+        is_safe_callback: nil,
+        node_class: Node::Expression::Function,
+        parser_callable: nil,
+      }.merge(@options)
+    end
+
+    # @param [Node::Base] function_args
+    def safe(function_args)
+      return @options[:is_safe] unless @options[:is_safe].nil?
+      return @options[:is_safe_callback].call(function_args) unless @options[:is_safe_callback].nil?
+
+      []
+    end
+
+    def type
+      :function
+    end
+
+    # @return [Proc|nil]
+    def parser_callable
+      @options[:parser_callable]
+    end
+
+    def node_class
+      @options[:node_class]
+    end
+  end
+end

data/lib/twig/twig_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Twig
+  class TwigTest < Callable
+    def initialize(name, callable = nil, options = {})
+      super
+
+      @options = {
+        node_class: Node::Expression::Test::Base,
+        one_mandatory_argument: false,
+      }.merge(@options)
+    end
+
+    def type
+      :test
+    end
+
+    def node_class
+      @options[:node_class]
+    end
+
+    # @return [Boolean]
+    def one_mandatory_argument?
+      @options[:one_mandatory_argument]
+    end
+
+    def needs_context?
+      false
+    end
+  end
+end

data/lib/twig/util/callable_arguments_extractor.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Twig
+  module Util
+    class CallableArgumentsExtractor
+      # @param [Node::Expression::Call] node
+      # @param [Callable] twig_callable
+      # @param [Environment] environment
+      def initialize(node, twig_callable, environment)
+        @node = node
+        @twig_callable = twig_callable
+        @environment = environment
+      end
+
+      # @param [Node::Nodes] arguments
+      def extract_arguments(arguments)
+        # Check argument order first
+        found_named = false
+        arguments.nodes.each_key do |key|
+          if key.is_a?(Integer)
+            if found_named
+              raise Error::Syntax.new(
+                "Positional arguments cannot be used after named arguments for #{@twig_callable.type} " \
+                "\"#{@twig_callable.name}\".",
+                @node.lineno,
+                @node.source_context
+              )
+            end
+          else
+            found_named = true
+          end
+        end
+
+        called_arguments = destination_arguments.keys.to_h { |k| [k, false] }
+
+        spreads, arguments = arguments.nodes.partition do |_, node|
+          node.is_a?(Node::Expression::Unary::Spread)
+        end.map(&:to_h)
+
+        positional, kwargs = arguments.partition do |key, _node|
+          key.is_a?(Integer)
+        end.map(&:to_h)
+
+        positional = positional.values
+        positional_count = positional.length
+
+        kwargs.transform_keys!(&:to_sym)
+        resolved_positional = []
+        resolved_kwargs = {}
+        rest = false
+        keyrest = false
+
+        destination_arguments.each do |name, type|
+          if positional.any?
+            case type
+            when :req, :opt
+              resolved_positional << positional.shift
+            when :keyreq, :key
+              arg = positional.shift
+
+              if arg.is_a?(Node::Expression::Unary::HashSpread)
+                keyrest = true
+                resolved_positional << arg
+              else
+                resolved_kwargs[name] = arg
+              end
+            when :rest
+              resolved_positional += positional
+              positional = []
+              rest = true
+              next
+            when :keyrest
+              arg = positional.shift
+
+              if arg.is_a?(Node::Expression::Unary::HashSpread)
+                keyrest = true
+                resolved_positional << arg
+              else
+                raise Error::Syntax.new(
+                  "Expected a hash spread for argument \"#{name}\" " \
+                  "for #{@twig_callable.type} \"#{@twig_callable.name}\".",
+                  @node.lineno,
+                  @node.source_context
+                )
+              end
+
+              next
+            else
+              raise "Unknown argument type: #{name} #{type}"
+            end
+          elsif kwargs.key?(name) || (found = kwargs.keys.detect { |key| key.to_s.underscore.to_sym == name })
+            found = name if found.nil?
+
+            if %i[opt req].include?(type)
+              resolved_positional << kwargs.delete(found)
+            else
+              resolved_kwargs[name] = kwargs.delete(found)
+            end
+          else
+            case type
+            when :opt, :key, :rest
+              next
+            when :keyrest
+              keyrest = true
+              resolved_kwargs.merge!(kwargs)
+              kwargs = {}
+              next
+            else
+              # If we have spreads, we just can't know until runtime since we don't know if it's a
+              # positional spread or kwarg spread because both use ...
+              unless spreads.any? || keyrest
+                raise Error::Syntax.new(
+                  "Value for argument \"#{name}\" is required for #{@twig_callable.type} \"#{@twig_callable.name}\".",
+                  @node.lineno,
+                  @node.source_context
+                )
+              end
+            end
+          end
+
+          called_arguments[name] = true
+        end
+
+        # If any of our remaining kwargs intersect with called_arguments then we have a duplicate key
+        duplicated = called_arguments.select { |_k, v| v }.keys & kwargs.keys
+        duplicated = duplicated.map(&:to_s)
+        duplicated = duplicated[0] if duplicated.one?
+
+        unless duplicated.empty?
+          raise Error::Syntax.new(
+            "Argument #{duplicated.inspect} is defined twice for #{@twig_callable.type} " \
+            "\"#{@twig_callable.name}\".",
+            @node.lineno,
+            @node.source_context
+          )
+        end
+
+        unexpected_arguments = []
+        unknown_argument = nil
+
+        # If there's no keyrest and any kwargs left, they are extraneous
+        if !keyrest && kwargs.any?
+          unexpected_arguments += kwargs.keys
+          unknown_argument = kwargs.values.first
+        end
+
+        # If there's a rest and any positional left, they are extraneous
+        if !rest && positional.any?
+          unexpected_arguments += [
+            *((positional_count - positional.length)...positional_count),
+          ]
+          unknown_argument = positional.first
+        end
+
+        if unexpected_arguments.any?
+          unknown_argument ||= @node
+
+          raise Error::Syntax.new(
+            "Unknown argument \"#{unexpected_arguments.join(', ')}\" " \
+            "for #{@twig_callable.type} \"#{@twig_callable.name}(#{destination_arguments.keys.join(', ')})\".",
+            unknown_argument.lineno,
+            unknown_argument.source_context
+          )
+        end
+
+        [resolved_positional + spreads.values, resolved_kwargs]
+      end
+
+      private
+
+      # @return [Callable]
+      attr_reader :twig_callable
+
+      # @return [Environment]
+      attr_reader :environment
+
+      def destination_arguments
+        arguments = callable_method.parameters.to_h { |k, v| [v, k] }
+
+        if @node.nodes.key?(:node)
+          arguments.shift
+        end
+
+        if twig_callable.needs_charset?
+          arguments.shift
+        end
+
+        if twig_callable.needs_environment?
+          arguments.shift
+        end
+
+        if twig_callable.needs_context?
+          arguments.shift
+        end
+
+        twig_callable.arguments.each do
+          arguments.shift
+        end
+
+        arguments
+      end
+
+      # @return [Method]
+      def callable_method
+        callable = twig_callable.callable
+
+        case callable
+        when ::Array
+          if callable[0] == :runtime
+            _, klass, method = callable
+
+            environment.runtime(klass).method(method.to_sym)
+          else
+            extension, method = callable[0, 2]
+            extension = extension.class.name if extension.is_a?(Extension::Base)
+
+            environment.extension(extension.delete_prefix('::')).method(method.to_sym)
+          end
+        when ::Method, ::Proc
+          callable
+        else
+          raise "Callable not supported: #{callable.inspect}"
+        end
+      end
+    end
+  end
+end