p2 2.0.1 → 2.2

data/lib/p2/compiler.rb

@@ -1,198 +1,21 @@
 # frozen_string_literal: true
 
-require 'cgi'
 require 'sirop'
-require 'digest/md5'
+require 'erb/escape'
 
-module P2
-  class TagNode
-    attr_reader :call_node, :location, :tag, :tag_location, :inner_text, :attributes, :block
-
-    def initialize(call_node, transformer)
-      @call_node = call_node
-      @location = call_node.location
-      @tag = call_node.name
-      prepare_block(transformer)
-
-      args = call_node.arguments&.arguments
-      return if !args
-
-      if @tag == :tag
-        @tag = args[0]
-        args = args[1..]
-      end
-
-      if args.size == 1 && args.first.is_a?(Prism::KeywordHashNode)
-        @inner_text = nil
-        @attributes = args.first
-      else
-        @inner_text = args.first
-        @attributes = args[1].is_a?(Prism::KeywordHashNode) ? args[1] : nil
-      end
-    end
-
-    def accept(visitor)
-      visitor.visit_tag_node(self)
-    end
-
-    def prepare_block(transformer)
-      @block = call_node.block
-      if @block.is_a?(Prism::BlockNode)
-        @block = transformer.visit(@block)
-        offset = @location.start_offset
-        length = @block.opening_loc.start_offset - offset
-        @tag_location = @location.copy(start_offset: offset, length: length)
-      else
-        @tag_location = @location
-      end
-    end
-  end
-
-  class EmitNode
-    attr_reader :call_node, :location, :block
-
-    include Prism::DSL
-
-    def initialize(call_node, transformer)
-      @call_node = call_node
-      @location = call_node.location
-      @transformer = transformer
-      @block = call_node.block && transformer.visit(call_node.block)
-
-      lambda = call_node.arguments && call_node.arguments.arguments[0]
-      return unless lambda.is_a?(Prism::LambdaNode)
-
-      location = lambda.location
-      parameters = lambda.parameters
-      parameters_location = parameters&.location || location
-      params = parameters&.parameters
-      lambda = lambda_node(
-        location: location,
-        parameters: block_parameters_node(
-          location: parameters_location,
-          parameters: parameters_node(
-            location: parameters_location,
-            requireds: [
-              required_parameter_node(
-                location: ad_hoc_string_location('__buffer__'),
-                name: :__buffer__
-              ),
-              *params&.requireds
-            ],
-            optionals: transform_array(params&.optionals),
-            rest: transform(params&.rest),
-            posts: transform_array(params&.posts),
-            keywords: transform_array(params&.keywords),
-            keyword_rest: transform(params&.keyword_rest),
-            block: transform(params&.block)
-          )
-        ),
-        body: transformer.visit(lambda.body)
-      )
-      call_node.arguments.arguments[0] = lambda
-      # pp lambda_body: call_node.arguments.arguments[0]
-    end
-
-    def ad_hoc_string_location(str)
-      src = source(str)
-      Prism::DSL.location(source: src, start_offset: 0, length: str.bytesize)
-    end
-
-    def transform(node)
-      node && @transformer.visit(node)
-    end
-
-    def transform_array(array)
-      array ? array.map { @transformer.visit(it) } : []
-    end
-
-    def accept(visitor)
-      visitor.visit_emit_node(self)
-    end
-  end
+require_relative './compiler/nodes'
+require_relative './compiler/tag_translator'
 
-  class TextNode
-    attr_reader :call_node, :location
-
-    def initialize(call_node, _compiler)
-      @call_node = call_node
-      @location = call_node.location
-    end
-
-    def accept(visitor)
-      visitor.visit_text_node(self)
-    end
-  end
-
-  class DeferNode
-    attr_reader :call_node, :location, :block
-
-    def initialize(call_node, compiler)
-      @call_node = call_node
-      @location = call_node.location
-      @block = call_node.block && compiler.visit(call_node.block)
-    end
-
-    def accept(visitor)
-      visitor.visit_defer_node(self)
-    end
-  end
-
-  class CustomTagNode
-    attr_reader :tag, :call_node, :location, :block
-
-    def initialize(call_node, compiler)
-      @call_node = call_node
-      @tag = call_node.name
-      @location = call_node.location
-      @block = call_node.block && compiler.visit(call_node.block)
-    end
-
-    def accept(visitor)
-      visitor.visit_custom_tag_node(self)
-    end
-  end
-
-  class TagTransformer < Prism::MutationCompiler
-    include Prism::DSL
-
-    def self.transform(ast)
-      ast.accept(new)
-    end
-
-    def visit_call_node(node)
-      # We're only interested in compiling method calls without a receiver
-      return super(node) if node.receiver
-
-      case node.name
-      when :emit_yield
-        yield_node(
-          location: node.location,
-          arguments: node.arguments
-        )
-      when :raise
-        super(node)
-      when :emit, :e
-        EmitNode.new(node, self)
-      when :text
-        TextNode.new(node, self)
-      when :defer
-        DeferNode.new(node, self)
-      when :html5, :emit_markdown, :markdown
-        CustomTagNode.new(node, self)
-      else
-        TagNode.new(node, self)
-      end
-    end
-  end
-
-  class VerbatimSourcifier < Sirop::Sourcifier
-    def visit_tag_node(node)
-      visit(node.call_node)
-    end
-  end
-
-  class TemplateCompiler < Sirop::Sourcifier
+module P2
+  # A Compiler converts a template into an optimized form that generates HTML
+  # efficiently.
+  class Compiler < Sirop::Sourcifier
+    # Compiles the given proc, returning the generated source map and the
+    # generated optimized source code.
+    #
+    # @param proc [Proc] template
+    # @param wrap [bool] whether to wrap the generated code with a literal Proc definition
+    # @return [Array] array containing the source map and generated code
     def self.compile_to_code(proc, wrap: true)
       ast = Sirop.to_ast(proc)
 
@@ -200,18 +23,34 @@ module P2
       ast = ast.block if ast.is_a?(Prism::CallNode)
 
       compiler = new.with_source_map(proc, ast)
-      transformed_ast = TagTransformer.transform(ast.body)
+      transformed_ast = TagTranslator.transform(ast.body)
       compiler.format_compiled_template(transformed_ast, ast, wrap:, binding: proc.binding)
       [compiler.source_map, compiler.buffer]
     end
 
+    # Compiles the given template into an optimized Proc that generates HTML.
+    #
+    #     template = -> {
+    #       h1 'Hello, world!'
+    #     }
+    #     compiled = P2::Compiler.compile(template)
+    #     compiled.render #=> '<h1>Hello, world!'
+    #
+    # @param proc [Proc] template
+    # @param wrap [bool] whether to wrap the generated code with a literal Proc definition
+    # @return [Proc] compiled proc
     def self.compile(proc, wrap: true)
       source_map, code = compile_to_code(proc, wrap:)
+      if ENV['DEBUG'] == '1'
+        puts '*' * 40
+        puts code
+      end
       eval(code, proc.binding, source_map[:compiled_fn])
     end
 
     attr_reader :source_map
 
+    # Initializes a compiler.
     def initialize(**)
       super(**)
       @pending_html_parts = []
@@ -220,16 +59,27 @@ module P2
       @yield_used = nil
     end
 
+    # Initializes a source map.
+    #
+    # @param orig_proc [Proc] template proc
+    # @param orig_ast [Prism::Node] template AST
+    # @return [self]
     def with_source_map(orig_proc, orig_ast)
-      ast_digest = Digest::MD5.hexdigest(orig_ast.inspect)
+      compiled_fn = "::(#{orig_proc.source_location.join(':')})"
       @source_map = {
         source_fn: orig_proc.source_location.first,
-        compiled_fn: "::#{ast_digest}"
+        compiled_fn: compiled_fn
       }
-      @source_map_line_ofs = 1
+      @source_map_line_ofs = 2
       self
     end
 
+    # Formats the source code for a compiled template proc.
+    #
+    # @param ast [Prism::Node] translated AST
+    # @param orig_ast [Prism::Node] original template AST
+    # @param wrap [bool] whether to wrap the generated code with a literal Proc definition
+    # @return [String] compiled template source code
     def format_compiled_template(ast, orig_ast, wrap:, binding:)
       # generate source code
       @binding = binding
@@ -240,7 +90,7 @@ module P2
       source_code = @buffer
       @buffer = +''
       if wrap
-        emit("(#{@source_map.inspect}).then { |src_map| ->(__buffer__")
+        emit("# frozen_string_literal: true\n(#{@source_map.inspect}).then { |src_map| ->(__buffer__")
 
         params = orig_ast.parameters
         params = params&.parameters
@@ -252,11 +102,11 @@ module P2
         if @yield_used
           emit(', &__block__')
         end
-        
+
         emit(") do\n")
       end
       @buffer << source_code
-      emit_postlude
+      emit_defer_postlude if @defer_mode
       if wrap
         emit('; __buffer__')
         adjust_whitespace(orig_ast.closing_loc)
@@ -266,11 +116,10 @@ module P2
       @buffer
     end
 
-    def emit_code(loc, semicolon: false, chomp: false, flush_html: true)
-      flush_html_parts! if flush_html
-      super(loc, semicolon:, chomp: )
-    end
-
+    # Visits a tag node.
+    #
+    # @param node [P2::TagNode] node
+    # @return [void]
     def visit_tag_node(node)
       tag = node.tag
       if tag.is_a?(Symbol) && tag =~ /^[A-Z]/
@@ -292,19 +141,23 @@ module P2
 
       if node.inner_text
         if is_static_node?(node.inner_text)
-          emit_html(node.location, CGI.escape_html(format_literal(node.inner_text)))
+          emit_html(node.location, ERB::Escape.html_escape(format_literal(node.inner_text)))
         else
           convert_to_s = !is_string_type_node?(node.inner_text)
           if convert_to_s
-            emit_html(node.location, "#\{CGI.escape_html((#{format_code(node.inner_text)}).to_s)}")
+            emit_html(node.location, interpolated("ERB::Escape.html_escape((#{format_code(node.inner_text)}).to_s)"))
           else
-            emit_html(node.location, "#\{CGI.escape_html(#{format_code(node.inner_text)})}")
+            emit_html(node.location, interpolated("ERB::Escape.html_escape(#{format_code(node.inner_text)})"))
           end
         end
       end
       emit_html(node.location, format_html_tag_close(tag))
     end
 
+    # Visits a const tag node.
+    #
+    # @param node [P2::ConstTagNode] node
+    # @return [void]
     def visit_const_tag_node(node)
       flush_html_parts!
       adjust_whitespace(node.location)
@@ -320,40 +173,72 @@ module P2
       emit(');')
     end
 
-    def visit_emit_node(node)
+    # Visits a render node.
+    #
+    # @param node [P2::RenderNode] node
+    # @return [void]
+    def visit_render_node(node)
+      args = node.call_node.arguments.arguments
+      first_arg = args.first
+
+      block_embed = node.block && "&(->(__buffer__) #{format_code(node.block)}.compiled!)"
+      block_embed = ", #{block_embed}" if block_embed && node.call_node.arguments
+
+      flush_html_parts!
+      adjust_whitespace(node.location)
+
+      if args.length == 1
+        emit("; #{format_code(first_arg)}.compiled_proc.(__buffer__#{block_embed})")
+      else
+        args_code = format_code_comma_separated_nodes(args[1..])
+        emit("; #{format_code(first_arg)}.compiled_proc.(__buffer__, #{args_code}#{block_embed})")
+      end
+    end
+
+    # Visits a text node.
+    #
+    # @param node [P2::TextNode] node
+    # @return [void]
+    def visit_text_node(node)
+      return if !node.call_node.arguments
+
       args = node.call_node.arguments.arguments
       first_arg = args.first
       if args.length == 1
         if is_static_node?(first_arg)
-          emit_html(node.location, format_literal(first_arg))
-        elsif first_arg.is_a?(Prism::LambdaNode)
-          visit(first_arg.body)
+          emit_html(node.location, ERB::Escape.html_escape(format_literal(first_arg)))
         else
-          emit_html(node.location, "#\{P2.render_emit_call(#{format_code(first_arg)})}")
+          emit_html(node.location, interpolated("ERB::Escape.html_escape(#{format_code(first_arg)}.to_s)"))
         end
       else
-        block_embed = node.block ? "&(->(__buffer__) #{format_code(node.block)}.compiled!)" : nil
-        block_embed = ", #{block_embed}" if block_embed && node.call_node.arguments
-        emit_html(node.location, "#\{P2.render_emit_call(#{format_code(node.call_node.arguments)}#{block_embed})}")
+        raise "Don't know how to compile #{node}"
       end
     end
 
-    def visit_text_node(node)
+    # Visits a raw node.
+    #
+    # @param node [P2::RawNode] node
+    # @return [void]
+    def visit_raw_node(node)
       return if !node.call_node.arguments
 
       args = node.call_node.arguments.arguments
       first_arg = args.first
       if args.length == 1
         if is_static_node?(first_arg)
-          emit_html(node.location, CGI.escape_html(format_literal(first_arg)))
+          emit_html(node.location, format_literal(first_arg))
         else
-          emit_html(node.location, "#\{CGI.escape_html(#{format_code(first_arg)}.to_s)}")
+          emit_html(node.location, interpolated("(#{format_code(first_arg)}).to_s"))
         end
       else
         raise "Don't know how to compile #{node}"
       end
     end
 
+    # Visits a defer node.
+    #
+    # @param node [P2::DeferNode] node
+    # @return [void]
     def visit_defer_node(node)
       block = node.block
       return if !block
@@ -374,22 +259,30 @@ module P2
       emit("}")
     end
 
-    def visit_custom_tag_node(node)
+    # Visits a builtin node.
+    #
+    # @param node [P2::BuiltinNode] node
+    # @return [void]
+    def visit_builtin_node(node)
       case node.tag
       when :tag
-        args = node.call_node.arguments&.arguments        
+        args = node.call_node.arguments&.arguments
       when :html5
         emit_html(node.location, '<!DOCTYPE html><html>')
         visit(node.block.body) if node.block
         emit_html(node.block.closing_loc, '</html>')
-      when :emit_markdown, :markdown
+      when :markdown
         args = node.call_node.arguments
         return if !args
 
-        emit_html(node.location, "#\{P2.markdown(#{format_code(args)})}")
+        emit_html(node.location, interpolated("P2.markdown(#{format_code(args)})"))
       end
     end
 
+    # Visits a yield node.
+    #
+    # @param node [P2::YieldNode] node
+    # @return [void]
     def visit_yield_node(node)
       adjust_whitespace(node.location)
       flush_html_parts!
@@ -404,16 +297,55 @@ module P2
 
     private
 
-    def format_code(node, klass = TemplateCompiler)
-      klass.new(minimize_whitespace: true).to_source(node)
+    # Overrides the Sourcifier behaviour to flush any buffered HTML parts.
+    def emit_code(loc, semicolon: false, chomp: false, flush_html: true)
+      flush_html_parts! if flush_html
+      super(loc, semicolon:, chomp: )
+    end
+
+    # Returns the given str inside interpolation syntax (#{...}).
+    #
+    # @param str [String] input string
+    # @return [String] output string
+    def interpolated(str)
+      "#\{#{str}}"
+    end
+
+    # Formats the given AST with minimal whitespace. Used for formatting
+    # arbitrary expressions.
+    #
+    # @param node [Prism::Node] AST
+    # @return [String] generated source code
+    def format_code(node)
+      Compiler.new(minimize_whitespace: true).to_source(node)
+    end
+
+    # Formats a comma separated list of AST nodes. Used for formatting partial
+    # argument lists.
+    #
+    # @param list [Array<Prism::Node>] node list
+    # @return [String] generated source code
+    def format_code_comma_separated_nodes(list)
+      compiler = self.class.new(minimize_whitespace: true)
+      compiler.visit_comma_separated_nodes(list)
+      compiler.buffer
     end
 
     VOID_TAGS = %w(area base br col embed hr img input link meta param source track wbr)
 
+    # Returns true if given HTML element is void (needs no closing tag).
+    #
+    # @param tag [String, Symbol] HTML tag
+    # @return [bool] void or not
     def is_void_element?(tag)
       VOID_TAGS.include?(tag.to_s)
     end
 
+    # Formats an open tag with optional attributes.
+    #
+    # @param tag [String, Symbol] HTML tag
+    # @param attributes [Hash, nil] attributes
+    # @return [String] HTML
     def format_html_tag_open(tag, attributes)
       tag = convert_tag(tag)
       if attributes && attributes&.elements.size > 0
@@ -423,29 +355,42 @@ module P2
       end
     end
 
+    # Formats a close tag.
+    #
+    # @param tag [String, Symbol] HTML tag
+    # @return [String] HTML
     def format_html_tag_close(tag)
       tag = convert_tag(tag)
       "</#{tag}>"
     end
 
+    # Converts a tag's underscores to dashes. If tag is dynamic, emits code to
+    # convert underscores to dashes at runtime.
+    #
+    # @param tag [any] tag
+    # @return [String] convert tag or code
     def convert_tag(tag)
       case tag
       when Prism::SymbolNode, Prism::StringNode
-        P2.format_tag(tag.unescaped)
+        P2.underscores_to_dashes(tag.unescaped)
       when Prism::Node
-        "#\{P2.format_tag(#{format_code(tag)})}"
+        interpolated("P2.underscores_to_dashes(#{format_code(tag)})")
       else
-        P2.format_tag(tag)
+        P2.underscores_to_dashes(tag)
       end
     end
 
+    # Formats a literal value for the given node.
+    #
+    # @param node [Prism::Node] AST node
+    # @return [String] literal representation
     def format_literal(node)
       case node
       when Prism::SymbolNode, Prism::StringNode
         node.unescaped
       when Prism::IntegerNode, Prism::FloatNode
         node.value.to_s
-      when Prism::InterpolatedStringNode  
+      when Prism::InterpolatedStringNode
         format_code(node)[1..-2]
       when Prism::TrueNode
         'true'
@@ -454,7 +399,7 @@ module P2
       when Prism::NilNode
         ''
       else
-        "#\{#{format_code(node)}}"
+        interpolated(format_code(node))
       end
     end
 
@@ -468,6 +413,10 @@ module P2
       Prism::TrueNode
     ]
 
+    # Returns true if given node is static, i.e. is a literal value.
+    #
+    # @param node [Prism::Node] AST node
+    # @return [bool] static or not
     def is_static_node?(node)
       STATIC_NODE_TYPES.include?(node.class)
     end
@@ -477,10 +426,18 @@ module P2
       Prism::InterpolatedStringNode
     ]
 
+    # Returns true if given node a string or interpolated string.
+    #
+    # @param node [Prism::Node] AST node
+    # @return [bool] string node or not
     def is_string_type_node?(node)
       STRING_TYPE_NODE_TYPES.include?(node.class)
     end
 
+    # Formats HTML attributes from the given node.
+    #
+    # @param node [Prism::Node] AST node
+    # @return [String] HTML
     def format_html_attributes(node)
       elements = node.elements
       dynamic_attributes = elements.any? do
@@ -488,7 +445,7 @@ module P2
           !is_static_node?(it.key) || !is_static_node?(it.value)
       end
 
-      return "#\{P2.format_html_attrs(#{format_code(node)})}" if dynamic_attributes
+      return interpolated("P2.format_tag_attrs(#{format_code(node)})") if dynamic_attributes
 
       parts = elements.map do
         key = it.key
@@ -499,12 +456,12 @@ module P2
         when Prism::FalseNode, Prism::NilNode
           nil
         else
-          k = format_literal(key) 
+          k = format_literal(key)
           if is_static_node?(value)
             value = format_literal(value)
-            "#{P2.format_html_attr_key(k)}=\\\"#{value}\\\""
+            "#{P2.underscores_to_dashes(k)}=\\\"#{value}\\\""
           else
-            "#{P2.format_html_attr_key(k)}=\\\"#\{#{format_code(value)}}\\\""
+            "#{P2.underscores_to_dashes(k)}=\\\"#\{#{format_code(value)}}\\\""
           end
         end
       end
@@ -512,21 +469,38 @@ module P2
       parts.compact.join(' ')
     end
 
+    # Emits HTML into the pending HTML buffer.
+    #
+    # @param loc [Prism::Location] location
+    # @param str [String] HTML
+    # @return [void]
     def emit_html(loc, str)
       @html_loc_start ||= loc
       @html_loc_end = loc
       @pending_html_parts << str
     end
 
+    # Flushes pending HTML parts to the source code buffer.
+    #
+    # @return [void]
     def flush_html_parts!(semicolon_prefix: true)
       return if @pending_html_parts.empty?
 
       adjust_whitespace(@html_loc_start)
-      if semicolon_prefix && @buffer =~ /[^\s]\s*$/m
-        emit '; '
+
+      code = +''
+      part = +''
+
+      @pending_html_parts.each do
+        if (m = it.match(/^#\{(.+)\}$/m))
+          emit_html_buffer_push(code, part, quotes: true) if !part.empty?
+          emit_html_buffer_push(code, m[1])
+        else
+          part << it
+        end
       end
+      emit_html_buffer_push(code, part, quotes: true) if !part.empty?
 
-      str = @pending_html_parts.join
       @pending_html_parts.clear
 
       @last_loc = @html_loc_end
@@ -536,12 +510,27 @@ module P2
       @html_loc_start = nil
       @html_loc_end = nil
 
-      emit "__buffer__ << \"#{str}\""
+      emit code
     end
 
-    def emit_postlude
-      return if !@defer_mode
+    # Emits HTML buffer push code to the given source code buffer.
+    #
+    # @param buf [String] source code buffer
+    # @param part [String] HTML part
+    # @param quotes [bool] whether to wrap emitted HTML in double quotes
+    # @return [void]
+    def emit_html_buffer_push(buf, part, quotes: false)
+      return if part.empty?
+
+      q = quotes ? '"' : ''
+      buf << "; __buffer__ << #{q}#{part}#{q}"
+      part.clear
+    end
 
+    # Emits postlude code for templates with deferred parts.
+    #
+    # @return [void]
+    def emit_defer_postlude
       emit("; __buffer__ = __orig_buffer__; __parts__.each { it.is_a?(Proc) ? it.() : (__buffer__ << it) }")
     end
   end