twig_ruby 0.0.1

data/lib/twig/node/module.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Module < Node::Base
+      def initialize(body, parent, blocks, source)
+        nodes = {
+          body:,
+          blocks:,
+        }
+        nodes[:parent] = parent if parent
+
+        super(nodes)
+
+        self.source_context = source
+      end
+
+      def compile(compiler)
+        class_begin = <<~CLASS
+          class Twig::#{compiler.environment.template_class(source_context.name)} < ::Twig::Template
+        CLASS
+
+        class_end = <<~CLASS
+          end
+        CLASS
+
+        compiler.
+          raw(class_begin).
+          indent.
+          write("def call(context = {}, blocks = {})\n").
+          indent
+
+        if nodes.key?(:parent)
+          compiler.
+            write('load_template(').
+            subcompile(nodes[:parent]).
+            raw(").render(context, block_list.merge(blocks));\n")
+        else
+          compiler.
+            subcompile(nodes[:body])
+        end
+
+        compiler.
+          write("@output_buffer\n").
+          outdent.
+          write("end\n\n").
+          subcompile(nodes[:blocks]).
+          outdent
+
+        compiler.
+          indent.
+          write("def block_list\n").
+          indent.
+          write("{\n").
+          indent
+
+        nodes[:blocks].nodes.each_value do |block|
+          compiler.
+            write("#{block.attributes[:name]}: self,\n")
+        end
+
+        compiler.
+          outdent.
+          write("}\n").
+          outdent.
+          write("end\n").
+          outdent
+
+        compiler.
+          raw(class_end)
+      end
+    end
+  end
+end

data/lib/twig/node/nodes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Nodes < Node::Base
+      # @param [Hash<Node::Base>] nodes
+      # @param [Integer] lineno
+      def initialize(nodes, lineno = 0)
+        super(nodes, {}, lineno)
+      end
+    end
+  end
+end

data/lib/twig/node/print.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Print < Node::Base
+      def initialize(expr, lineno)
+        super({ expr: }, {}, lineno)
+      end
+
+      def compile(compiler)
+        compiler.
+          write('@output_buffer.append = ').
+          subcompile(nodes[:expr]).
+          raw(";\n")
+      end
+    end
+  end
+end

data/lib/twig/node/text.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Text < Node::Base
+      # @param [String] data
+      # @param [Integer] lineno
+      def initialize(data, lineno = 0)
+        super({}, { data: }, lineno)
+      end
+
+      def compile(compiler)
+        compiler.
+          write('@output_buffer.safe_append = ').
+          string(attributes[:data]).
+          raw(";\n")
+      end
+    end
+  end
+end

data/lib/twig/node/yield.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Twig
+  module Node
+    class Yield < Node::Base
+      def initialize(expr, body, arguments, lineno)
+        arguments = arguments.empty? ? {} : { arguments: }
+        super({ expr:, body: }, arguments, lineno)
+      end
+
+      def compile(compiler)
+        compiler.
+          write('@output_buffer.append = (').
+          subcompile(nodes[:expr]).
+          raw(' do')
+
+        if attributes.key?(:arguments)
+          compiler.
+            raw(" |#{attributes[:arguments].join(', ')}|")
+        end
+
+        compiler.
+          raw("\n").
+          indent
+
+        if attributes.key?(:arguments)
+          compiler.
+            write("context.push_stack\n").
+            write('context.merge!({')
+
+          attributes[:arguments].each do |argument|
+            compiler.raw("#{argument}:,")
+          end
+
+          compiler.
+            raw("})\n")
+        end
+
+        compiler.
+          subcompile(nodes[:body]).
+          raw("\n")
+
+        if attributes.key?(:arguments)
+          compiler.
+            write("context.pop_stack\n")
+        end
+
+        compiler.
+          outdent.
+          write("end);\n")
+      end
+    end
+  end
+end

data/lib/twig/output_buffer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Twig
+  class OutputBuffer
+    def initialize
+      @buffer = +''
+    end
+
+    def append=(string)
+      unless string.nil?
+        string = string.to_s
+
+        @buffer << if string.html_safe?
+                     string
+                   else
+                     CGI.escapeHTML(string)
+                   end
+      end
+    end
+
+    def safe_append=(string)
+      @buffer << string.html_safe
+    end
+
+    def to_s
+      @buffer
+    end
+  end
+end

data/lib/twig/parser.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Twig
+  # @!attribute [r] stream
+  #   @return [TokenStream]
+  class Parser
+    attr_reader :stream, :block_stack
+
+    # @param [Environment] environment
+    def initialize(environment)
+      @environment = environment
+    end
+
+    # @param [TokenStream] stream
+    def parse(stream, test = nil, drop_needle: false)
+      @stream = stream
+      @parent = nil
+      @blocks = {}
+      @block_stack = []
+      @imported_symbols = [{}]
+
+      body = subparse(test, drop_needle:)
+
+      Node::Module.new(body, @parent, Node::Nodes.new(@blocks), stream.source)
+    end
+
+    # @param [Proc] test
+    # @return [Node::Base]
+    def subparse(test, drop_needle: false)
+      lineno = current_token.lineno
+      rv = AutoHash.new
+
+      until stream.eof?
+        case current_token.type
+        when Token::TEXT_TYPE
+          token = stream.next
+          rv.add(Node::Text.new(token.value, token.lineno))
+        when Token::VAR_START_TYPE
+          token = stream.next
+          expr = expression_parser.parse_expression
+          stream.expect(Token::VAR_END_TYPE)
+
+          rv.add(Node::Print.new(expr, token.lineno))
+        when Token::BLOCK_START_TYPE
+          stream.next
+          token = current_token
+
+          unless token.type == Token::NAME_TYPE
+            raise Error::Syntax.new('A block must start with a tag name.', token.lineno, stream.source)
+          end
+
+          if test&.call(token)
+            stream.next if drop_needle
+            return rv.values.first if rv.length == 1
+
+            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)
+          end
+
+          stream.next
+          subparser.parser = self
+          node = subparser.parse(token)
+
+          raise 'Cannot return nil from TokenParser' unless node
+
+          node.tag = subparser.tag
+
+          rv.add(node)
+        else
+          raise "Unable to parse token of type #{current_token.type}"
+        end
+      end
+
+      Node::Nodes.new(rv)
+    end
+
+    # @return [Token]
+    def current_token
+      stream.current
+    end
+
+    # @return [ExpressionParser]
+    def expression_parser
+      @expression_parser ||= ExpressionParser.new(self, @environment)
+    end
+
+    def push_local_scope
+      @imported_symbols.unshift({})
+    end
+
+    def pop_local_scope
+      @imported_symbols.shift
+    end
+
+    def peek_block_stack
+      @block_stack[-1]
+    end
+
+    def pop_block_stack
+      @block_stack.pop
+    end
+
+    def push_block_stack(name)
+      @block_stack << name
+    end
+
+    def block?(name)
+      @blocks.key?(name)
+    end
+
+    # @todo type value as BlockNode and also set it to a BodyNode
+    def set_block(name, value)
+      @blocks[name] = value
+    end
+
+    # @param [Node::Base] parent
+    def parent=(parent)
+      if @parent
+        raise Error::Syntax.new('Cannot extends twice', parent.lineno, parent.source_context)
+      end
+
+      @parent = parent
+    end
+  end
+end

data/lib/twig/railtie.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Twig
+  class RailsRenderer
+    def call(template, source)
+      <<~TEMPLATE
+        ::#{self.class.name}.
+          environment.
+          load_template("#{template.short_identifier}", call_context: self, output_buffer: @output_buffer).
+            render(local_assigns)
+
+        @output_buffer
+      TEMPLATE
+    end
+
+    def translate_location(spot, backtrace_location, source)
+      template = backtrace_location.path.delete_prefix(Rails.root.to_s)
+
+      # Attempt to recompile the template to find where the syntax error is
+      # otherwise just do what would have happened anyway
+      begin
+        self.class.environment.render_ruby(template)
+      rescue ::Twig::Error::Syntax => e
+        return spot.merge({
+          first_lineno: e.lineno,
+          last_lineno: e.lineno + 1,
+          script_lines: source.lines,
+        })
+      rescue StandardError
+        # Nothing, don't add another exception to the problem
+      end
+
+      spot
+    end
+
+    def self.loader
+      @loader ||= ::Twig::Loader::Filesystem.new(
+        Rails.root,
+        %w[/ /app/views]
+      )
+    end
+
+    def self.environment
+      options = {
+        cache: Rails.root.join('tmp/cache/twig').to_s,
+        debug: Rails.env.development?,
+      }
+
+      @environment ||= ::Twig::Environment.new(loader, options).tap do |env|
+        env.add_extension(::Twig::Extension::Rails.new)
+      end
+    end
+  end
+
+  class Railtie < ::Rails::Railtie
+    initializer 'twig_ruby.configure_rails_initialization' do
+      ActionView::Template.register_template_handler :twig, RailsRenderer.new
+    end
+  end
+end

data/lib/twig/source.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Twig
+  class Source
+    attr_reader :code, :name, :path
+
+    def initialize(code, name, path = '')
+      @code = code
+      @name = name
+      @path = path
+    end
+  end
+end

data/lib/twig/template.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Twig
+  # Base class for compiled templates
+  class Template
+    ARRAY_CALL = :array_call
+    METHOD_CALL = :method_call
+    ANY_CALL = :any_call
+
+    # @param [Environment] environment
+    def initialize(environment, call_context: nil, output_buffer: nil)
+      @environment = environment
+      @parents = {}
+      @blocks = {}
+      @call_context = call_context
+      @output_buffer = output_buffer || OutputBuffer.new
+    end
+
+    def call(context = {}, blocks = {})
+      raise 'call is not implemented'
+    end
+
+    def render(context = {}, blocks = {})
+      call(Context.new(context), blocks)
+    end
+
+    def yield_block(name, context = {}, blocks = {})
+      object = self
+
+      if blocks.key?(name)
+        object = blocks[name]
+      end
+
+      object.public_send(:"block_#{name}", context, blocks)
+    end
+
+    private
+
+    # @param [String] name
+    # @return ]Template]
+    def load_template(name, template_name = '', template_line = nil)
+      env.load_template(name, call_context: @call_context, output_buffer: @output_buffer)
+    end
+
+    # @return [Environment]
+    def env
+      @environment
+    end
+  end
+end

data/lib/twig/token.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Twig
+  class Token
+    EOF_TYPE = :eof
+    TEXT_TYPE = :text
+    BLOCK_START_TYPE = :block_start
+    VAR_START_TYPE = :var_start
+    BLOCK_END_TYPE = :block_end
+    VAR_END_TYPE = :var_end
+    NAME_TYPE = :name
+    SYMBOL_TYPE = :symbol
+    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
+
+    attr_reader :type, :value, :lineno
+
+    def initialize(type, value, lineno)
+      @type = type
+      @value = value
+      @lineno = lineno
+    end
+
+    # @param [Symbol | String] type
+    def test(type, values = nil)
+      if values.nil? && !type.is_a?(Symbol)
+        values = type
+        type = NAME_TYPE
+      end
+
+      @type == type && (
+        values.nil? ||
+          (values.is_a?(Array) && values.include?(@value)) ||
+          (@value == values)
+      )
+    end
+
+    def debug
+      [type, value]
+    end
+  end
+end

data/lib/twig/token_parser/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    class Base
+      # @return [Parser]
+      attr_accessor :parser
+
+      # @param [Token] token
+      def parse(token)
+        raise 'parse is not implemented'
+      end
+
+      # @return [String]
+      def tag
+        raise 'tag is not implemented'
+      end
+    end
+  end
+end

data/lib/twig/token_parser/block.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    # Marks a section of a template as being reusable.
+    #
+    #  {% block head %}
+    #    <link rel="stylesheet" href="style.css" />
+    #    <title>{% block title %}{% endblock %} - My Webpage</title>
+    #  {% endblock %}
+    class Block < Base
+      def parse(token)
+        lineno = token.lineno
+        stream = parser.stream
+        name = stream.expect(Token::NAME_TYPE).value
+        block = Node::Block.new(name, Node::Empty.new, lineno)
+
+        parser.set_block(name, block)
+        parser.push_local_scope
+        parser.push_block_stack(name)
+
+        if stream.next_if(Token::BLOCK_END_TYPE)
+          body = parser.subparse(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),
+          })
+        end
+
+        stream.expect(Token::BLOCK_END_TYPE)
+        block.nodes[:body] = body
+
+        parser.pop_block_stack
+        parser.pop_local_scope
+
+        Node::BlockReference.new(name, lineno)
+      end
+
+      def tag
+        'block'
+      end
+
+      private
+
+      def decide_block_end
+        ->(token) { token.test('endblock') }
+      end
+    end
+  end
+end

data/lib/twig/token_parser/extends.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    class Extends < TokenParser::Base
+      def parse(token)
+        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
+        end
+
+        parser.parent = parser.expression_parser.parse_expression
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        Node::Empty.new(token.lineno)
+      end
+
+      def tag
+        'extends'
+      end
+    end
+  end
+end

data/lib/twig/token_parser/for.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Twig
+  module TokenParser
+    #  {% for user in users %}
+    #    <li>{{ user.name }}</li>
+    #  {% endfor %}
+    class For < Base
+      def parse(token)
+        lineno = token.lineno
+        stream = parser.stream
+
+        targets = parser.expression_parser.parse_assignment_expression
+        stream.expect(Token::OPERATOR_TYPE, 'in')
+        seq = parser.expression_parser.parse_expression
+
+        stream.expect(Token::BLOCK_END_TYPE)
+        body = parser.subparse(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
+          else_expr = nil
+        end
+
+        stream.expect(Token::BLOCK_END_TYPE)
+
+        if targets.nodes.length > 1
+          key_target = targets.nodes[0]
+          key_target = Node::Expression::Variable::AssignContext.new(
+            key_target.attributes[:name],
+            key_target.lineno
+          )
+          value_target = targets.nodes[1]
+        else
+          key_target = Node::Expression::Variable::AssignContext.new('_key', lineno)
+          value_target = targets.nodes[0]
+        end
+
+        value_target = Node::Expression::Variable::AssignContext.new(
+          value_target.attributes[:name],
+          value_target.lineno
+        )
+
+        Node::For.new(key_target, value_target, seq, nil, body, else_expr, lineno)
+      end
+
+      def tag
+        'for'
+      end
+
+      private
+
+      def decide_for_fork
+        ->(token) { token.test(%w[else endfor]) }
+      end
+
+      def decide_for_end
+        ->(token) { token.test(%w[endfor]) }
+      end
+    end
+  end
+end