twig_ruby 0.0.1 → 0.0.3

data/lib/twig/parser.rb

@@ -6,25 +6,92 @@ module Twig
   class Parser
     attr_reader :stream, :block_stack
 
+    # @return [Environment]
+    attr_reader :environment
+
+    STACKABLE = %i[
+      stream
+      parent
+      blocks
+      block_stack
+      macros
+      imported_symbols
+      traits
+      embedded_templates
+      ignore_unknown_twig_callables
+    ].freeze
+
     # @param [Environment] environment
     def initialize(environment)
       @environment = environment
+      @parsers = environment.expression_parsers
+      @stack = []
     end
 
     # @param [TokenStream] stream
+    # @return [Node::Module]
     def parse(stream, test = nil, drop_needle: false)
+      # Save the current value to stack
+      frame = {}
+      STACKABLE.each do |attr|
+        frame[attr] = instance_variable_get("@#{attr}")
+      end
+
+      @stack << frame
       @stream = stream
       @parent = nil
+      @traits = AutoHash.new
+      @macros = {}
       @blocks = {}
+      @embedded_templates = AutoHash.new
       @block_stack = []
       @imported_symbols = [{}]
+      @ignore_unknown_twig_callables = false
+
+      begin
+        body = subparse(test, drop_needle:)
+
+        if !@parent.nil? && (body = filter_body_nodes(body)).nil?
+          body = Node::Empty.new
+        end
+      rescue Error::Syntax => e
+        unless e.source_context
+          e.source_context = stream.source
+        end
+
+        unless e.lineno
+          e.lineno = stream.current.lineno
+        end
+
+        raise e
+      end
 
-      body = subparse(test, drop_needle:)
+      node = Node::Module.new(
+        Node::Body.new({ 0 => body }),
+        @parent,
+        @blocks.empty? ? Node::Empty.new : Node::Nodes.new(@blocks),
+        @macros.empty? ? Node::Empty.new : Node::Nodes.new(@macros),
+        @traits.empty? ? Node::Empty.new : Node::Nodes.new(@traits),
+        @embedded_templates.empty? ? Node::Empty.new : Node::Nodes.new(@embedded_templates),
+        stream.source
+      )
 
-      Node::Module.new(body, @parent, Node::Nodes.new(@blocks), stream.source)
+      @visitors ||= environment.node_visitors
+
+      node = NodeTraverser.
+        new(environment, @visitors).
+        traverse(node)
+
+      # Restore stack
+      frame = @stack.pop
+      STACKABLE.each do |attr|
+        instance_variable_set("@#{attr}", frame[attr])
+      end
+
+      node
     end
 
-    # @param [Proc] test
+    # @param [Method, nil] test
     # @return [Node::Base]
     def subparse(test, drop_needle: false)
       lineno = current_token.lineno
@@ -37,7 +104,7 @@ module Twig
           rv.add(Node::Text.new(token.value, token.lineno))
         when Token::VAR_START_TYPE
           token = stream.next
-          expr = expression_parser.parse_expression
+          expr = parse_expression
           stream.expect(Token::VAR_END_TYPE)
 
           rv.add(Node::Print.new(expr, token.lineno))
@@ -56,11 +123,22 @@ module Twig
             return Node::Nodes.new(rv, lineno)
           end
 
-          # @todo Check that there is a token parser for this token value
           subparser = @environment.token_parser(token.value)
 
           unless subparser
-            raise Error::Syntax.new("Unexpected '#{token.value}' tag.", token.lineno, stream.source)
+            if test.nil?
+              raise Error::Syntax.new("Unknown \"#{token.value}\" tag.", token.lineno, stream.source)
+            else
+              e = Error::Syntax.new("Unexpected \"#{token.value}\" tag", token.lineno, stream.source)
+
+              if test.respond_to?(:receiver) && (receiver = test.receiver) && receiver.is_a?(Twig::TokenParser::Base)
+                e.append_message(
+                  " (expecting closing tag for the \"#{receiver.tag}\" tag defined near line #{lineno})."
+                )
+              end
+
+              raise e
+            end
           end
 
           stream.next
@@ -80,16 +158,113 @@ module Twig
       Node::Nodes.new(rv)
     end
 
+    def subparse_ignore_unknown_twig_callables(test, drop_needle: false)
+      previous = @ignore_unknown_twig_callables
+      @ignore_unknown_twig_callables = true
+
+      begin
+        subparse(test, drop_needle:)
+      ensure
+        @ignore_unknown_twig_callables = previous
+      end
+    end
+
     # @return [Token]
     def current_token
       stream.current
     end
 
+    def parse_expression(precedence = 0)
+      token = current_token
+      if token.test(Token::OPERATOR_TYPE) && (parser = parsers.by_name(:prefix, token.value))
+        stream.next
+        expr = parser.parse(self, token)
+      else
+        expr = parsers.by_class(ExpressionParser::Prefix::Literal.name).parse(self, token)
+      end
+
+      token = current_token
+      while token.test(Token::OPERATOR_TYPE) &&
+            (parser = parsers.by_name(:infix, token.value)) &&
+            parser.precedence >= precedence
+
+        stream.next
+        expr = parser.parse(self, expr, token)
+        token = current_token
+      end
+
+      expr
+    end
+
+    # @return [TwigFilter]
+    def filter(name, lineno)
+      unless (filter = environment.filter(name))
+        unless ignore_unknown_twig_callables?
+          raise Error::Syntax.new("Unknown '#{name}' filter.", lineno, stream.source)
+        end
+
+        filter = TwigFilter.new(name, -> {})
+      end
+
+      filter
+    end
+
+    # @return [TwigFunction, Node::Expression::HelperMethod]
+    def function(name, args, lineno)
+      unless (function = environment.function(name))
+        if ignore_unknown_twig_callables?
+          return TwigFunction.new(name, -> {})
+        elsif environment.allow_helper_methods?
+          return Node::Expression::HelperMethod.new(name, args, lineno)
+        else
+          raise Error::Syntax.new("Unknown \"#{name}\" function.", lineno, stream.source)
+        end
+      end
+
+      function
+    end
+
+    # @param [Integer] line
+    # @return [TwigTest]
+    def test(line)
+      name = stream.expect(Token::NAME_TYPE).value
+
+      if stream.test(Token::NAME_TYPE)
+        # try 2 word tests
+        name = "#{name} #{current_token.value}"
+
+        if (test = environment.test(name))
+          stream.next
+        end
+      else
+        test = environment.test(name)
+      end
+
+      if test.nil? && ignore_unknown_twig_callables?
+        test = TwigTest.new(name, -> {})
+      end
+
+      unless test
+        raise Error::Syntax.new("Unknown #{name} test.", line, stream.source)
+      end
+
+      test
+    end
+
     # @return [ExpressionParser]
     def expression_parser
       @expression_parser ||= ExpressionParser.new(self, @environment)
     end
 
+    # @return [Boolean]
+    def inheritance?
+      @parent || @traits.length.positive?
+    end
+
+    def main_scope?
+      @imported_symbols.one?
+    end
+
     def push_local_scope
       @imported_symbols.unshift({})
     end
@@ -98,6 +273,26 @@ module Twig
       @imported_symbols.shift
     end
 
+    def add_imported_symbol(type, symbol_alias, name = nil, internal_ref = nil)
+      @imported_symbols[0][type] ||= {}
+      @imported_symbols[0][type][symbol_alias] = { name:, node: internal_ref }
+    end
+
+    def imported_symbol(type, symbol_alias)
+      if (symbol = @imported_symbols.dig(0, type, symbol_alias))
+        symbol
+      else
+        @imported_symbols.dig(-1, type, symbol_alias)
+      end
+    end
+
+    # @param [Node::Module] template
+    def embed_template(template)
+      template.index = rand(2**32)
+
+      @embedded_templates << template
+    end
+
     def peek_block_stack
       @block_stack[-1]
     end
@@ -114,9 +309,28 @@ module Twig
       @blocks.key?(name)
     end
 
-    # @todo type value as BlockNode and also set it to a BodyNode
+    def add_trait(trait)
+      @traits << trait
+    end
+
+    # @param [String] name
+    # @param [Node::Macro] node
+    def set_macro(name, node)
+      @macros[name] = node
+    end
+
+    # @param [String] name
+    # @param [Node::Body] value
     def set_block(name, value)
-      @blocks[name] = value
+      if @blocks.key?(name)
+        raise Error::Syntax.new(
+          "The block '#{name}' has already been defined line #{@blocks[name].lineno}.",
+          current_token.lineno,
+          @blocks[name].source_context
+        )
+      end
+
+      @blocks[name] = Node::Body.new({ 0 => value }, {}, value.lineno)
     end
 
     # @param [Node::Base] parent
@@ -127,5 +341,64 @@ module Twig
 
       @parent = parent
     end
+
+    def ignore_unknown_twig_callables?
+      @ignore_unknown_twig_callables
+    end
+
+    private
+
+    # @return [ExpressionParser::ExpressionParsers]
+    attr_reader :parsers
+
+    def filter_body_nodes(node, nested: false)
+      # check that the body does not contain non-empty output nodes
+      if (node.is_a?(Node::Text) && !node.attributes[:data].match?(/\A[[:space:]]*\z/)) ||
+         (!node.is_a?(Node::Text) && !node.is_a?(Node::BlockReference) && node.is_a?(Node::Output))
+        if node.to_s.include?("\xEF\xBB\xBF")
+          t = node.attributes[:data][3..]
+          # bypass empty nodes starting with a BOM
+          if t == '' || t.match?(/\A[[:space:]]*\z/)
+            return nil
+          end
+        end
+
+        raise Error::Syntax.new(
+          'A template that extends another one cannot include content outside Twig blocks. Did you forget ' \
+          'to put the content inside a {% block %} tag?',
+          node.lineno,
+          stream.source
+        )
+      end
+
+      # Bypass nodes that "capture" the output
+      if node.is_a?(Node::Set)
+        return node
+      end
+
+      # "block" tags that are not captured (see above) are only used for defining
+      # the content of the block. In such a case, nesting it does not work as
+      # expected as the definition is not part of the default template code flow.
+      if nested && node.is_a?(Node::BlockReference)
+        raise Error::Syntax.new(
+          'A block definition cannot be nested under non-capturing nodes.',
+          node.lineno,
+          stream.source
+        )
+      end
+
+      if node.is_a?(Node::Output)
+        return nil
+      end
+
+      nested ||= !node.is_a?(Node::Nodes)
+      node.nodes.each do |k, n|
+        if filter_body_nodes(n, nested: nested).nil?
+          node.nodes.delete(k)
+        end
+      end
+
+      node
+    end
   end
 end

data/lib/twig/rails/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Twig
+  module Rails
+    class Config
+      def self.defaults
+        ActiveSupport::OrderedOptions.new.merge!({
+          root: ::Rails.root,
+          paths: %w[./ app/views/],
+          debug: ::Rails.env.development?,
+          allow_helper_methods: true,
+          cache: ::Rails.root.join('tmp/cache/twig').to_s,
+          charset: 'UTF-8',
+          strict_variables: true,
+          autoescape: :name,
+          auto_reload: nil,
+          loader: lambda do
+            ::Twig::Loader::Filesystem.new(
+              current.root,
+              current.paths
+            )
+          end,
+        })
+      end
+
+      def self.current
+        self.configuration ||= defaults
+      end
+
+      class_attribute :configuration
+    end
+  end
+end

data/lib/twig/rails/engine.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rails'
+require 'English'
+require 'twig/rails/config'
+require 'twig/rails/renderer'
+
+module Twig
+  # @return [Environment]
+  def self.environment
+    @@environment ||= begin
+      options = ::Twig::Rails::Config.current.slice(
+        :autoescape,
+        :cache,
+        :debug,
+        :allow_helper_methods,
+        :charset,
+        :strict_variables,
+        :auto_reload
+      )
+
+      ::Twig::Environment.new(loader, options).tap do |env|
+        env.add_extension(::Twig::Extension::Rails.new)
+        env.add_extension(::Twig::Extension::Debug.new) if env.debug?
+      end
+    end
+  end
+
+  def self.loader
+    @@loader ||= ::Twig::Rails::Config.current.loader.call
+  end
+
+  module Rails
+    class Engine < ::Rails::Engine
+      config.before_configuration do |app|
+        app.config.twig = Config.current
+      end
+
+      initializer 'twig_ruby.configure_rails_initialization' do
+        ActionView::Template.register_template_handler :twig, Renderer.new
+      end
+    end
+  end
+end

data/lib/twig/rails/renderer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Twig
+  module Rails
+    class Renderer
+      def call(template, source)
+        <<~TEMPLATE
+          ::Twig.
+            environment.
+            load("#{template.short_identifier}").
+            render(
+              local_assigns,
+              call_context: self,
+              output_buffer: @output_buffer
+            )
+
+          @output_buffer
+        TEMPLATE
+      end
+
+      def translate_location(spot, _backtrace_location, source)
+        exception = $ERROR_INFO
+
+        return nil unless exception.is_a?(::ActionView::Template::Error)
+
+        twig_exception = exception.cause
+
+        return nil unless twig_exception.is_a?(::Twig::Error::Base)
+
+        lineno = twig_exception.lineno
+        lineno = 1 if lineno == -1
+
+        spot[:script_lines] = twig_exception.source_context&.code&.lines || source.lines
+        spot[:first_lineno] = spot[:last_lineno] = lineno
+        spot[:first_column] = spot[:last_column] = 0
+
+        spot
+      end
+    end
+  end
+end

data/lib/twig/runtime/argument_spreader.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Twig
+  module Runtime
+    class ArgumentSpreader
+      # @param [Method] method
+      def initialize(method)
+        @method = method
+      end
+
+      # like {{ ["Hello", "World"] | join(glue: " ") }}
+      def call(*arguments, **kwargs)
+        positional = []
+
+        arguments.each do |v|
+          if v.is_a?(Spread)
+            if v.array?
+              positional = [*positional, *v.value]
+            else
+              kwargs = kwargs.merge(v.value)
+            end
+          else
+            positional << v
+          end
+        end
+
+        kwargs = kwargs.transform_keys(&:to_sym)
+
+        if positional.empty? && kwargs.empty?
+          method.call
+        elsif positional.length.positive? && kwargs.empty?
+          method.call(*positional)
+        elsif positional.empty? && kwargs.length.positive?
+          method.call(**kwargs)
+        elsif positional.length.positive? && kwargs.length.positive?
+          method.call(*positional, **kwargs)
+        end
+      end
+
+      private
+
+      # @return [Method]
+      attr_reader :method
+    end
+  end
+end

data/lib/twig/runtime/context.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Twig
+  module Runtime
+    class Context < Hash
+      attr_reader :call_context
+
+      def initialize(initial_context = {}, output_buffer: nil, call_context: nil)
+        super()
+
+        output_buffer ||= OutputBuffer.new
+        @output_buffer_stack = [output_buffer]
+        @call_context = call_context
+        @popping = false
+
+        merge!(initial_context)
+      end
+
+      def original_buffer
+        output_buffer_stack.first
+      end
+
+      def merge!(other, overwrite: true)
+        return if other == []
+
+        unless other.is_a?(Hash)
+          raise "Must merge! another Hash, given #{other.class.name}"
+        end
+
+        other.each do |k, v|
+          if overwrite || !key?(k)
+            self[k] = v
+          end
+        end
+
+        self
+      end
+
+      def keep!(keys)
+        (self.keys - keys).each { |k| delete(k) }
+      end
+
+      def remove!(*keys)
+        keys.each { |k| delete(k) }
+      end
+
+      def merge(other, overwrite: true)
+        self.class.new(self, call_context:, output_buffer:).merge!(other, overwrite:)
+      end
+
+      def only(other)
+        self.class.new(other, call_context:, output_buffer:)
+      end
+
+      def push_stack
+        stack.push({ remove: [], replace: {} })
+      end
+
+      def pop_stack(new_only = false)
+        return unless stack.last
+
+        @popping = true
+
+        frame = stack.pop
+        frame[:remove].each do |k|
+          delete(k)
+        end
+
+        unless new_only
+          frame[:replace].each { |k, v| self[k] = v }
+        end
+
+        @popping = false
+      end
+
+      def output_buffer
+        output_buffer_stack.last
+      end
+
+      def push_output_buffer
+        output_buffer_stack.push(OutputBuffer.new)
+      end
+
+      def pop_output_buffer
+        output_buffer_stack.pop
+      end
+
+      def buffer_and_return(&)
+        push_output_buffer
+        yield
+        pop_output_buffer
+      end
+
+      def clear
+        # Copy everything to the replace stack
+        merge!(self)
+
+        # Clear the hash
+        super
+      end
+
+      def dup
+        self.class.new(to_h, call_context:, output_buffer:)
+      end
+
+      def [](key)
+        super(key.to_sym)
+      end
+
+      def []=(key, value)
+        super if popping
+
+        key = key.to_sym
+
+        if (frame = stack.last)
+          super and return if frame[:replace].key?(key) || frame[:remove].include?(key)
+
+          if key?(key)
+            frame[:replace][key] = self[key]
+          else
+            frame[:remove].push(key)
+          end
+        end
+
+        super
+      end
+
+      # @return [Context]
+      def self.from(context = {}, output_buffer: nil, call_context: nil)
+        if context.is_a?(Context)
+          context
+        else
+          new(context, output_buffer:, call_context:)
+        end
+      end
+
+      def each(...)
+        to_h.each(...)
+      end
+
+      private
+
+      attr_reader :popping
+
+      def stack
+        @stack ||= []
+      end
+
+      def output_buffer_stack
+        @output_buffer_stack ||= []
+      end
+    end
+  end
+end