twig_ruby 0.0.1 → 0.0.2

data/lib/twig/template_wrapper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Twig
+  class TemplateWrapper
+    def initialize(environment, template)
+      @environment = environment
+      @template = template
+    end
+
+    def render(context = {}, call_context: nil, output_buffer: nil)
+      context = Runtime::Context.from(context, call_context:, output_buffer:)
+
+      template.render(context).to_s
+    end
+
+    def render_block(name, context = {}, call_context: nil, output_buffer: nil)
+      context = Runtime::Context.from(context, call_context:, output_buffer:)
+      context.merge!(environment.globals)
+
+      template.render_block(name, context).to_s
+    end
+
+    def block?(name, context = {})
+      context = Runtime::Context.from(context)
+
+      template.block?(name, context)
+    end
+
+    # @return [Template]
+    def unwrap
+      template
+    end
+
+    private
+
+    # @return [Environment]
+    attr_reader :environment
+
+    # @return [Twig::Template]
+    attr_accessor :template
+  end
+end

data/lib/twig/token.rb

@@ -10,14 +10,30 @@ module Twig
     VAR_END_TYPE = :var_end
     NAME_TYPE = :name
     SYMBOL_TYPE = :symbol
+    CLASS_VAR_TYPE = :class_var
     NUMBER_TYPE = :number
     STRING_TYPE = :string
     OPERATOR_TYPE = :operator
     PUNCTUATION_TYPE = :punctuation
     INTERPOLATION_START_TYPE = :interpolation_start
     INTERPOLATION_END_TYPE = :interpolation_end
-    ARROW_TYPE = :arrow
-    SPREAD_TYPE = :spread
+
+    TOKEN_TO_ENGLISH = {
+      EOF_TYPE => 'end of template',
+      TEXT_TYPE => 'text',
+      BLOCK_START_TYPE => 'begin of statement block',
+      VAR_START_TYPE => 'begin of print statement',
+      BLOCK_END_TYPE => 'end of statement block',
+      VAR_END_TYPE => 'end of print statement',
+      NAME_TYPE => 'name',
+      NUMBER_TYPE => 'number',
+      STRING_TYPE => 'string',
+      OPERATOR_TYPE => 'operator',
+      PUNCTUATION_TYPE => 'punctuation',
+      INTERPOLATION_START_TYPE => 'begin of string interpolation',
+      INTERPOLATION_END_TYPE => 'end of string interpolation',
+      SYMBOL_TYPE => 'symbol',
+    }.freeze
 
     attr_reader :type, :value, :lineno
 
@@ -44,5 +60,15 @@ module Twig
     def debug
       [type, value]
     end
+
+    def to_english
+      self.class.type_to_english(@type)
+    end
+
+    def self.type_to_english(type)
+      TOKEN_TO_ENGLISH.fetch(type) do
+        raise ArgumentError, "Token of type \"#{type}\" does not exist."
+      end
+    end
   end
 end

data/lib/twig/token_parser/apply.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    # Applies filters on a section of a template.
+    #
+    # {% apply upper %}
+    #   This text becomes uppercase
+    # {% endapply %}
+    class Apply < Base
+      def parse(token)
+        lineno = token.lineno
+        ref = Node::Expression::Variable::Local.new(nil, lineno)
+        filter = ref
+        ep = parser.environment.expression_parsers.by_class(ExpressionParser::Infix::Filter.name)
+
+        loop do
+          filter = ep.parse(parser, filter, parser.current_token)
+
+          unless parser.stream.test(Token::OPERATOR_TYPE, '|')
+            break
+          end
+
+          parser.stream.next
+        end
+
+        parser.stream.expect(Token::BLOCK_END_TYPE)
+        body = parser.subparse(method(:decide_apply_end), drop_needle: true)
+        parser.stream.expect(Token::BLOCK_END_TYPE)
+
+        Node::Nodes.new({
+          0 => Node::Set.new(true, ref, body, lineno),
+          1 => Node::Print.new(filter, lineno),
+        }, lineno)
+      end
+
+      def tag
+        'apply'
+      end
+
+      private
+
+      def decide_apply_end(token)
+        token.test('endapply')
+      end
+    end
+  end
+end

data/lib/twig/token_parser/auto_escape.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    class AutoEscape < TokenParser::Base
+      def parse(token)
+        lineno = token.lineno
+        stream = parser.stream
+
+        if stream.test(Token::BLOCK_END_TYPE)
+          value = :html
+        else
+          expr = parser.parse_expression
+
+          unless expr.is_a?(Node::Expression::Constant)
+            raise Error::Syntax.new(
+              'An escaping strategy must be a string or false.',
+              stream.current.lineno,
+              stream.source
+            )
+          end
+
+          value = expr.attributes[:value]
+          value = value.to_sym if value.is_a?(String)
+        end
+
+        stream.expect(Token::BLOCK_END_TYPE)
+        body = parser.subparse(method(:decide_block_end), drop_needle: true)
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        Node::AutoEscape.new(value, body, lineno)
+      end
+
+      def tag
+        'autoescape'
+      end
+
+      private
+
+      def decide_block_end(token)
+        token.test('endautoescape')
+      end
+    end
+  end
+end

data/lib/twig/token_parser/base.rb

@@ -15,6 +15,32 @@ module Twig
       def tag
         raise 'tag is not implemented'
       end
+
+      private
+
+      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
     end
   end
 end

data/lib/twig/token_parser/block.rb

@@ -20,14 +20,14 @@ module Twig
         parser.push_block_stack(name)
 
         if stream.next_if(Token::BLOCK_END_TYPE)
-          body = parser.subparse(decide_block_end, drop_needle: true)
+          body = parser.subparse(method(:decide_block_end), drop_needle: true)
 
           if (token = stream.next_if(Token::NAME_TYPE)) && token.value != name
             raise "Expected end block for #{name}, given #{token.value}"
           end
         else
           body = Node::Nodes.new({
-            0 => Node::Print.new(parser.expression_parser.parse_expression, lineno),
+            0 => Node::Print.new(parser.parse_expression, lineno),
           })
         end
 
@@ -46,8 +46,8 @@ module Twig
 
       private
 
-      def decide_block_end
-        ->(token) { token.test('endblock') }
+      def decide_block_end(token)
+        token.test('endblock')
       end
     end
   end

data/lib/twig/token_parser/cache.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    class Cache < TokenParser::Base
+      include Twig::ExpressionParser::ParsesArguments
+
+      def parse(token)
+        stream = parser.stream
+        lineno = token.lineno
+        arguments = parse_named_arguments(parser)
+
+        stream.expect(Token::BLOCK_END_TYPE)
+        body = parser.subparse(method(:decide_cache_end), drop_needle: true)
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        Node::Cache.new(arguments, body, lineno)
+      end
+
+      def tag
+        'cache'
+      end
+
+      private
+
+      def decide_cache_end(token)
+        token.test('endcache')
+      end
+    end
+  end
+end

data/lib/twig/token_parser/deprecated.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    class Deprecated < Base
+      def parse(token)
+        stream = parser.stream
+        expr = parser.parse_expression
+        node = Node::Deprecated.new(expr, token.lineno)
+
+        while stream.test(Token::NAME_TYPE)
+          k = stream.current.value
+          stream.next
+          stream.expect(Token::OPERATOR_TYPE, '=')
+
+          case k
+          when 'package'
+            node.nodes[:package] = parser.parse_expression
+          when 'version'
+            node.nodes[:version] = parser.parse_expression
+          else
+            raise Error::Syntax.new(
+              "Unknown \"#{k}\" option.",
+              stream.current.lineno,
+              stream.source_context
+            )
+          end
+        end
+
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        node
+      end
+
+      def tag
+        'deprecated'
+      end
+    end
+  end
+end

data/lib/twig/token_parser/do.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    class Do < TokenParser::Base
+      def parse(token)
+        expr = parser.parse_expression
+
+        parser.stream.expect(Token::BLOCK_END_TYPE)
+
+        Node::Do.new(expr, token.lineno)
+      end
+
+      def tag
+        'do'
+      end
+    end
+  end
+end

data/lib/twig/token_parser/embed.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'include'
+
+module Twig
+  module TokenParser
+    class Embed < Include
+      def parse(token)
+        stream = parser.stream
+        parent = parser.parse_expression
+
+        variables, only, ignore_missing = parse_arguments
+
+        parent_token = fake_parent_token = Token.new(Token::STRING_TYPE, '__parent__', token.lineno)
+
+        if parent.is_a?(Node::Expression::Constant)
+          parent_token = Token.new(Token::STRING_TYPE, parent.attributes[:value], token.lineno)
+        elsif parent.is_a?(Node::Expression::Variable::Context)
+          parent_token = Token.new(Token::NAME_TYPE, parent.attributes[:name], token.lineno)
+        end
+
+        # inject a fake parent to make the parent() function work
+        stream.inject([
+          Token.new(Token::BLOCK_START_TYPE, '', token.lineno),
+          Token.new(Token::NAME_TYPE, 'extends', token.lineno),
+          parent_token,
+          Token.new(Token::BLOCK_END_TYPE, '', token.lineno),
+        ])
+
+        node = parser.parse(stream, method(:decide_block_end), drop_needle: true)
+
+        # override the parent with the correct one
+        if fake_parent_token == parent_token
+          node.nodes[:parent] = parent
+        end
+
+        parser.embed_template(node)
+
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        Node::Embed.new(
+          node.template_name,
+          node.attributes[:index],
+          variables,
+          only,
+          ignore_missing,
+          token.lineno
+        )
+      end
+
+      def tag
+        'embed'
+      end
+
+      private
+
+      def decide_block_end(token)
+        token.test('endembed')
+      end
+    end
+  end
+end

data/lib/twig/token_parser/extends.rb

@@ -7,11 +7,12 @@ module Twig
         stream = parser.stream
 
         if parser.peek_block_stack
-          raise Error::Syntax.new('Cannot raise from inside a block', token.lineno, stream.source)
-          # elsif parser.main_scope? @todo
+          raise Error::Syntax.new('Cannot use "extend" in a block.', token.lineno, stream.source)
+        elsif !parser.main_scope?
+          raise Error::Syntax.new('Cannot use "extend" in a macro.', token.lineno, stream.source)
         end
 
-        parser.parent = parser.expression_parser.parse_expression
+        parser.parent = parser.parse_expression
         stream.expect(Token::BLOCK_END_TYPE)
 
         Node::Empty.new(token.lineno)

data/lib/twig/token_parser/for.rb

@@ -10,16 +10,21 @@ module Twig
         lineno = token.lineno
         stream = parser.stream
 
-        targets = parser.expression_parser.parse_assignment_expression
+        targets = parse_assignment_expression
         stream.expect(Token::OPERATOR_TYPE, 'in')
-        seq = parser.expression_parser.parse_expression
+        seq = parser.parse_expression
+
+        if_expr = nil
+        if stream.next_if(Token::NAME_TYPE, 'if')
+          if_expr = parser.parse_expression
+        end
 
         stream.expect(Token::BLOCK_END_TYPE)
-        body = parser.subparse(decide_for_fork)
+        body = parser.subparse(method(:decide_for_fork))
 
         if stream.next.value == 'else'
           stream.expect(Token::BLOCK_END_TYPE)
-          else_expr = parser.subparse(decide_for_end, drop_needle: true)
+          else_expr = parser.subparse(method(:decide_for_end), drop_needle: true)
         else
           else_expr = nil
         end
@@ -43,7 +48,7 @@ module Twig
           value_target.lineno
         )
 
-        Node::For.new(key_target, value_target, seq, nil, body, else_expr, lineno)
+        Node::For.new(key_target, value_target, seq, if_expr, body, else_expr, lineno)
       end
 
       def tag
@@ -52,12 +57,12 @@ module Twig
 
       private
 
-      def decide_for_fork
-        ->(token) { token.test(%w[else endfor]) }
+      def decide_for_fork(token)
+        token.test(%w[else endfor])
       end
 
-      def decide_for_end
-        ->(token) { token.test(%w[endfor]) }
+      def decide_for_end(token)
+        token.test(%w[endfor])
       end
     end
   end

data/lib/twig/token_parser/from.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    # Imports macros.
+    #
+    # {% from 'forms.html.twig' import forms %}
+    #
+    class From < Base
+      # @param [Token] token
+      def parse(token)
+        macro = parser.parse_expression
+        stream = parser.stream
+        stream.expect(Token::NAME_TYPE, 'import')
+
+        targets = {}
+        loop do
+          name = stream.expect(Token::NAME_TYPE).value
+
+          aliased = if stream.next_if('as')
+                      Node::Expression::Variable::AssignContext.new(
+                        stream.expect(Token::NAME_TYPE).value,
+                        token.lineno
+                      )
+                    else
+                      Node::Expression::Variable::AssignContext.new(name, token.lineno)
+                    end
+
+          targets[name] = aliased
+
+          unless stream.next_if(Token::PUNCTUATION_TYPE, ',')
+            break
+          end
+        end
+
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        internal_ref = Node::Expression::Variable::AssignTemplate.new(
+          Node::Expression::Variable::Template.new(nil, token.lineno),
+          global: parser.main_scope?
+        )
+
+        node = Node::Import.new(macro, internal_ref, token.lineno)
+
+        targets.each do |name, aliased|
+          parser.add_imported_symbol(:function, aliased.attributes[:name], "macro_#{name}", internal_ref)
+        end
+
+        node
+      end
+
+      def tag
+        'from'
+      end
+    end
+  end
+end

data/lib/twig/token_parser/guard.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    # Prevents compilation of block if function/filter/test does not exist.
+    # Since this is at compilation time, this DOES NOT work with Rails helper functions
+    # as those can't be determined fully at compile time as of now.
+    class Guard < Base
+      def parse(token)
+        stream = parser.stream
+        type_token = stream.expect(Token::NAME_TYPE)
+
+        unless %w[function filter test].include?(type_token.value)
+          raise Error::Syntax.new(
+            "Supported guard types are function, filter, and test, \"#{token.value}\" given.",
+            type_token.lineno,
+            stream.source
+          )
+        end
+
+        name_token = stream.expect(Token::NAME_TYPE)
+
+        begin
+          exists = !parser.environment.send(type_token.value, name_token.value).nil?
+        rescue Error::Syntax
+          exists = false
+        end
+
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        if exists
+          body = parser.subparse(method(:decide_guard_fork))
+        else
+          body = Node::Empty.new
+          parser.subparse_ignore_unknown_twig_callables(method(:decide_guard_fork))
+        end
+
+        else_node = Node::Empty.new
+
+        if stream.next.value == 'else'
+          stream.expect(Token::BLOCK_END_TYPE)
+          else_node = parser.subparse(method(:decide_guard_end), drop_needle: true)
+        end
+
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        Node::Nodes.new(AutoHash.new.add(exists ? body : else_node))
+      end
+
+      def tag
+        'guard'
+      end
+
+      private
+
+      def decide_guard_fork(token)
+        token.test(%w[else endguard])
+      end
+
+      def decide_guard_end(token)
+        token.test(['endguard'])
+      end
+    end
+  end
+end

data/lib/twig/token_parser/if.rb

@@ -12,10 +12,10 @@ module Twig
     class If < Base
       def parse(token)
         lineno = token.lineno
-        expr = parser.expression_parser.parse_expression
+        expr = parser.parse_expression
         stream = parser.stream
         stream.expect(Token::BLOCK_END_TYPE)
-        body = parser.subparse(decide_if_fork)
+        body = parser.subparse(method(:decide_if_fork))
         tests = [expr, body]
         else_node = nil
 
@@ -24,11 +24,11 @@ module Twig
           case stream.next.value
           when 'else'
             stream.expect(Token::BLOCK_END_TYPE)
-            else_node = parser.subparse(decide_if_end)
+            else_node = parser.subparse(method(:decide_if_end))
           when 'elsif', 'elseif'
-            expr = parser.expression_parser.parse_expression
+            expr = parser.parse_expression
             stream.expect(Token::BLOCK_END_TYPE)
-            body = parser.subparse(decide_if_fork)
+            body = parser.subparse(method(:decide_if_fork))
             tests.push(expr, body)
           when 'endif'
             if_ended = true
@@ -52,12 +52,12 @@ module Twig
 
       private
 
-      def decide_if_end
-        ->(token) { token.test(%w[endif]) }
+      def decide_if_end(token)
+        token.test(%w[endif])
       end
 
-      def decide_if_fork
-        ->(token) { token.test(%w[elseif elsif else endif]) }
+      def decide_if_fork(token)
+        token.test(%w[elseif elsif else endif])
       end
     end
   end

data/lib/twig/token_parser/import.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    # Imports macros.
+    #
+    # {% import 'forms.html.twig' as forms %}
+    #
+    class Import < Base
+      def parse(token)
+        macro = parser.parse_expression
+        parser.stream.expect(Token::NAME_TYPE, 'as')
+        name = parser.stream.expect(Token::NAME_TYPE).value
+        var = Node::Expression::Variable::AssignTemplate.new(
+          Node::Expression::Variable::Template.new(name, token.lineno),
+          global: parser.main_scope?
+        )
+        parser.stream.expect(Token::BLOCK_END_TYPE)
+        parser.add_imported_symbol(:template, name)
+
+        Node::Import.new(macro, var, token.lineno)
+      end
+
+      def tag
+        'import'
+      end
+    end
+  end
+end

data/lib/twig/token_parser/include.rb

@@ -4,7 +4,7 @@ module Twig
   module TokenParser
     class Include < TokenParser::Base
       def parse(token)
-        expr = parser.expression_parser.parse_expression
+        expr = parser.parse_expression
         variables, only, ignore_missing = parse_arguments
 
         Node::Include.new(
@@ -34,7 +34,7 @@ module Twig
 
         variables = nil
         if stream.next_if(Token::NAME_TYPE, 'with')
-          variables = parser.expression_parser.parse_expression
+          variables = parser.parse_expression
         end
 
         only = false