twig_ruby 0.0.1

data/lib/twig/expression_parser.rb

@@ -0,0 +1,517 @@
+# frozen_string_literal: true
+
+module Twig
+  # @!attribute [r] environment
+  #   @return [Environment]
+  class ExpressionParser
+    attr_reader :environment
+
+    OPERATOR_LEFT = 1
+    OPERATOR_RIGHT = 2
+
+    # @param [Parser] parser
+    # @param [Environment] environment
+    def initialize(parser, environment)
+      @parser = parser
+      @environment = environment
+    end
+
+    # @return [Node::Expression::Base]
+    def parse_expression(precedence = 0)
+      # @todo parse arrow
+
+      expr = primary
+      token = parser.current_token
+
+      while binary?(token) && binary_operators[token.value.to_sym][:precedence] >= precedence
+        operator = binary_operators[token.value.to_sym]
+        parser.stream.next
+
+        next_precedence = operator[:precedence]
+        next_precedence += 1 if operator[:associativity] == OPERATOR_LEFT
+
+        expr1 = parse_expression(next_precedence)
+
+        # @type [Node::Expression::Binary::Base]
+        expr = operator[:class].new(expr, expr1, token.lineno)
+        expr.attributes[:operator] = "binary_#{token.value}"
+
+        token = parser.current_token
+      end
+
+      return parse_ternary_expression(expr) if precedence.zero?
+
+      expr
+    end
+
+    # @return [Node::Expression::Base]
+    def parse_primary_expression
+      token = parser.current_token
+
+      case token.type
+      when Token::SYMBOL_TYPE
+        parser.stream.next
+
+        node = Node::Expression::Constant.new(token.value.to_sym, token.lineno)
+      when Token::NAME_TYPE
+        parser.stream.next
+
+        node = case token.value
+               when 'true', 'TRUE'
+                 Node::Expression::Constant.new(true, token.lineno)
+               when 'false', 'FALSE'
+                 Node::Expression::Constant.new(false, token.lineno)
+               when 'null', 'NULL', 'nil'
+                 Node::Expression::Constant.new(nil, token.lineno)
+               else
+                 if parser.current_token.value == '('
+                   get_function_node(token.value, token.lineno)
+                 else
+                   # @todo should be a context variable
+                   Node::Expression::Name.new(token.value, token.lineno)
+                 end
+               end
+      when Token::NUMBER_TYPE
+        parser.stream.next
+
+        node = Node::Expression::Constant.new(token.value, token.lineno)
+      when Token::STRING_TYPE, Token::INTERPOLATION_START_TYPE
+        node = parse_string_expression
+      when Token::PUNCTUATION_TYPE
+        case token.value
+        when '['
+          node = parse_sequence_expression
+        when '{'
+          node = parse_mapping_expression
+        else
+          Error::Syntax.new(
+            "Unexpected token #{token.type} of value #{token.value}",
+            token.lineno,
+            parser.stream.source
+          )
+        end
+      else
+        raise Error::Syntax.new(
+          "Unexpected token '#{token.type}' of value '#{token.value}'",
+          token.lineno,
+          parser.stream.source
+        )
+      end
+
+      parse_post_fix_expression(node)
+    end
+
+    # @param [Node::Expression::Base] node
+    # @return [Node::Expression::Base]
+    def parse_post_fix_expression(node)
+      loop do
+        token = parser.current_token
+
+        unless token.type == Token::PUNCTUATION_TYPE
+          break
+        end
+
+        case token.value
+        when '.', '['
+          node = parse_subscript_expression(node)
+        when '|'
+          node = parse_filter_expression(node)
+        else
+          break
+        end
+      end
+
+      node
+    end
+
+    def parse_subscript_expression(node)
+      if parser.stream.next.value == '.'
+        return parse_subscript_expression_dot(node)
+      end
+
+      parse_subscript_expression_array(node)
+    end
+
+    def parse_subscript_expression_dot(node)
+      stream = parser.stream
+      token = stream.current
+      lineno = token.lineno
+      arguments = Node::Expression::Array.new({}, lineno)
+      token = stream.next
+
+      if token.type == Token::NAME_TYPE
+        attribute = Node::Expression::Constant.new(token.value, token.lineno)
+      end
+
+      Node::Expression::GetAttribute.new(node, attribute, arguments, nil, token.lineno)
+    end
+
+    def parse_sequence_expression
+      stream = parser.stream
+      stream.expect(Token::PUNCTUATION_TYPE, '[', 'A sequence element was expected')
+
+      node = Node::Expression::Array.new({}, stream.current.lineno)
+      first = true
+
+      # raise stream.debug
+
+      until stream.test(Token::PUNCTUATION_TYPE, ']')
+        unless first
+          stream.expect(Token::PUNCTUATION_TYPE, ',', 'A sequence element must be followed by a comma')
+
+          # trailing comma
+          break if stream.test(Token::PUNCTUATION_TYPE, ']')
+        end
+
+        first = false
+
+        if stream.next_if(Token::SPREAD_TYPE)
+          expr = parse_expression
+          expr.attributes[:spread] = true
+          node.add_element(expr)
+        else
+          node.add_element(parse_expression)
+        end
+      end
+
+      stream.expect(Token::PUNCTUATION_TYPE, ']', 'An opened sequence is not properly closed')
+
+      node
+    end
+
+    def parse_mapping_expression
+      stream = parser.stream
+      stream.expect(Token::PUNCTUATION_TYPE, '{', 'A mapping element was expected')
+
+      node = Node::Expression::Array.new({}, stream.current.lineno)
+      first = true
+
+      until stream.test(Token::PUNCTUATION_TYPE, '}')
+        unless first
+          stream.expect(Token::PUNCTUATION_TYPE, ',', 'A mapping value must be followed by a comma')
+
+          # trailing comma
+          if stream.test(Token::PUNCTUATION_TYPE, '}')
+            break
+          end
+        end
+
+        first = false
+
+        if stream.next_if(Token::SPREAD_TYPE)
+          value = parse_expression
+          value.attributes[:spread] = true
+          node.add_element(value)
+
+          next
+        end
+
+        # a mapping key can be:
+        #
+        #  * a number -- 12
+        #  * a string -- 'a'
+        #  * a name, which is equivalent to a symbol -- a
+        #  * an expression, which must be enclosed in parentheses -- (1 + 2)
+        if (token = stream.next_if(Token::NAME_TYPE))
+          key = Node::Expression::Constant.new(token.value.to_sym, token.lineno)
+
+          # {a} is a shortcut for {a: a}
+          if stream.test(Token::PUNCTUATION_TYPE, %w[, }])
+            value = Node::Expression::Variable::Context.new(key.attributes[:value], key.lineno)
+            node.add_element(value, key.to_sym)
+
+            next
+          end
+        elsif (token = stream.next_if(Token::STRING_TYPE)) || (token = stream.next_if(Token::NUMBER_TYPE))
+          key = Node::Expression::Constant.new(token.value, token.lineno)
+        elsif stream.test(Token::PUNCTUATION_TYPE, '(')
+          key = parse_expression
+        else
+          current = stream.current
+
+          raise Error::Syntax.new(
+            'A mapping key must be a quoted string, number, name, or expression in parentheses ' \
+            "expected token '#{current.type}' of value '#{current.value}'",
+            current.lineno,
+            stream.source
+          )
+        end
+
+        stream.expect(Token::PUNCTUATION_TYPE, ':', 'A mapping key must be followed by a colon (:)')
+        value = parse_expression
+
+        node.add_element(value, key)
+      end
+
+      stream.expect(Token::PUNCTUATION_TYPE, '}', 'An opened mapping is not properly closed')
+
+      node
+    end
+
+    def get_function_node(name, line)
+      # @todo lots of stuff in this method
+      args = parse_only_arguments
+
+      if environment.helper_method?(name.to_sym)
+        Node::Expression::HelperMethod.new(name, args, line)
+      else
+        raise Error::Syntax.new("Unknown function '#{name}'", line, parser.stream.source)
+      end
+    end
+
+    def parse_only_arguments
+      args = AutoHash.new
+      stream = parser.stream
+      stream.expect(Token::PUNCTUATION_TYPE, '(', 'A list of arguments must begin with an opening parenthesis')
+      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::SPREAD_TYPE)
+          has_spread = true
+          value = Node::Expression::Unary::Spread.new(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 = parse_expression
+        end
+
+        name = nil
+        if (token = stream.next_if(Token::OPERATOR_TYPE, '=')) ||
+           (token = stream.next_if(Token::PUNCTUATION_TYPE, ':'))
+          unless value.class <= Node::Expression::Name
+            raise Error::Syntax.new(
+              "A parameter name must be a string, #{value.class.name} given.",
+              token.lineno,
+              stream.source
+            )
+          end
+
+          name = value.attributes[:name]
+          value = 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
+
+    # @return [Parser]
+    attr_reader :parser
+
+    # @return [Node::Expression::Base]
+    def primary
+      token = parser.current_token
+
+      if unary?(token)
+        operator = unary_operators[token.value.to_sym]
+        parser.stream.next
+
+        expr = parse_expression(operator[:precedence])
+        expr = operator[:class].new(expr, token.lineno)
+        expr.attributes[:operator] = "unary_#{token.value}"
+
+        return parse_post_fix_expression(expr)
+      elsif token.test(Token::PUNCTUATION_TYPE, '(')
+        parser.stream.next
+        expr = parse_expression.set_explicit_parentheses
+
+        parser.stream.expect(Token::PUNCTUATION_TYPE, ')', 'Open parenthesis not closed')
+
+        return parse_post_fix_expression(expr)
+      end
+
+      parse_primary_expression
+    end
+
+    # @param [Node::Expression] expr
+    # @return [Node::Expression]
+    def parse_ternary_expression(expr)
+      while parser.stream.next_if(Token::PUNCTUATION_TYPE, '?')
+        expr2 = parse_expression
+        expr3 = if parser.stream.next_if(Token::PUNCTUATION_TYPE, ':')
+                  parse_expression
+                else
+                  Node::Expression::Constant.new('', parser.current_token.lineno)
+                end
+
+        expr = Node::Expression::Ternary.new(expr, expr2, expr3, parser.current_token.lineno)
+      end
+
+      expr
+    end
+
+    def parse_filter_expression(node)
+      parser.stream.next
+
+      parse_filter_expression_raw(node)
+    end
+
+    def parse_filter_expression_raw(node)
+      loop do
+        token = parser.stream.expect(Token::NAME_TYPE)
+
+        arguments = if parser.stream.test(Token::PUNCTUATION_TYPE, '(')
+                      parse_only_arguments
+                    else
+                      Node::Empty.new
+                    end
+
+        filter = get_filter(token.value, token.lineno)
+        node = filter.node_class.new(node, filter, arguments, token.lineno)
+
+        unless parser.stream.test(Token::PUNCTUATION_TYPE, '|')
+          break
+        end
+
+        parser.stream.next
+      end
+
+      node
+    end
+
+    def parse_arguments
+      raise NotImplementedError
+    end
+
+    # @return [Node::Nodes]
+    def parse_assignment_expression
+      stream = parser.stream
+      targets = AutoHash.new
+
+      loop do
+        token = parser.current_token
+
+        if stream.test(Token::OPERATOR_TYPE) && token.value.match(Lexer::REGEX_NAME)
+          # in this context, string operators are variables names
+          parser.stream.next
+        else
+          stream.expect(Token::NAME_TYPE, nil, 'Only variables can be assigned to')
+        end
+
+        targets << Node::Expression::Variable::AssignContext.new(token.value, token.lineno)
+
+        unless stream.next_if(Token::PUNCTUATION_TYPE, ',')
+          break
+        end
+      end
+
+      Node::Nodes.new(targets)
+    end
+
+    def parse_string_expression
+      stream = parser.stream
+      nodes = []
+
+      # a string cannot be followed by another string in a single expression
+      next_can_be_string = true
+
+      loop do
+        if next_can_be_string && (token = stream.next_if(Token::STRING_TYPE))
+          nodes << Node::Expression::Constant.new(token.value, token.lineno)
+          next_can_be_string = false
+        elsif stream.next_if(Token::INTERPOLATION_START_TYPE)
+          nodes << parse_expression
+          stream.expect(Token::INTERPOLATION_END_TYPE)
+          next_can_be_string = true
+        else
+          break
+        end
+      end
+
+      expr = nodes.shift
+      nodes.each do |node|
+        expr = Node::Expression::Binary::Concat(expr, node, node.lineno)
+      end
+
+      expr
+    end
+
+    # @param [Node::Base]
+    # @return [Node::Expression::Base]
+    def parse_subscript_expression_array(node)
+      stream = parser.stream
+      token = stream.current
+      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 = parse_expression
+      end
+
+      if stream.next_if(Token::PUNCTUATION_TYPE, ':')
+        slice = true
+      end
+
+      if slice
+        length = if stream.test(Token::PUNCTUATION_TYPE, ']')
+                   Node::Expression::Constant.new(nil, token.lineno)
+                 else
+                   parse_expression
+                 end
+
+        filter = get_filter('slice', token.lineno)
+        arguments = Node::Nodes.new(AutoHash.new.add(attribute, length))
+        filter = filter.node_class.new(node, filter, arguments, token.lineno)
+
+        stream.expect(Token::PUNCTUATION_TYPE, ']')
+
+        return filter
+      end
+
+      stream.expect(Token::PUNCTUATION_TYPE, ']')
+
+      Node::Expression::GetAttribute.new(node, attribute, arguments, Template::ARRAY_CALL, lineno)
+    end
+
+    # @return [Hash]
+    def unary_operators
+      @unary_operators ||= environment.operators[0]
+    end
+
+    # @return [Hash]
+    def binary_operators
+      @binary_operators ||= environment.operators[1]
+    end
+
+    # @param [Token] token
+    def unary?(token)
+      token.test(Token::OPERATOR_TYPE) && unary_operators.key?(token.value.to_sym)
+    end
+
+    # @param [Token] token
+    def binary?(token)
+      token.test(Token::OPERATOR_TYPE) && binary_operators.key?(token.value.to_sym)
+    end
+
+    # @return [Filter]
+    def get_filter(name, lineno)
+      unless (filter = environment.filter(name))
+        raise Error::Syntax.new("Unknown '#{name}' filter", lineno, parser.stream.source)
+      end
+
+      filter
+    end
+  end
+end

data/lib/twig/extension/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Twig
+  module Extension
+    class Base
+      def operators
+        [{}, {}]
+      end
+
+      def filters
+        {}
+      end
+
+      def token_parsers
+        []
+      end
+
+      def helper_methods
+        []
+      end
+    end
+  end
+end

data/lib/twig/extension/core.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Twig
+  module Extension
+    class Core < Base
+      def operators
+        unary = Node::Expression::Unary
+        binary = Node::Expression::Binary
+
+        [
+          {
+            not: { precedence: 70, class: unary::Not },
+            '-': { precedence: 500, class: unary::Neg },
+            '+': { precedence: 500, class: unary::Pos },
+          },
+          {
+            or: { precedence: 10, class: binary::Or, associativity: ExpressionParser::OPERATOR_LEFT },
+            xor: { precedence: 12, class: binary::Xor, associativity: ExpressionParser::OPERATOR_LEFT },
+            and: { precedence: 15, class: binary::And, associativity: ExpressionParser::OPERATOR_LEFT },
+
+            '==': { precedence: 20, class: binary::Equal, associativity: ExpressionParser::OPERATOR_LEFT },
+            '!=': { precedence: 20, class: binary::NotEqual, associativity: ExpressionParser::OPERATOR_LEFT },
+            '<=>': { precedence: 20, class: binary::Spaceship, associativity: ExpressionParser::OPERATOR_LEFT },
+            '<': { precedence: 20, class: binary::Less, associativity: ExpressionParser::OPERATOR_LEFT },
+            '>': { precedence: 20, class: binary::Greater, associativity: ExpressionParser::OPERATOR_LEFT },
+            '>=': { precedence: 20, class: binary::GreaterEqual, associativity: ExpressionParser::OPERATOR_LEFT },
+            '<=': { precedence: 20, class: binary::LessEqual, associativity: ExpressionParser::OPERATOR_LEFT },
+
+            # @todo this needs a custom class but just needs to be parsed as operaor for for loops
+            in: { precedence: 20, class: binary::LessEqual, associativity: ExpressionParser::OPERATOR_LEFT },
+
+            '+': { precedence: 30, class: binary::Add, associativity: ExpressionParser::OPERATOR_LEFT },
+            '-': { precedence: 30, class: binary::Sub, associativity: ExpressionParser::OPERATOR_LEFT },
+            '~': { precedence: 40, class: binary::Concat, associativity: ExpressionParser::OPERATOR_LEFT },
+            '*': { precedence: 60, class: binary::Mul, associativity: ExpressionParser::OPERATOR_LEFT },
+            '/': { precedence: 60, class: binary::Div, associativity: ExpressionParser::OPERATOR_LEFT },
+          },
+        ]
+      end
+
+      def filters
+        {
+          capitalize: TwigFilter.new('capitalize', [self, :capitalize]),
+          upper: TwigFilter.new('upper', [self, :upper]),
+          lower: TwigFilter.new('lower', [self, :lower]),
+          raw: TwigFilter.new('raw', [self, :raw]),
+        }
+      end
+
+      def token_parsers
+        [
+          TokenParser::Block.new,
+          TokenParser::Extends.new,
+          TokenParser::For.new,
+          TokenParser::If.new,
+          TokenParser::Include.new,
+          TokenParser::Yield.new,
+        ]
+      end
+
+      def capitalize(string)
+        string.capitalize
+      end
+
+      def upper(string)
+        string.upcase
+      end
+
+      def lower(string)
+        string.downcase
+      end
+
+      def self.ensure_hash(value)
+        return value if value.class < Hash
+
+        AutoHash.new.add(*value)
+      end
+
+      def self.get_attribute(object, attribute, type)
+        case type
+        when Template::ARRAY_CALL
+          object[attribute] || (attribute.is_a?(String) ? object[attribute.to_sym] : object[attribute.to_s])
+        else
+          raise NotImplementedError, 'Need to implement other get_attribute calls'
+        end
+      end
+    end
+  end
+end

data/lib/twig/extension/rails.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Twig
+  module Extension
+    class Rails < Extension::Base
+      def filters
+        {}
+      end
+
+      def helper_methods
+        %w[
+          render
+
+          distance_of_time_in_words
+          time_ago_in_words
+
+          number_to_currency
+          number_to_human
+          number_to_human_size
+          number_to_percentage
+          number_to_phone
+          number_with_delimiter
+          number_with_precision
+
+          excerpt
+          pluralize
+          truncate
+          word_wrap
+
+          button_to
+          current_page?
+          link_to
+          mail_to
+          url_for
+
+          raw
+          sanitize
+          sanitize_css
+          strip_links
+          strip_tags
+
+          audio_tag
+          auto_discovery_link_tag
+          favicon_link_tag
+          image_tag
+          javascript_include_tag
+          picture_tag
+          preload_link_tag
+          stylesheet_link_tag
+          video_tag
+
+          escape_javascript
+          javascript_tag
+
+          benchmark
+          cache
+          debug
+
+          tag
+          token_list
+
+          form_for
+          form_with
+
+          date_test
+        ]
+      end
+    end
+  end
+end