RubyGems - p2 - Versions diffs - 2.6 → 2.9 - Mend

p2 2.6 → 2.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +23 -4
data/README.md +171 -67
data/lib/p2/compiler/nodes.rb +61 -5
data/lib/p2/compiler/tag_translator.rb +9 -8
data/lib/p2/compiler.rb +118 -39
data/lib/p2/proc_ext.rb +11 -1
data/lib/p2/version.rb +1 -1
data/lib/p2.rb +19 -6
metadata +3 -3

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c67f363b3f2f756ab72d89bc9d54f3e7c717a0134b080d522cd7d87923ee21b2
-  data.tar.gz: 4d8ed90dae13469d324cebef15735386c12161edba87fac791aa8cbdf60f3ba8
+  metadata.gz: bda78e0c4b37c895274b5d357022f3f491bf6b1fdab4d52cdc4e7aa7660f2f6a
+  data.tar.gz: f9e1295f3208cb6b734d65d20afa41fcb46803b37b51b7d801ab56715fe24db8
 SHA512:
-  metadata.gz: f5af31de4e3673acf332c748dbfec372b998958f3807fa410951ec7bf28e33e0fcda2adb92f9455486bc57b1cf40147d43451d31f7ea452e4ff5036accca607d
-  data.tar.gz: 164dbf6b2e03df22a85a6eb2267d34cd2e9dd4c51a1761bb469cd57e1c3167916438cffb8d66e6a8e62d225568a57f5d053e3da8cf478f56d3118fa459a4cb49
+  metadata.gz: 80891d65d533e7fabac367d342c3884c0da607e5c815821ace691fe62e5ae393983e89c60cc226b69627b0ebb66bf7f1d91ae89f8be6d8baca9620498364c756
+  data.tar.gz: 3e969bb24fbc9ec1668757e5ac152baf0052928937bd18d8c708a2031c416d8752cf8b85f3047427de82eafd008abd6126d212e3265fcfbfd9275b6ed4bc0b95

data/CHANGELOG.md CHANGED Viewed

@@ -1,12 +1,31 @@
+# 2.9 2025-09-02
+- Tweak generated code to incorporate @byroot's
+  [recommendations](https://www.reddit.com/r/ruby/comments/1mtj7bx/comment/n9ckbvt/):
+  - Remove call to to_s coercion before calling html_escape
+  - Chain calls to `#<<` with emitted HTML parts
+# 2.8 2025-08-17
+- Add `#render_children` builtin
+- Rename `#emit_yield` to `#render_yield`
+- Add `Proc#render_cached` for caching render result
+# 2.7 2025-08-17
+- Improve source maps and whitespace in compiled code
+- Minor improvements to emit_yield generated code
+- Add support for extensions
 # 2.6 2025-08-16
-- Add support for block invocation.
+- 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.
+- 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

data/README.md CHANGED Viewed

@@ -10,8 +10,8 @@
   <a href="http://rubygems.org/gems/p2">
     <img src="https://badge.fury.io/rb/p2.svg" alt="Ruby gem">
   </a>
-  <a href="https://github.com/digital-fabric/p2/actions?query=workflow%3ATests">
-    <img src="https://github.com/digital-fabric/p2/workflows/Tests/badge.svg" alt="Tests">
+  <a href="https://github.com/digital-fabric/p2/actions/workflows/test.yml">
+    <img src="https://github.com/digital-fabric/p2/actions/workflows/test.yml/badge.svg" alt="Tests">
   </a>
   <a href="https://github.com/digital-fabric/p2/blob/master/LICENSE">
     <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License">
@@ -30,7 +30,7 @@ require 'p2'
 page = ->(**props) {
   html {
     head { title 'My Title' }
-    body { emit_yield **props }
+    body { render_yield **props }
   }
 }
 page.render {
@@ -39,14 +39,13 @@ page.render {
 #=> "<html><head><title>Title</title></head><body><p>foo</p></body></html>"
 ```
 P2 is a templating engine for dynamically producing HTML in Ruby apps. P2
 templates are expressed as Ruby procs, leading to easier debugging, better
 protection against HTML injection attacks, and better code reuse.
 P2 templates can be composed in a variety of ways, facilitating the usage of
-layout templates, and enabling a component-oriented approach to building complex
-web interfaces.
+layout templates, and enabling a component-oriented approach to building web
+interfaces of arbitrary complexity.
 In P2, dynamic data is passed explicitly to the template as block/lambda
 arguments, making the data flow easy to follow and understand. P2 also lets
@@ -77,19 +76,21 @@ hello.render(name: 'world')
 P2 features:
 - Express HTML using plain Ruby procs.
-- Deferred rendering using `defer`.
-- Template composition (for uses such as layouts).
-- Markdown rendering using [Kramdown](https://github.com/gettalong/kramdown/).
 - Automatic compilation for super-fast execution (about as
   [fast](https://github.com/digital-fabric/p2/blob/master/examples/perf.rb) as
   compiled ERB/ERubi).
+- Deferred rendering using `defer`.
+- Simple and easy template composition (for uses such as layouts, or modular
+  templates).
+- Markdown rendering using [Kramdown](https://github.com/gettalong/kramdown/).
+- Support for extensions.
+- Simple caching API for caching the rendering result.
 ## Table of Content
-- [Basic Usage](#basic-usage)
-- [Adding Tags](#adding-tags)
-- [Tag and Attribute Formatting](#tag-and-attribute-formatting)
-- [Escaping Content](#escaping-content)
+- [Getting Started](#getting-started)
+- [Basic Markup](#basic-markup)
+- [Builtin Methods](#builtin-methods)
 - [Template Parameters](#template-parameters)
 - [Template Logic](#template-logic)
 - [Template Blocks](#template-blocks)
@@ -97,13 +98,14 @@ P2 features:
 - [Parameter and Block Application](#parameter-and-block-application)
 - [Higher-Order Templates](#higher-order-templates)
 - [Layout Template Composition](#layout-template-composition)
-- [Emitting Raw HTML](#emitting-raw-html)
-- [Emitting a String with HTML Escaping](#emitting-a-string-with-html-escaping)
 - [Emitting Markdown](#emitting-markdown)
 - [Deferred Evaluation](#deferred-evaluation)
-- [API Reference](#api-reference)
+- [Cached Rendering](#cached-rendering)
+A typical example for a dashboard-type app markup can be found here:
+https://github.com/digital-fabric/p2/blob/master/examples/dashboard.rb
-## Basic Usage
+## Getting Started
 In P2, an HTML template is expressed as a proc:
@@ -113,7 +115,7 @@ html = -> {
 }
 ```
-Rendering a template is done using `#render`:
+Rendering a template is done using `Proc#render`:
 ```ruby
 require 'p2'
@@ -121,7 +123,7 @@ require 'p2'
 html.render #=> "<div id="greeter"><p>Hello!</p></div>"
 ```
-## Expressing HTML Using Ruby
+## Basic Markup
 Tags are added using unqualified method calls, and can be nested using blocks:
@@ -172,7 +174,7 @@ An attribute value given as an array will be joined by space characters:
 -> { div class: [:foo, :bar] }.render #=> "<div class=\"foo bar\"></div>"
 ```
-## Tag and Attribute Formatting
+### Tag and Attribute Formatting
 P2 does not make any assumption about what tags and attributes you can use. You
 can mix upper and lower case letters, and you can include arbitrary characters
@@ -198,16 +200,137 @@ normally used for tags:
 }.render #=> '<cra_zy__:!tag>foo</cra_zy__:!tag>'
 ```
-## Escaping Content
+### Escaping Content
 P2 automatically escapes all text content emitted in a template. The specific
-escaping algorithm depends on the template type. For HTML templates, P2 uses
-[escape_utils](https://github.com/brianmario/escape_utils), specifically:
+escaping algorithm depends on the template type. To emit raw HTML, use the
+`#raw` method as [described below](#builtin-methods).
+## Builtin Methods
+In addition to normal tags, P2 provides the following method calls for templates:
+### `#text` - emit escaped text
+`#text` is used for emitting text that will be escaped. This method can be used
+to emit text not directly inside an enclosing tag:
+```ruby
+-> {
+  p {
+    text 'The time is: '
+    span(Time.now, id: 'clock')
+  }
+}.render #=> <p>The time is: <span id="clock">XX:XX:XX</span></p>
+```
+### `#raw` - emit raw HTML
+`#raw` is used for emitting raw HTML, i.e. without escaping. You can use this to
+emit an HTML snippet:
+```ruby
+TITLE_HTML = '<h1>hi</h1>'
+-> {
+  div {
+    raw TITLE_HTML
+  }
+}.render #=> <div><h1>hi</h1></div>
+```
+### `#render_yield` - emit given block
+`#render_yield` is used to emit a given block. If no block is given, a
+`LocalJumpError` exception is raised:
+```ruby
+Card = ->(**props) {
+  card { render_yield(**props) }
+}
+Card.render(foo: 'bar') { |foo|
+  h1 foo
+} #=> <card><h1>bar</h1></card>
+```
+`render_yield` can be called with or without arguments, which are passed to the
+given block.
+### `#render_children` - emit given block
+`#render_children` is used to emit a given block, but does not raise an
+exception if no block is given.
+### `#defer` - emit deferred HTML
+`#defer` is used to emit HTML in a deferred fashion - the deferred part will be
+evaluated only after processing the entire template:
+```ruby
+Layout = -> {
+  head {
+    defer {
+      title @title
+    }
+  }
+  body {
+    render_yield
+  }
+}
-- HTML: `escape_utils.escape_html`
+Layout.render {
+  @title = 'Foobar'
+  h1 'hi'
+} #=> <head><title>Foobar</title></head><body><h1>hi</h1></body>
+```
+### `#render` - render the given template inline
+`#render` is used to emit the given template. This can be used to compose
+templates:
+```ruby
+partial = -> { p 'foo' }
+-> {
+  div {
+    render partial
+  }
+}.render #=> <div><p>foo</p></div>
+```
+Any argument following the given template is passed to the template for
+rendering:
+```ruby
+large_button = ->(title) { button(title, class: 'large') }
+-> {
+  render large_button, 'foo'
+}.render #=> <button class="large">foo</button>
+```
+### `#html5` - emit an HTML5 document type declaration and html tag
+```ruby
+-> {
+  html5 {
+    p 'hi'
+  }
+} #=> <!DOCTYPE html><html><p>hi</p></html>
+```
+### `#markdown` emit markdown content
-In order to emit raw HTML, you can use the `#emit` method as [described
-below](#emitting-raw-html).
+`#markdown` is used for rendering markdown content. The call converts the given
+markdown to HTML and emits it into the rendered HTML:
+```ruby
+-> {
+  div {
+    markdown 'This is *markdown*'
+  }
+}.render #=> <p>This is <em>markdown</em></p>
+```
 ## Template Parameters
@@ -216,14 +339,14 @@ parameters are specified as block parameters, and are passed to the template on
 rendering:
 ```ruby
-greeting = -> { |name| h1 "Hello, #{name}!" }
+greeting = ->(name) { h1 "Hello, #{name}!" }
 greeting.render('world') #=> "<h1>Hello, world!</h1>"
 ```
 Templates can also accept named parameters:
 ```ruby
-greeting = -> { |name:| h1 "Hello, #{name}!" }
+greeting = ->(name:) { h1 "Hello, #{name}!" }
 greeting.render(name: 'world') #=> "<h1>Hello, world!</h1>"
 ```
@@ -233,7 +356,7 @@ Since P2 templates are just a bunch of Ruby, you can easily embed your view
 logic right in the template:
 ```ruby
--> { |user = nil|
+->(user = nil) {
   if user
     span "Hello, #{user.name}!"
   else
@@ -244,12 +367,12 @@ logic right in the template:
 ## Template Blocks
-Templates can also accept and render blocks by using `emit_yield`:
+Templates can also accept and render blocks by using `render_yield`:
 ```ruby
 page = -> {
   html {
-    body { emit_yield }
+    body { render_yield }
   }
 }
@@ -280,7 +403,7 @@ ItemList = ->(items) {
   }
 }
-page = -> { |title, items|
+page = ->(title, items) {
   html5 {
     head { Title(title) }
     body { ItemList(items) }
@@ -322,7 +445,7 @@ hello_world = hello.apply('world')
 hello_world.render #=> "<h1>Hello, world!</h1>"
 # block application
-div_wrap = -> { div { emit_yield } }
+div_wrap = -> { div { render_yield } }
 wrapped_h1 = div_wrap.apply { h1 'hi' }
 wrapped_h1.render #=> "<div><h1>hi</h1></div>"
@@ -350,7 +473,7 @@ wrapped_greeter.render #=> "<div><h1>hi</h1></div>"
 The inner template can also be passed as a block, as shown above:
 ```ruby
-div_wrap = -> { div { emit_yield } }
+div_wrap = -> { div { render_yield } }
 wrapped_greeter = div_wrap.apply { h1 'hi' }
 wrapped_greeter.render #=> "<div><h1>hi</h1></div>"
 ```
@@ -370,7 +493,7 @@ default_layout = -> { |**params|
       title: params[:title]
     }
     body {
-      emit_yield(**params)
+      render_yield(**params)
     }
   }
 }
@@ -388,24 +511,6 @@ article_layout.render(
 )
 ```
-## Emitting Raw HTML
-Raw HTML can be emitted using `#raw`:
-```ruby
-wrapped = -> { |html| div { raw html } }
-wrapped.render("<h1>hi</h1>") #=> "<div><h1>hi</h1></div>"
-```
-## Emitting a String with HTML Escaping
-To emit a string with proper HTML escaping, without wrapping it in an HTML
-element, use `#text`:
-```ruby
--> { text 'hi&lo' }.render #=> "hi&amp;lo"
-```
 ## Emitting Markdown
 Markdown is rendered using the
@@ -477,7 +582,7 @@ default_layout = -> { |**args|
   head {
     defer { render deps.head_markup }
   }
-  body { emit_yield **args }
+  body { render_yield **args }
 }
 button = proc { |text, onclick|
@@ -503,18 +608,17 @@ page = default_layout.apply {
 }
 ```
-## HTML Utility methods
+## Cached Rendering
-HTML templates include a few HTML-specific methods to facilitate writing modern
-HTML:
+P2 provides a simple API for caching the result of a rendering. The cache stores
+renderings of a template respective to the given arguments. To automatically
+retrieve the cached rendered HTML, or generate it for the first time, use
+`Proc#render_cached`:
-- `html5 { ... }` - emits an HTML 5 DOCTYPE (`<!DOCTYPE html>`)
-- `import_map(root_path, root_url)` - emits an import map including all files
-  matching `<root_path>/*.js`, based on the given `root_url`
-- `js_module(js)` - emits a `<script type="module">` element
-- `link_stylesheet(href, **attributes)` - emits a `<link rel="stylesheet" ...>`
-  element
-- `script(js, **attributes)` - emits an inline `<script>` element
-- `style(css, **attributes)` - emits an inline `<style>` element
-- `versioned_file_href(href, root_path, root_url)` - calculates a versioned href
-  for the given file
+```ruby
+template = ->(title) { div { h1 title } }
+template.render_cached('foo') #=> <div><h1>foo</h1></div>
+template.render_cached('foo') #=> <div><h1>foo</h1></div> (from cache)
+template.render_cached('bar') #=> <div><h1>bar</h1></div>
+template.render_cached('bar') #=> <div><h1>bar</h1></div> (from cache)
+```

data/lib/p2/compiler/nodes.rb CHANGED Viewed

@@ -1,8 +1,21 @@
 # frozen_string_literal: true
+class Prism::InspectVisitor
+  def visit_tag_node(node)
+    commands << [inspect_node("TagNode", node), indent]
+    # flags = [("newline" if node.newline?), ("static_literal" if node.static_literal?), ].compact
+    # commands << ["├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n", indent]
+    # commands << ["├── left:\n", indent]
+    # commands << [node.left, "#{indent}│   "]
+    # commands << ["├── right:\n", indent]
+    # commands << [node.right, "#{indent}│   "]
+    # commands << ["└── operator_loc: #{inspect_location(node.operator_loc)}\n", indent]
+  end
+end
 module P2
   # Represents a tag call
-  class TagNode
+  class TagNode < Prism::Node
     attr_reader :call_node, :location, :tag, :tag_location, :inner_text, :attributes, :block
     def initialize(call_node, translator)
@@ -149,19 +162,62 @@ module P2
       visitor.visit_builtin_node(self)
     end
   end
+  class ExtensionTagNode
+    attr_reader :tag, :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_extension_tag_node(self)
+    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
+end
+class RenderYieldNode
+  attr_reader :call_node, :location
+  def initialize(call_node, translator)
+    @call_node = call_node
+    @tag = call_node.name
+    @location = call_node.location
+  end
+  def accept(visitor)
+    visitor.visit_render_yield_node(self)
+  end
 end
-class BlockInvocationNode
-  attr_reader :call_node, :location, :block
+class RenderChildrenNode
+  attr_reader :call_node, :location
   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)
+    visitor.visit_render_children_node(self)
   end
 end

data/lib/p2/compiler/tag_translator.rb CHANGED Viewed

@@ -23,7 +23,7 @@ module P2
       return super(node) if dont_translate
       match_builtin(node) ||
-      match_emit_yield(node) ||
+      match_extension(node) ||
       match_const_tag(node) ||
       match_block_call(node) ||
       match_tag(node) ||
@@ -34,6 +34,10 @@ module P2
       return if node.receiver
       case node.name
+      when :render_yield
+        RenderYieldNode.new(node, self)
+      when :render_children
+        RenderChildrenNode.new(node, self)
       when :raise
         visit_call_node(node, dont_translate: true)
       when :render
@@ -51,14 +55,11 @@ module P2
       end
     end
-    def match_emit_yield(node)
+    def match_extension(node)
       return if node.receiver
-      return if node.name != :emit_yield
-      yield_node(
-        location: node.location,
-        arguments: node.arguments
-      )
+      return if !P2::Extensions[node.name]
+      ExtensionTagNode.new(node, self)
     end
     def match_const_tag(node)

data/lib/p2/compiler.rb CHANGED Viewed

@@ -53,6 +53,8 @@ module P2
     end
     def self.store_source_map(source_map)
+      return if !source_map
       fn = source_map[:compiled_fn]
       source_map_store[fn] = source_map
     end
@@ -67,9 +69,6 @@ module P2
     def initialize(**)
       super(**)
       @pending_html_parts = []
-      @html_loc_start = nil
-      @html_loc_end = nil
-      @yield_used = nil
     end
     # Initializes a source map.
@@ -79,6 +78,8 @@ module P2
     # @return [self]
     def with_source_map(orig_proc, orig_ast)
       fn = Compiler.source_location_to_fn(orig_proc.source_location)
+      @orig_proc = orig_proc
+      @orig_proc_fn = orig_proc.source_location.first
       @source_map = {
         source_fn: orig_proc.source_location.first,
         compiled_fn: fn
@@ -87,6 +88,15 @@ module P2
       self
     end
+    def update_source_map(str = nil)
+      return if !@source_map
+      buffer_cur_line = @buffer.count("\n") + 1
+      orig_source_cur_line = @last_loc_start ? @last_loc_start.first : '?'
+      @source_map[buffer_cur_line + @source_map_line_ofs] ||=
+        "#{@orig_proc_fn}:#{orig_source_cur_line}"
+    end
     # Formats the source code for a compiled template proc.
     #
     # @param ast [Prism::Node] translated AST
@@ -104,7 +114,7 @@ module P2
       source_code = @buffer
       @buffer = +''
       if wrap
-        @source_map[2] = loc_start(orig_ast.location).first
+        @source_map[2] = "#{@orig_proc_fn}:#{loc_start(orig_ast.location).first}"
         emit("# frozen_string_literal: true\n->(__buffer__")
         params = orig_ast.parameters
@@ -114,11 +124,12 @@ module P2
           emit(format_code(params))
         end
-        if @yield_used
+        if @render_yield_used || @render_children_used
           emit(', &__block__')
         end
         emit(") {\n")
       end
       @buffer << source_code
       emit_defer_postlude if @defer_mode
@@ -126,8 +137,6 @@ module P2
         emit('; __buffer__')
         adjust_whitespace(orig_ast.closing_loc)
         emit('}')
-        # emit(";") if @buffer !~ /\n\s*$/m
-        # emit("rescue Exception => e; P2.translate_backtrace(e, src_map); raise e; end }")
       end
       update_source_map
       Compiler.store_source_map(@source_map)
@@ -141,7 +150,7 @@ module P2
     def visit_tag_node(node)
       tag = node.tag
-      adjust_whitespace(node.location)
+      # 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
@@ -159,9 +168,7 @@ module P2
         if is_static_node?(node.inner_text)
           emit_html(node.location, ERB::Escape.html_escape(format_literal(node.inner_text)))
         else
-          to_s = is_string_type_node?(node.inner_text) ? '' : '.to_s'
-          emit_html(node.location, interpolated("ERB::Escape.html_escape((#{format_code(node.inner_text)})#{to_s})"))
+          emit_html(node.location, interpolated("ERB::Escape.html_escape((#{format_code(node.inner_text)}))"))
         end
       end
       emit_html(node.location, format_html_tag_close(tag))
@@ -221,7 +228,7 @@ module P2
         if is_static_node?(first_arg)
           emit_html(node.location, ERB::Escape.html_escape(format_literal(first_arg)))
         else
-          emit_html(node.location, interpolated("ERB::Escape.html_escape(#{format_code(first_arg)}.to_s)"))
+          emit_html(node.location, interpolated("ERB::Escape.html_escape(#{format_code(first_arg)})"))
         end
       else
         raise "Don't know how to compile #{node}"
@@ -292,20 +299,81 @@ module P2
       end
     end
-    # Visits a yield node.
+    # Visits a extension tag node.
     #
-    # @param node [P2::YieldNode] node
+    # @param node [P2::ExtensionTagNode] node
     # @return [void]
-    def visit_yield_node(node)
+    def visit_extension_tag_node(node)
       flush_html_parts!
       adjust_whitespace(node.location)
-      @yield_used = true
-      emit("; (__block__ ? __block__.compiled_proc.(__buffer__")
-      if node.arguments
+      emit("; P2::Extensions[#{node.tag.inspect}].compiled_proc.(__buffer__")
+      if node.call_node.arguments
         emit(', ')
-        visit(node.arguments)
+        visit(node.call_node.arguments)
       end
-      emit(") : raise(LocalJumpError, 'no block given (yield/emit_yield)'))")
+      if node.block
+        block_body = format_inline_block(node.block.body)
+        block_params = []
+        if node.block.parameters.is_a?(Prism::ItParametersNode)
+          raise P2::Error, "Blocks passed to extensions cannot use it parameter"
+        end
+        if (params = node.block.parameters&.parameters)
+          params.requireds.each do
+            block_params << format_code(it) if !it.is_a?(Prism::ItParametersNode)
+          end
+          params.optionals.each do
+            block_params << format_code(it) if !it.is_a?(Prism::ItParametersNode)
+          end
+          block_params << format_code(params.rest) if params.rest
+          params.posts.each do
+            block_params << format_code(it) if !it.is_a?(Prism::ItParametersNode)
+          end
+          params.keywords.each do
+            block_params << format_code(it) if !it.is_a?(Prism::ItParametersNode)
+          end
+          block_params << format_code(params.keyword_rest) if params.keyword_rest
+        end
+        block_params = block_params.empty? ? '' : ", #{block_params.join(', ')}"
+        emit(", &(proc { |__buffer__#{block_params}| #{block_body} }).compiled!")
+      end
+      emit(")")
+    end
+    # Visits a render_yield node.
+    #
+    # @param node [P2::RenderYieldNode] node
+    # @return [void]
+    def visit_render_yield_node(node)
+      flush_html_parts!
+      adjust_whitespace(node.location)
+      guard = @render_yield_used ?
+        '' : "; raise(LocalJumpError, 'no block given (render_yield)') if !__block__"
+      @render_yield_used = true
+      emit("#{guard}; __block__.compiled_proc.(__buffer__")
+      if node.call_node.arguments
+        emit(', ')
+        visit(node.call_node.arguments)
+      end
+      emit(")")
+    end
+    # Visits a render_children node.
+    #
+    # @param node [P2::RenderChildrenNode] node
+    # @return [void]
+    def visit_render_children_node(node)
+      flush_html_parts!
+      adjust_whitespace(node.location)
+      @render_children_used = true
+      emit("; __block__&.compiled_proc&.(__buffer__")
+      if node.call_node.arguments
+        emit(', ')
+        visit(node.call_node.arguments)
+      end
+      emit(")")
     end
     def visit_block_invocation_node(node)
@@ -356,6 +424,10 @@ module P2
       Compiler.new(minimize_whitespace: true).to_source(node)
     end
+    def format_inline_block(node)
+      Compiler.new(minimize_whitespace: true).format_compiled_template(node, node, wrap: false, binding: @binding)
+    end
     # Formats a comma separated list of AST nodes. Used for formatting partial
     # argument lists.
     #
@@ -512,8 +584,8 @@ module P2
     # @return [void]
     def emit_html(loc, str)
       @html_loc_start ||= loc
-      @html_loc_end = loc
-      @pending_html_parts << str
+      @html_loc_end ||= loc
+      @pending_html_parts << [loc, str]
     end
     # Flushes pending HTML parts to the source code buffer.
@@ -522,31 +594,31 @@ module P2
     def flush_html_parts!(semicolon_prefix: true)
       return if @pending_html_parts.empty?
-      adjust_whitespace(@html_loc_start)
-      code = +''
-      part = +''
+      adjust_whitespace(@html_loc_start, advance_to_end: false)
+      emit('; __buffer__')
+      concatenated = +''
-      @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])
+      last_loc = @html_loc_start
+      @pending_html_parts.each do |(loc, part)|
+        if (m = part.match(/^#\{(.+)\}$/m))
+          emit_html_buffer_push(concatenated, quotes: true) if !concatenated.empty?
+          # adjust_whitespace(loc, advance_to_end: false)
+          emit_html_buffer_push(m[1], loc:)
         else
-          part << it
+          concatenated << part
         end
+        last_loc = loc
       end
-      emit_html_buffer_push(code, part, quotes: true) if !part.empty?
+      emit_html_buffer_push(concatenated, quotes: true) if !concatenated.empty?
       @pending_html_parts.clear
-      @last_loc = @html_loc_end
-      @last_loc_start = loc_start(@html_loc_end)
-      @last_loc_end = loc_end(@html_loc_end)
+      @last_loc = last_loc
+      @last_loc_start = loc_start(@last_loc)
+      @last_loc_end = @last_loc_start
       @html_loc_start = nil
       @html_loc_end = nil
-      emit code
     end
     # Emits HTML buffer push code to the given source code buffer.
@@ -555,11 +627,18 @@ module P2
     # @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)
+    def emit_html_buffer_push(part, quotes: false, loc: nil)
       return if part.empty?
       q = quotes ? '"' : ''
-      buf << "; __buffer__ << #{q}#{part}#{q}"
+      if loc
+        emit(".<<(")
+        adjust_whitespace(loc, advance_to_end: false)
+        emit("#{q}#{part}#{q}")
+        emit(")")
+      else
+        emit(".<<(#{q}#{part}#{q})")
+      end
       part.clear
     end

data/lib/p2/proc_ext.rb CHANGED Viewed

@@ -50,7 +50,10 @@ class ::Proc
   # @return [Proc] compiled proc
   def compile
     P2::Compiler.compile(self).compiled!
-  rescue Sirop::Error
+  rescue Sirop::Error => e
+    puts '!' * 40
+    p self
+    p e
     raise P2::Error, "Dynamically defined procs cannot be compiled"
   end
@@ -87,4 +90,11 @@ class ::Proc
       compiled.(__buffer__, *a, *x, **b, **y, &c_proc)
     }.compiled!
   end
+  # Caches and returns
+  def render_cached(*args, **kargs, &block)
+    @render_cache ||= {}
+    key = args.empty? && kargs.empty? && !block ? nil : [args, kargs, block&.source_location]
+    @render_cache[key] ||= render(*args, **kargs, &block)
+  end
 end

data/lib/p2/version.rb CHANGED Viewed

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

data/lib/p2.rb CHANGED Viewed

@@ -12,6 +12,18 @@ module P2
   extend self
+  # Registry of P2 exgtensions
+  Extensions = {}
+  # Registers extensions to the P2 syntax.
+  #
+  # @param spec [Hash] hash mapping symbols to procs
+  # @return [self]
+  def extension(spec)
+    Extensions.merge!(spec)
+    self
+  end
   # Formats the given string, converting underscores to dashes.
   #
   # @param tag [String, Symbol] input string
@@ -67,8 +79,8 @@ module P2
     source_map = cache[fn] ||= Compiler.source_map_store[fn]
     return entry if !source_map
-    source_line = source_map[line] || "?(#{line})"
-    entry.sub(m[1], "#{source_map[:source_fn]}:#{source_line}")
+    ref = source_map[line] || "?(#{line})"
+    entry.sub(m[1], ref)
   end
   def make_argument_error(err, backtrace)
@@ -89,10 +101,11 @@ module P2
   # @param opts [Hash] Kramdown option overrides
   # @return [String] HTML
   def markdown(markdown, **opts)
-    # require relevant deps on use
-    require 'kramdown'
-    require 'rouge'
-    require 'kramdown-parser-gfm'
+    @markdown_deps_loaded ||= true.tap do
+      require 'kramdown'
+      require 'rouge'
+      require 'kramdown-parser-gfm'
+    end
     opts = default_kramdown_options.merge(opts)
     Kramdown::Document.new(markdown, **opts).to_html

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: p2
 version: !ruby/object:Gem::Version
-  version: '2.6'
+  version: '2.9'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.3
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement