twig_ruby 0.0.1 → 0.0.3

data/lib/twig/expression_parser/infix/dot.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Infix
+      class Dot < InfixExpressionParser
+        include ParsesArguments
+
+        def parse(parser, left, _token)
+          stream = parser.stream
+          token = stream.current
+          lineno = token.lineno
+          arguments = Node::Expression::Array.new(AutoHash.new, lineno)
+          type = Template::ANY_CALL
+
+          if stream.next_if(Token::OPERATOR_TYPE, '(')
+            attribute = parser.parse_expression
+            stream.expect(Token::PUNCTUATION_TYPE, ')')
+          else
+            token = stream.next
+
+            if [Token::NAME_TYPE, Token::NUMBER_TYPE].include?(token.type) ||
+               (token.type == Token::OPERATOR_TYPE && token.value.match(/\A#{Lexer::REGEX_NAME}/))
+              attribute = Node::Expression::Constant.new(token.value, token.lineno)
+            else
+              raise Error::Syntax.new(
+                "Expected name or number, got value \"#{token.value}\" of type #{token.type}.",
+                token.lineno,
+                stream.source
+              )
+            end
+          end
+
+          if stream.test(Token::OPERATOR_TYPE, '(')
+            type = Template::METHOD_CALL
+            arguments = parse_callable_arguments(parser, token.lineno)
+          end
+
+          if left.is_a?(Node::Expression::Name) && (
+            parser.imported_symbol(:template, left.attributes[:name]) ||
+              (left.attributes[:name] == '_self' && attribute.is_a?(Node::Expression::Constant))
+          )
+            return Node::Expression::MacroReference.new(
+              Node::Expression::Variable::Template.new(left.attributes[:name], left.lineno),
+              "macro_#{attribute.attributes[:value]}",
+              arguments,
+              left.lineno
+            )
+          end
+
+          Node::Expression::GetAttribute.new(left, attribute, arguments, type, token.lineno)
+        end
+
+        def name
+          '.'
+        end
+
+        def description
+          'Get an attribute on a variable'
+        end
+
+        def precedence
+          512
+        end
+
+        def associativity
+          LEFT
+        end
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/infix/filter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Infix
+      class Filter < InfixExpressionParser
+        include ParsesArguments
+
+        def parse(parser, left, _token)
+          stream = parser.stream
+          token = stream.expect(Token::NAME_TYPE)
+          line = token.lineno
+
+          arguments = if stream.test(Token::OPERATOR_TYPE, '(')
+                        parse_named_arguments(parser)
+                      else
+                        Node::Empty.new
+                      end
+
+          filter = parser.filter(token.value, line)
+
+          filter.node_class.new(left, filter, arguments, token.lineno)
+        end
+
+        def name
+          '|'
+        end
+
+        def description
+          'Twig filter call'
+        end
+
+        def precedence
+          300
+        end
+
+        def associativity
+          LEFT
+        end
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/infix/function.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Infix
+      class Function < InfixExpressionParser
+        include ParsesArguments
+
+        def parse(parser, left, token)
+          line = token.lineno
+
+          unless left.is_a?(Node::Expression::Variable::Context)
+            raise Error::Syntax.new(
+              "Function name must be an identifier. got #{left.inspect}",
+              line,
+              parser.stream.source
+            )
+          end
+
+          name = left.attributes[:name]
+
+          if (aliased = parser.imported_symbol(:function, name))
+            return Node::Expression::MacroReference.new(
+              aliased[:node].nodes[:var],
+              aliased[:name],
+              parse_callable_arguments(parser, line, parse_open_parenthesis: false),
+              line
+            )
+          end
+
+          args = parse_named_arguments(parser, parse_open_parenthesis: false)
+          function = parser.function(name, args, line)
+
+          # Helper method returned
+          if function.is_a?(Node::Expression::Base)
+            return function
+          end
+
+          if (callable = function.parser_callable)
+            fake_node = Node::Empty.new(line)
+            fake_node.source_context = parser.stream.source
+
+            return callable.call(parser, fake_node, args, line)
+          end
+
+          function.node_class.new(function, args, line)
+        end
+
+        def name
+          '('
+        end
+
+        def description
+          'Twig function call'
+        end
+
+        def precedence
+          512
+        end
+
+        def associativity
+          LEFT
+        end
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/infix/is.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Infix
+      class Is < InfixExpressionParser
+        include ParsesArguments
+
+        def parse(parser, left, token)
+          stream = parser.stream
+          test = parser.test(left.lineno)
+
+          arguments = nil
+          if stream.test(Token::OPERATOR_TYPE, '(')
+            arguments = parse_named_arguments(parser)
+          elsif test.one_mandatory_argument?
+            arguments = Node::Nodes.new(AutoHash.new.add(
+              parser.parse_expression(precedence)
+            ))
+          end
+
+          if test.name == 'defined' && left.is_a?(Node::Expression::Variable::Context) &&
+             !(aliased = parser.imported_symbol(:function, left.attributes[:name])).nil?
+            left = Node::Expression::MacroReference.new(
+              aliased[:node].nodes[:var],
+              aliased[:name],
+              Node::Expression::Array.new(AutoHash.new, left.lineno),
+              left.lineno
+            )
+          end
+
+          test.node_class.new(left, test, arguments, parser.current_token.lineno)
+        end
+
+        def name
+          'is'
+        end
+
+        def description
+          'Twig tests'
+        end
+
+        def precedence
+          100
+        end
+
+        def associativity
+          LEFT
+        end
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/infix/is_not.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Infix
+      class IsNot < Is
+        include ParsesArguments
+
+        def parse(parser, left, token)
+          Node::Expression::Unary::Not.new(super, token.lineno)
+        end
+
+        def name
+          'is not'
+        end
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/infix/parses_arguments.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module ParsesArguments
+      private
+
+      # @param [Parser] parser
+      # @param [Integer] lineno
+      def parse_callable_arguments(parser, lineno, parse_open_parenthesis: true)
+        arguments = Node::Expression::Hash.new({}, lineno)
+
+        parse_named_arguments(parser, parse_open_parenthesis:).nodes.each do |key, node|
+          arguments.add_element(node, Node::Expression::Variable::Local.new(key, lineno))
+        end
+
+        arguments
+      end
+
+      # @param [Parser] parser
+      def parse_named_arguments(parser, parse_open_parenthesis: true)
+        args = AutoHash.new
+        stream = parser.stream
+
+        if parse_open_parenthesis
+          stream.expect(Token::OPERATOR_TYPE, '(', 'A list of arguments must begin with an opening parenthesis')
+        end
+
+        has_spread = false
+
+        until stream.test(Token::PUNCTUATION_TYPE, ')')
+          unless args.empty?
+            stream.expect(Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma')
+
+            # if above was trailing comma, exit early
+            break if stream.test(Token::PUNCTUATION_TYPE, ')')
+          end
+
+          if stream.next_if(Token::OPERATOR_TYPE, '...')
+            has_spread = true
+            value = Node::Expression::Unary::Spread.new(parser.parse_expression, stream.current.lineno)
+          elsif has_spread
+            raise Error::Syntax.new(
+              'Normal arguments must be placed before argument unpacking.',
+              stream.current.lineno,
+              stream.source
+            )
+          else
+            value = parser.parse_expression
+          end
+
+          name = nil
+          if (token = stream.next_if(Token::OPERATOR_TYPE, '=')) ||
+             (token = stream.next_if(Token::PUNCTUATION_TYPE, ':'))
+            # Allow quoted kwargs - form_with("data-turbo-stream": true)
+            if value.is_a?(Node::Expression::Constant) && value.attributes[:value].is_a?(String)
+              name = value.attributes[:value]
+            elsif value.is_a?(Node::Expression::Name)
+              name = value.attributes[:name]
+            else
+              raise Error::Syntax.new(
+                "A parameter name must be a string, #{value.class.name} given.",
+                token.lineno,
+                stream.source
+              )
+            end
+
+            value = parser.parse_expression
+          end
+
+          if name.nil?
+            args.add(value)
+          else
+            args[name] = value
+          end
+        end
+
+        stream.expect(Token::PUNCTUATION_TYPE, ')', 'A list of arguments must be closed by a parenthesis')
+
+        Node::Nodes.new(args)
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/infix/square_bracket.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Infix
+      class SquareBracket < InfixExpressionParser
+        def parse(parser, left, token)
+          stream = parser.stream
+          lineno = token.lineno
+          arguments = Node::Expression::Array.new({}, lineno)
+
+          slice = false
+          if stream.test(Token::PUNCTUATION_TYPE, ':')
+            slice = true
+            attribute = Node::Expression::Constant.new(0, token.lineno)
+          else
+            attribute = parser.parse_expression
+          end
+
+          if stream.next_if(Token::PUNCTUATION_TYPE, ':')
+            slice = true
+          end
+
+          if slice || stream.test(Token::SYMBOL_TYPE)
+            length = if stream.test(Token::PUNCTUATION_TYPE, ']')
+                       Node::Expression::Constant.new(nil, token.lineno)
+                     elsif stream.test(Token::SYMBOL_TYPE)
+                       token = stream.next
+                       Node::Expression::Variable::Context.new(token.value, token.lineno)
+                     else
+                       parser.parse_expression
+                     end
+
+            filter = parser.filter('slice', token.lineno)
+            arguments = Node::Nodes.new(AutoHash.new.add(attribute, length))
+            filter = filter.node_class.new(left, filter, arguments, token.lineno)
+
+            stream.expect(Token::PUNCTUATION_TYPE, ']')
+
+            return filter
+          end
+
+          stream.expect(Token::PUNCTUATION_TYPE, ']')
+
+          Node::Expression::GetAttribute.new(left, attribute, arguments, Template::ARRAY_CALL, lineno)
+        end
+
+        def name
+          '['
+        end
+
+        def description
+          'Array access'
+        end
+
+        def precedence
+          512
+        end
+
+        def associativity
+          LEFT
+        end
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/infix_expression_parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    class InfixExpressionParser < ExpressionParser::Base
+      LEFT = 'left'
+      RIGHT = 'right'
+
+      # @param [Parser] parser
+      # @param [Node::Expression::Base] left
+      # @param [Token] token
+      # @return [Node::Expression::Base]
+      def parse(parser, left, token)
+        raise NotImplementedError
+      end
+
+      def associativity
+        raise NotImplementedError
+      end
+
+      def left?
+        associativity == LEFT
+      end
+
+      def right?
+        associativity == RIGHT
+      end
+
+      def type
+        :infix
+      end
+    end
+  end
+end

data/lib/twig/expression_parser/prefix/grouping.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Twig
+  module ExpressionParser
+    module Prefix
+      class Grouping < PrefixExpressionParser
+        def parse(parser, token)
+          stream = parser.stream
+          expr = parser.parse_expression(precedence)
+
+          if stream.next_if(Token::PUNCTUATION_TYPE, ')')
+            unless stream.test(Token::OPERATOR_TYPE, '=>')
+              return expr.set_explicit_parentheses
+            end
+
+            return Node::Expression::Array.new(AutoHash.new.add(expr), token.lineno)
+          end
+
+          # determine if we are parsing arrow function arguments
+          unless stream.test(Token::PUNCTUATION_TYPE, ',')
+            stream.expect(Token::PUNCTUATION_TYPE, ')', 'An opened parenthesis is not properly closed.')
+          end
+
+          names = AutoHash.new.add(expr)
+          loop do
+            if stream.next_if(Token::PUNCTUATION_TYPE, ')')
+              break
+            end
+
+            stream.expect(Token::PUNCTUATION_TYPE, ',')
+            token = stream.expect(Token::NAME_TYPE)
+            names << Node::Expression::Variable::Context.new(token.value, token.lineno)
+          end
+
+          unless stream.test(Token::OPERATOR_TYPE, '=>')
+            raise Error::Syntax.new(
+              'A list of variables must be followed by an arrow.',
+              stream.current.lineno,
+              stream.source
+            )
+          end
+
+          Node::Expression::Array.new(names, token.lineno)
+        end
+
+        def name
+          '('
+        end
+
+        def description
+          'Explicit group expression (a)'
+        end
+
+        def precedence
+          0
+        end
+      end
+    end
+  end
+end