papercraft 1.1 → 1.3

data/lib/papercraft/compiler.rb

@@ -1,428 +1,263 @@
 # frozen_string_literal: true
 
-module Papercraft
-  # The Compiler class compiles Papercraft templates
-  class Compiler
-    DEFAULT_CODE_BUFFER_CAPACITY = 8192
-    DEFAULT_EMIT_BUFFER_CAPACITY = 4096
-
-    def initialize
-      @level = 1
-      @code_buffer = String.new(capacity: DEFAULT_CODE_BUFFER_CAPACITY)
-    end
-
-    def emit_output
-      @output_mode = true
-      yield
-      @output_mode = false
-    end
-
-    def emit_code_line_break
-      return if @code_buffer.empty?
-
-      @code_buffer << "\n" if @code_buffer[-1] != "\n"
-      @line_break = nil
-    end
-
-    def emit_literal(lit)
-      if @output_mode
-        emit_code_line_break if @line_break
-        @emit_buffer ||= String.new(capacity: DEFAULT_EMIT_BUFFER_CAPACITY)
-        @emit_buffer << lit
-      else
-        emit_code(lit)
+require 'cgi'
+require 'escape_utils'
+require 'sirop'
+
+class Papercraft::Compiler < Sirop::Sourcifier
+  module AuxMethods
+    def format_html_attr(tag)
+      tag.to_s.tr('_', '-')
+    end
+  
+    def format_html_attrs(attrs)
+      attrs.reduce(+'') do |html, (k, v)|
+        html << ' ' if !html.empty?
+        html << "#{format_html_attr(k)}=\"#{v}\""
       end
     end
 
-    def emit_text(str, encoding: :html)
-      emit_code_line_break if @line_break
-      @emit_buffer ||= String.new(capacity: DEFAULT_EMIT_BUFFER_CAPACITY)
-      @emit_buffer << encode(str, encoding).inspect[1..-2]
-    end
-
-    def encode(str, encoding)
-      case encoding
-      when :html
-        __html_encode__(str)
-      when :uri
-        __uri_encode__(str)
+    def render_emit_call(o, *a, **b, &block)
+      case o
+      when nil
+        # do nothing
+      when Papercraft::Template
+        o.render(*a, **b, &block)
+      when ::Proc
+        Papercraft.html(&o).render(*a, **b, &block)
       else
-        raise "Invalid encoding #{encoding.inspect}"
+        o.to_s
       end
     end
+  end
+  
+  Papercraft.extend(AuxMethods)
 
-    def emit_expression
-      if @output_mode
-        emit_literal('#{__html_encode__(')
-        yield
-        emit_literal(')}')
-      else
-        yield
-      end
-    end
+  def initialize
+    super
+    @html_buffer = +''
+  end
 
-    def flush_emit_buffer
-      return if !@emit_buffer
+  def compile(node)
+    @root_node = node
+    inject_buffer_parameter(node)
 
-      @code_buffer << "#{'  ' * @level}__buffer__ << \"#{@emit_buffer}\"\n"
-      @emit_buffer = nil
-      true
-    end
+    @buffer.clear
+    @html_buffer.clear
+    visit(node)
+    @buffer
+  end
 
-    def emit_code(code)
-      if flush_emit_buffer || @line_break
-        emit_code_line_break if @line_break
-        @code_buffer << "#{'  ' * @level}#{code}"
-      else
-        if @code_buffer.empty? || (@code_buffer[-1] == "\n")
-          @code_buffer << "#{'  ' * @level}#{code}"
-        else
-          @code_buffer << "#{code}"
-        end
-      end
-    end
+  def inject_buffer_parameter(node)
+    node.inject_parameters('__buffer__')
+  end
 
-    def compile(template)
-      @block = template.to_proc
-      ast = RubyVM::AbstractSyntaxTree.of(@block)
-      # Compiler.pp_ast(ast)
-      parse(ast)
-      flush_emit_buffer
-      self
-    end
+  def embed_visit(node, pre = '', post = '')
+    tmp_last_loc_start = @last_loc_start
+    tmp_last_loc_end = @last_loc_end
+    @last_loc_start = loc_start(node.location)
+    @last_loc_end = loc_end(node.location)
+
+    @embed_mode = true
+    tmp_buffer = @buffer
+    @buffer = +''
+    visit(node)
+    @embed_mode = false
+    @html_buffer << "#{pre}#{@buffer}#{post}"
+    @buffer = tmp_buffer
+
+    @last_loc_start = tmp_last_loc_start
+    @last_loc_end = tmp_last_loc_end
+  end
 
-    attr_reader :code_buffer
+  def html_embed_visit(node)
+    embed_visit(node, '#{CGI.escapeHTML((', ').to_s)}')
+  end
 
-    def to_code
-      "->(__buffer__, __context__) do\n#{@code_buffer}end"
+  def tag_attr_embed_visit(node, key)
+    if key
+      embed_visit(node, '#{Papercraft.format_html_attr(', ')}')
+    else
+      embed_visit(node, '#{', '}')
     end
+  end
 
-    def to_proc
-      @block.binding.eval(to_code)
-    end
+  def emit_code(loc, semicolon: false)
+    flush_html_buffer if !@embed_mode
+    super
+  end
 
-    def parse(node)
-      @line_break = @last_node && node.first_lineno != @last_node.first_lineno
-      @last_node = node
-      # puts "- parse(#{node.type}) (break: #{@line_break.inspect})"
-      send(:"parse_#{node.type.downcase}", node)
-    end
+  def emit_html(str)
+    @html_buffer << str
+  end
 
-    def parse_scope(node)
-      parse(node.children[2])
-    end
+  def flush_html_buffer
+    return if @html_buffer.empty?
 
-    def parse_iter(node)
-      call, scope = node.children
-      if call.type == :FCALL
-        parse_fcall(call, scope)
-      else
-        parse(call)
-        emit_code(" do")
-        args = scope.children[0]
-        emit_code(" |#{args.join(', ')}|") if args
-        emit_code("\n")
-        @level += 1
-        parse(scope)
-        flush_emit_buffer
-        @level -= 1
-        emit_code("end\n")
-      end
+    if @last_loc_start
+      adjust_whitespace(@html_location_start) if @html_location_start
     end
-
-    def parse_ivar(node)
-      ivar = node.children.first.match(/^@(.+)*/)[1]
-      emit_literal("__context__[:#{ivar}]")
+    if @defer_proc_mode
+      @buffer << "__b__ << \"#{@html_buffer}\""
+    elsif @defer_mode
+      @buffer << "__parts__ << \"#{@html_buffer}\""
+    else
+      @buffer << "__buffer__ << \"#{@html_buffer}\""
     end
+    @html_buffer.clear
+    @last_loc_end = loc_end(@html_location_end) if @html_location_end
 
-    def parse_fcall(node, block = nil)
-      tag, args = node.children
-      args = args.children.compact if args
-      text = fcall_inner_text_from_args(args)
-      atts = fcall_attributes_from_args(args)
-      if block
-        emit_tag(tag, atts) { parse(block) }
-      elsif text
-        emit_tag(tag, atts) do
-          emit_output do
-            if text.is_a?(String)
-              emit_text(text)
-            else
-              emit_expression { parse(text) }
-            end
-          end
-        end
-      else
-        emit_tag(tag, atts)
-      end
-    end
+    @html_location_start = nil
+    @html_location_end = nil
+  end
 
-    def fcall_inner_text_from_args(args)
-      return nil if !args
-
-      first = args.first
-      case first.type
-      when :STR
-        first.children.first
-      when :LIT
-        first.children.first.to_s
-      when :HASH
-        nil
-      else
-        first
-      end
-    end
+  def visit_call_node(node)
+    return super if node.receiver || @embed_mode
 
-    def fcall_attributes_from_args(args)
-      return nil if !args
+    @html_location_start ||= node.location
 
-      last = args.last
-      (last.type == :HASH) ? last : nil
+    case node.name
+    when :text
+      emit_html_text(node)
+    when :emit
+      emit_html_emit(node)
+    when :emit_yield
+      raise NotImplementedError, "emit_yield is not yet supported in compiled templates"
+    when :defer
+      emit_html_deferred(node)
+    else
+      emit_html_tag(node)
     end
 
-    def emit_tag(tag, atts, &block)
-      emit_output do
-        if atts
-          emit_literal("<#{tag}")
-          emit_tag_attributes(atts)
-          emit_literal(block ? '>' : '/>')
-        else
-          emit_literal(block ? "<#{tag}>" : "<#{tag}/>")
-        end
-      end
-      if block
-        block.call
-        emit_output { emit_literal("</#{tag}>") }
-      end
-    end
+    @html_location_end = node.location
+  end
 
-    def emit_tag_attributes(atts)
-      list = atts.children.first.children
-      while true
-        key = list.shift
-        break unless key
-
-        value = list.shift
-        value_type = value.type
-        case value_type
-        when :FALSE, :NIL
-          next
-        end
-
-        emit_literal(' ')
-        emit_tag_attribute_key(key)
-        next if value_type == :TRUE
-
-        emit_literal('=\"')
-        emit_tag_attribute_value(value, key)
-        emit_literal('\"')
-      end
-    end
+  def tag_args(node)
+    args = node.arguments&.arguments
+    return nil if !args
 
-    def emit_tag_attribute_key(key)
-      case key.type
-      when :STR
-        emit_literal(key.children.first)
-      when :LIT
-        emit_literal(key.children.first.to_s)
-      when :NIL
-        emit_literal('nil')
-      else
-        emit_expression { parse(key) }
-      end
+    if args[0]&.is_a?(Prism::KeywordHashNode)
+      [nil, args[0]]
+    elsif args[1]&.is_a?(Prism::KeywordHashNode)
+      args
+    else
+      [args && args[0], nil]
     end
+  end
 
-    def emit_tag_attribute_value(value, key)
-      case value.type
-      when :STR
-        encoding = (key.type == :LIT) && (key.children.first == :href) ? :uri : :html
-        emit_text(value.children.first, encoding: encoding)
-      when :LIT
-        emit_text(value.children.first.to_s)
-      else
-        parse(value)
-      end
-    end
+  def emit_tag_open(node, attrs)
+    emit_html("<#{node.name}")
+    emit_tag_attributes(node, attrs) if attrs
+    emit_html(">")
+  end
 
-    def parse_call(node)
-      receiver, method, args = node.children
-      if receiver.type == :VCALL && receiver.children == [:context]
-        emit_literal('__context__')
-      else
-        parse(receiver)
-      end
-      if method == :[]
-        emit_literal('[')
-        args = args.children.compact
-        while true
-          arg = args.shift
-          break unless arg
-
-          parse(arg)
-          emit_literal(', ') if !args.empty?
-        end
-        emit_literal(']')
-      else
-        emit_literal('.')
-        emit_literal(method.to_s)
-        if args
-          emit_literal('(')
-          args = args.children.compact
-          while true
-            arg = args.shift
-            break unless arg
-
-            parse(arg)
-            emit_literal(', ') if !args.empty?
-          end
-          emit_literal(')')
-        end
-      end
-    end
+  def emit_tag_close(node)
+    emit_html("</#{node.name}>")
+  end
 
-    def parse_str(node)
-      str = node.children.first
-      emit_literal(str.inspect)
-    end
+  def emit_tag_open_close(node, attrs)
+    emit_html("<#{node.name}")
+    emit_tag_attributes(node, attrs) if attrs
+    emit_html("/>")
+  end
 
-    def parse_lit(node)
-      value = node.children.first
-      emit_literal(value.inspect)
+  def emit_tag_inner_text(node)
+    case node
+    when Prism::StringNode, Prism::SymbolNode
+      @html_buffer << CGI.escapeHTML(node.unescaped)
+    else
+      html_embed_visit(node)
     end
+  end
 
-    def parse_true(node)
-      emit_expression { emit_literal('true') }
-    end
+  def emit_tag_attributes(node, attrs)
+    attrs.elements.each do |e|
+      emit_html(" ")
 
-    def parse_false(node)
-      emit_expression { emit_literal('true') }
+      if e.is_a?(Prism::AssocSplatNode)
+        embed_visit(e.value, '#{Papercraft.format_html_attrs(', ')}')
+      else
+        emit_tag_attribute_node(e.key, true)
+        emit_html('=\"')
+        emit_tag_attribute_node(e.value)
+        emit_html('\"')
+      end  
     end
+  end
 
-    def parse_list(node)
-      emit_literal('[')
-      items = node.children.compact
-      while true
-        item = items.shift
-        break unless item
-
-        parse(item)
-        emit_literal(', ') if !items.empty?
-      end
-      emit_literal(']')
+  def emit_tag_attribute_node(node, key = false)
+    case node
+    when Prism::StringNode, Prism::SymbolNode
+      value = node.unescaped
+      value = Papercraft.format_html_attr(value) if key
+      @html_buffer << value
+    else
+      tag_attr_embed_visit(node, key)
     end
+  end
 
-    def parse_vcall(node)
-      tag = node.children.first
-      emit_tag(tag, nil)
+  def emit_html_tag(node)
+    inner_text, attrs = tag_args(node)
+    block = node.block
+
+    if inner_text
+      emit_tag_open(node, attrs)
+      emit_tag_inner_text(inner_text)
+      emit_tag_close(node)
+    elsif block
+      emit_tag_open(node, attrs)
+      visit(block.body)
+      @html_location_start ||= node.block.closing_loc
+      emit_tag_close(node)
+    else
+      emit_tag_open_close(node, attrs)
     end
+  end
 
-    def parse_opcall(node)
-      left, op, right = node.children
-      parse(left)
-      emit_literal(" #{op} ")
-      right.children.compact.each { |c| parse(c) }
-    end
+  def emit_html_text(node)
+    args = node.arguments&.arguments
+    return nil if !args
 
-    def parse_block(node)
-      node.children.each { |c| parse(c) }
-    end
+    emit_tag_inner_text(args[0])
+  end
 
-    def parse_if(node)
-      cond, then_branch, else_branch = node.children
-      if @output_mode
-        emit_if_output(cond, then_branch, else_branch)
-      else
-        emit_if_code(cond, then_branch, else_branch)
-      end
-    end
+  def emit_html_emit(node)
+    args = node.arguments&.arguments
+    return nil if !args
 
-    def parse_unless(node)
-      cond, then_branch, else_branch = node.children
-      if @output_mode
-        emit_unless_output(cond, then_branch, else_branch)
-      else
-        emit_unless_code(cond, then_branch, else_branch)
-      end
-    end
+    embed_visit(node.arguments, '#{Papercraft.render_emit_call(', ')}')
+  end
 
-    def emit_if_output(cond, then_branch, else_branch)
-      parse(cond)
-      emit_literal(" ? ")
-      parse(then_branch)
-      emit_literal(" : ")
-      if else_branch
-        parse(else_branch)
-      else
-        emit_literal(nil)
-      end
-    end
+  def emit_html_deferred(node)
+    raise NotImplementedError, "#defer in embed mode is not supported in compiled templates" if @embed_mode
 
-    def emit_unless_output(cond, then_branch, else_branch)
-      parse(cond)
-      emit_literal(" ? ")
-      if else_branch
-        parse(else_branch)
-      else
-        emit_literal(nil)
-      end
-      emit_literal(" : ")
-      parse(then_branch)
-    end
+    block = node.block
+    return if not block
 
-    def emit_if_code(cond, then_branch, else_branch)
-      emit_code('if ')
-      parse(cond)
-      emit_code("\n")
-      @level += 1
-      parse(then_branch)
-      flush_emit_buffer
-      @level -= 1
-      if else_branch
-        emit_code("else\n")
-        @level += 1
-        parse(else_branch)
-        flush_emit_buffer
-        @level -= 1
-      end
-      emit_code("end\n")
-    end
+    setup_defer_mode if !@defer_mode
 
-    def emit_unless_code(cond, then_branch, else_branch)
-      emit_code('unless ')
-      parse(cond)
-      emit_code("\n")
-      @level += 1
-      parse(then_branch)
-      flush_emit_buffer
-      @level -= 1
-      if else_branch
-        emit_code("else\n")
-        @level += 1
-        parse(else_branch)
-        flush_emit_buffer
-        @level -= 1
-      end
-      emit_code("end\n")
-    end
+    flush_html_buffer
+    @buffer << ';__parts__ << ->(__b__) '
+    @defer_proc_mode = true
+    visit(node.block)
+    @defer_proc_mode = nil
+  end
 
-    def parse_dvar(node)
+  DEFER_PREFIX_EMPTY = "; __parts__ = []"
+  DEFER_PREFIX_NOT_EMPTY = "; __parts__ = [__buffer__.dup]; __buffer__.clear"
+  DEFER_POSTFIX = ";__parts__.each { |p| p.is_a?(Proc) ? p.(__buffer__) : (__buffer__ << p) }"
 
-      emit_literal(node.children.first.to_s)
+  def setup_defer_mode
+    @defer_mode = true
+    if @html_buffer && !@html_buffer.empty?
+      @buffer << DEFER_PREFIX_NOT_EMPTY
+    else
+      @buffer << DEFER_PREFIX_EMPTY
     end
 
-    def self.pp_ast(node, level = 0)
-      case node
-      when RubyVM::AbstractSyntaxTree::Node
-        puts "#{'  ' * level}#{node.type.inspect}"
-        node.children.each { |c| pp_ast(c, level + 1) }
-      when Array
-        puts "#{'  ' * level}["
-        node.each { |c| pp_ast(c, level + 1) }
-        puts "#{'  ' * level}]"
-      else
-        puts "#{'  ' * level}#{node.inspect}"
-        return
-      end
+    @root_node.after_body do
+      flush_html_buffer
+      @buffer << DEFER_POSTFIX
     end
   end
 end