p2 2.3 → 2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad3bf1a720998e9b118a15d4a7b57677c5938bf74d6f65f474653ecaf58a9387
-  data.tar.gz: 6299a9c113a3bf8cc3c0a2c745ba281f7f42304ae7d127fca907b2cead73788c
+  metadata.gz: c67f363b3f2f756ab72d89bc9d54f3e7c717a0134b080d522cd7d87923ee21b2
+  data.tar.gz: 4d8ed90dae13469d324cebef15735386c12161edba87fac791aa8cbdf60f3ba8
 SHA512:
-  metadata.gz: 8fffd7f51d9efd4a537f5e870987bf7cc849aaf3a22a912cb36f6f2ab046259a1191201966e9497941b863a7e0ac35a2dc49d4e6ecf93445d6d1ed0d4725fc09
-  data.tar.gz: 6b7165c8d382c91d97d7a4799e2da53e80cacb2100ce7703017af7adee1ec53c0a474a2ff6798231ec848e5463ffce26231026f0f135057803b4d9cf53ac9090
+  metadata.gz: f5af31de4e3673acf332c748dbfec372b998958f3807fa410951ec7bf28e33e0fcda2adb92f9455486bc57b1cf40147d43451d31f7ea452e4ff5036accca607d
+  data.tar.gz: 164dbf6b2e03df22a85a6eb2267d34cd2e9dd4c51a1761bb469cd57e1c3167916438cffb8d66e6a8e62d225568a57f5d053e3da8cf478f56d3118fa459a4cb49

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+# 2.6 2025-08-16
+
+- Add support for block invocation.
+
+# 2.5 2025-08-15
+
+- Translate backtrace for exceptions raised in `#render_to_buffer`.
+- Improve display of backtrace when source map is missing entries.
+- Improve handling of ArgumentError raised on calling the template.
+- Add `Template#apply`, `Template#compiled_proc` methods
+
+# 2.4 2025-08-10
+
+- Add P2::Template wrapper class
+
 # 2.3 2025-08-10
 
 - Fix whitespace issue in visit_yield_node

data/lib/p2/compiler/nodes.rb

@@ -78,6 +78,19 @@ module P2
     end
   end
 
+  class ConstTagNode
+    attr_reader :call_node, :location
+
+    def initialize(call_node, translator)
+      @call_node = call_node
+      @location = call_node.location
+    end
+
+    def accept(visitor)
+      visitor.visit_const_tag_node(self)
+    end
+  end
+
   # Represents a text call
   class TextNode
     attr_reader :call_node, :location
@@ -137,3 +150,18 @@ module P2
     end
   end
 end
+
+class BlockInvocationNode
+  attr_reader :call_node, :location, :block
+
+  def initialize(call_node, translator)
+    @call_node = call_node
+    @tag = call_node.name
+    @location = call_node.location
+    @block = call_node.block && translator.visit(call_node.block)
+  end
+
+  def accept(visitor)
+    visitor.visit_block_invocation_node(self)
+  end
+end

data/lib/p2/compiler/tag_translator.rb

@@ -10,22 +10,32 @@ module P2
   class TagTranslator < Prism::MutationCompiler
     include Prism::DSL
 
-    def self.transform(ast)
-      ast.accept(new)
+    def initialize(root)
+      @root = root
+      super()
     end
 
-    def visit_call_node(node)
-      # We're only interested in compiling method calls without a receiver
-      return super(node) if node.receiver
+    def self.transform(ast, root)
+      ast.accept(new(root))
+    end
+
+    def visit_call_node(node, dont_translate: false)
+      return super(node) if dont_translate
+
+      match_builtin(node) ||
+      match_emit_yield(node) ||
+      match_const_tag(node) ||
+      match_block_call(node) ||
+      match_tag(node) ||
+      super(node)
+    end
+
+    def match_builtin(node)
+      return if node.receiver
 
       case node.name
-      when :emit_yield
-        yield_node(
-          location: node.location,
-          arguments: node.arguments
-        )
       when :raise
-        super(node)
+        visit_call_node(node, dont_translate: true)
       when :render
         RenderNode.new(node, self)
       when :raw
@@ -37,8 +47,46 @@ module P2
       when :html5, :markdown
         BuiltinNode.new(node, self)
       else
-        TagNode.new(node, self)
+        nil
+      end
+    end
+
+    def match_emit_yield(node)
+      return if node.receiver
+      return if node.name != :emit_yield
+
+      yield_node(
+        location: node.location,
+        arguments: node.arguments
+      )
+    end
+
+    def match_const_tag(node)
+      return if node.receiver
+      return if node.name !~ /^[A-Z]/
+
+      ConstTagNode.new(node, self)
+    end
+
+    def match_block_call(node)
+      return if !node.receiver
+      return if node.name != :call
+
+      receiver = node.receiver
+      return if !receiver.is_a?(Prism::LocalVariableReadNode)
+      return if @root.parameters&.parameters.block&.name != receiver.name
+
+      if node.block
+        raise P2::Error, 'No support for proc invocation with block'
       end
+
+      BlockInvocationNode.new(node, self)
+    end
+
+    def match_tag(node)
+      return if node.receiver
+
+      TagNode.new(node, self)
     end
   end
 end

data/lib/p2/compiler.rb

@@ -23,7 +23,7 @@ module P2
       ast = ast.block if ast.is_a?(Prism::CallNode)
 
       compiler = new.with_source_map(proc, ast)
-      transformed_ast = TagTranslator.transform(ast.body)
+      transformed_ast = TagTranslator.transform(ast.body, ast)
       compiler.format_compiled_template(transformed_ast, ast, wrap:, binding: proc.binding)
       [compiler.source_map, compiler.buffer]
     end
@@ -57,6 +57,10 @@ module P2
       source_map_store[fn] = source_map
     end
 
+    def self.source_location_to_fn(source_location)
+      "::(#{source_location.join(':')})"
+    end
+
     attr_reader :source_map
 
     # Initializes a compiler.
@@ -74,10 +78,10 @@ module P2
     # @param orig_ast [Prism::Node] template AST
     # @return [self]
     def with_source_map(orig_proc, orig_ast)
-      compiled_fn = "::(#{orig_proc.source_location.join(':')})"
+      fn = Compiler.source_location_to_fn(orig_proc.source_location)
       @source_map = {
         source_fn: orig_proc.source_location.first,
-        compiled_fn: compiled_fn
+        compiled_fn: fn
       }
       @source_map_line_ofs = 2
       self
@@ -92,6 +96,7 @@ module P2
     def format_compiled_template(ast, orig_ast, wrap:, binding:)
       # generate source code
       @binding = binding
+      update_source_map
       visit(ast)
       flush_html_parts!(semicolon_prefix: true)
       update_source_map
@@ -99,6 +104,7 @@ module P2
       source_code = @buffer
       @buffer = +''
       if wrap
+        @source_map[2] = loc_start(orig_ast.location).first
         emit("# frozen_string_literal: true\n->(__buffer__")
 
         params = orig_ast.parameters
@@ -134,10 +140,8 @@ module P2
     # @return [void]
     def visit_tag_node(node)
       tag = node.tag
-      if tag.is_a?(Symbol) && tag =~ /^[A-Z]/
-        return visit_const_tag_node(node.call_node)
-      end
 
+      adjust_whitespace(node.location)
       is_void = is_void_element?(tag)
       emit_html(node.tag_location, format_html_tag_open(tag, node.attributes))
       return if is_void
@@ -170,14 +174,14 @@ module P2
     def visit_const_tag_node(node)
       flush_html_parts!
       adjust_whitespace(node.location)
-      if node.receiver
-        emit(node.receiver.location)
+      if node.call_node.receiver
+        emit(node.call_node.receiver.location)
         emit('::')
       end
-      emit("; #{node.name}.compiled_proc.(__buffer__")
-      if node.arguments
+      emit("; #{node.call_node.name}.compiled_proc.(__buffer__")
+      if node.call_node.arguments
         emit(', ')
-        visit(node.arguments)
+        visit(node.call_node.arguments)
       end
       emit(');')
     end
@@ -304,9 +308,32 @@ module P2
       emit(") : raise(LocalJumpError, 'no block given (yield/emit_yield)'))")
     end
 
+    def visit_block_invocation_node(node)
+      flush_html_parts!
+      adjust_whitespace(node.location)
+
+      emit("; #{node.call_node.receiver.name}.compiled_proc.(__buffer__")
+      if node.call_node.arguments
+        emit(', ')
+        visit(node.call_node.arguments)
+      end
+      if node.call_node.block
+        emit(", &(->")
+        visit(node.call_node.block)
+        emit(").compiled_proc")
+      end
+      emit(")")
+    end
+
     private
 
     # Overrides the Sourcifier behaviour to flush any buffered HTML parts.
+    #
+    # @param loc [Prism::Location] location
+    # @param semicolon [bool] prefix a semicolon before emitted code
+    # @param chomp [bool] chomp the emitted code
+    # @param flush_html [bool] flush pending HTML parts before emitting the code
+    # @return [void]
     def emit_code(loc, semicolon: false, chomp: false, flush_html: true)
       flush_html_parts! if flush_html
       super(loc, semicolon:, chomp: )

data/lib/p2/proc_ext.rb

@@ -11,6 +11,16 @@ class ::Proc
     P2::Compiler.compile_to_code(self).last
   end
 
+  def source_map
+    loc = source_location
+    fn = compiled? ? loc.first : P2::Compiler.source_location_to_fn(loc)
+    P2::Compiler.source_map_store[fn]
+  end
+
+  def ast
+    Sirop.to_ast(self)
+  end
+
   # Returns true if proc is marked as compiled
   #
   # @return [bool] is the proc marked as compiled
@@ -50,8 +60,7 @@ class ::Proc
   def render(*a, **b, &c)
     compiled_proc.(+'', *a, **b, &c)
   rescue Exception => e
-    P2.translate_backtrace(e)
-    raise e
+    raise P2.translate_backtrace(e)
   end
 
   # Renders the proc into the given buffer
@@ -59,6 +68,8 @@ class ::Proc
   # @return [String] HTML string
   def render_to_buffer(buf, *a, **b, &c)
     compiled_proc.(buf, *a, **b, &c)
+  rescue Exception => e
+    raise P2.translate_backtrace(e)
   end
 
   # Returns a proc that applies the given arguments to the original proc

data/lib/p2/template.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module P2
+  # Template wrapper class. This class can be used to distinguish between P2
+  # templates and other kinds of procs.
+  class Template
+    attr_reader :proc
+    def initialize(proc)  = @proc = proc
+    def render(*, **, &)  = @proc.render(*, **, &)
+    def apply(*, **, &)   = Template.new(@proc.apply(*, **, &))
+    def compiled_proc     = @proc.compiled_proc
+  end
+end

data/lib/p2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module P2
-  VERSION = '2.3'
+  VERSION = '2.6'
 end

data/lib/p2.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'p2/template'
 require_relative 'p2/compiler'
 require_relative 'p2/proc_ext'
 
@@ -38,21 +39,23 @@ module P2
     end
   end
 
-  # Translates an exceptions backtrace using a source map.
-  #
-  # @param exception [Exception] raised exception
-  # @param source_map [Hash] source map
+  # Translates entries in exception's backtrace to point to original source code.
   #
+  # @param err [Exception] raised exception
   # @return [Exception] raised exception
-  def translate_backtrace(exception)
+  def translate_backtrace(err)
     cache = {}
-    backtrace = exception.backtrace.map { |e| compute_backtrace_entry(e, cache) }
-    exception.set_backtrace(backtrace)
-    exception
+    is_argument_error = err.is_a?(ArgumentError) && err.backtrace[0] =~ /^\:\:/
+    backtrace = err.backtrace.map { |e| compute_backtrace_entry(e, cache) }
+
+    return make_argument_error(err, backtrace) if is_argument_error
+
+    err.set_backtrace(backtrace)
+    err
   end
 
   # Computes a backtrace entry with caching.
-  # 
+  #
   # @param entry [String] backtrace entry
   # @param cache [Hash] cache store mapping compiled filename to source_map
   def compute_backtrace_entry(entry, cache)
@@ -68,6 +71,17 @@ module P2
     entry.sub(m[1], "#{source_map[:source_fn]}:#{source_line}")
   end
 
+  def make_argument_error(err, backtrace)
+    m = err.message.match(/(given (\d+), expected (\d+))/)
+    if m
+      rectified = format('given %d, expected %d', m[2].to_i - 1, m[3].to_i - 1)
+      message = err.message.gsub(m[1], rectified)
+    else
+      message = err.message
+    end
+    ArgumentError.new(message).tap { it.set_backtrace(backtrace) }
+  end
+
   # Renders Markdown into HTML. The `opts` argument will be merged with the
   # default Kramdown options in order to change the rendering behaviour.
   #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: p2
 version: !ruby/object:Gem::Version
-  version: '2.3'
+  version: '2.6'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -107,6 +107,7 @@ files:
 - lib/p2/compiler/nodes.rb
 - lib/p2/compiler/tag_translator.rb
 - lib/p2/proc_ext.rb
+- lib/p2/template.rb
 - lib/p2/version.rb
 - p2.png
 homepage: http://github.com/digital-fabric/p2