p2 2.9 → 2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bda78e0c4b37c895274b5d357022f3f491bf6b1fdab4d52cdc4e7aa7660f2f6a
-  data.tar.gz: f9e1295f3208cb6b734d65d20afa41fcb46803b37b51b7d801ab56715fe24db8
+  metadata.gz: f9f7d2a86ea17670a7bcc69301db096ec2a2b667c7eb8f2c0df1ac28178eb823
+  data.tar.gz: 6dd4d03825d1a881fd7b721fea58af43b7c2f2c68f7ceb8bd8031a2fbfdab0de
 SHA512:
-  metadata.gz: 80891d65d533e7fabac367d342c3884c0da607e5c815821ace691fe62e5ae393983e89c60cc226b69627b0ebb66bf7f1d91ae89f8be6d8baca9620498364c756
-  data.tar.gz: 3e969bb24fbc9ec1668757e5ac152baf0052928937bd18d8c708a2031c416d8752cf8b85f3047427de82eafd008abd6126d212e3265fcfbfd9275b6ed4bc0b95
+  metadata.gz: 6cf0579fe72241ae904f417d1fd2f6e97ef347d8a3106b7069c232b8332440ef3eea5dc8b7c059516d3ad17903d207941d3e4c795768943950295fd345304248
+  data.tar.gz: 0b44037b06cc328543ed6809a5f5c0b675318902fcb36800559d1b100bf190f42e56d9249905a0ee50dd59cf0006a3fb4f17a31dcff10d6d86b70b9608d31842

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 2.11 2025-09-11
+
+- Add mode param to `P2::Template` wrapper class
+
+# 2.10 2025-09-11
+
+- Add support for rendering XML, implement `Proc#render_xml`
+- Fix handling of literal strings with double quotes
+- Improve error handling for `P2::Error` exceptions
+
 # 2.9 2025-09-02
 
 - Tweak generated code to incorporate @byroot's

data/lib/p2/compiler/tag_translator.rb

@@ -58,7 +58,7 @@ module P2
     def match_extension(node)
       return if node.receiver
       return if !P2::Extensions[node.name]
-    
+
       ExtensionTagNode.new(node, self)
     end
 

data/lib/p2/compiler.rb

@@ -14,15 +14,16 @@ module P2
     # generated optimized source code.
     #
     # @param proc [Proc] template
+    # @param mode [Symbol] compilation mode (:html, :xml)
     # @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)
+    def self.compile_to_code(proc, mode: :html, wrap: true)
       ast = Sirop.to_ast(proc)
 
       # adjust ast root if proc is defined with proc {} / lambda {} syntax
       ast = ast.block if ast.is_a?(Prism::CallNode)
 
-      compiler = new.with_source_map(proc, ast)
+      compiler = new(mode:).with_source_map(proc, ast)
       transformed_ast = TagTranslator.transform(ast.body, ast)
       compiler.format_compiled_template(transformed_ast, ast, wrap:, binding: proc.binding)
       [compiler.source_map, compiler.buffer]
@@ -37,10 +38,11 @@ module P2
     #     compiled.render #=> '<h1>Hello, world!'
     #
     # @param proc [Proc] template
+    # @param mode [Symbol] compilation mode (:html, :xml)
     # @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:)
+    def self.compile(proc, mode: :html, wrap: true)
+      source_map, code = compile_to_code(proc, mode:, wrap:)
       if ENV['DEBUG'] == '1'
         puts '*' * 40
         puts code
@@ -66,8 +68,9 @@ module P2
     attr_reader :source_map
 
     # Initializes a compiler.
-    def initialize(**)
+    def initialize(mode:, **)
       super(**)
+      @mode = mode
       @pending_html_parts = []
     end
 
@@ -336,7 +339,7 @@ module P2
           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(")")
@@ -421,11 +424,11 @@ module P2
     # @param node [Prism::Node] AST
     # @return [String] generated source code
     def format_code(node)
-      Compiler.new(minimize_whitespace: true).to_source(node)
+      Compiler.new(mode: @mode, 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)
+      Compiler.new(mode: @mode, 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
@@ -434,7 +437,7 @@ module P2
     # @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 = Compiler.new(mode: @mode, minimize_whitespace: true)
       compiler.visit_comma_separated_nodes(list)
       compiler.buffer
     end
@@ -446,6 +449,8 @@ module P2
     # @param tag [String, Symbol] HTML tag
     # @return [bool] void or not
     def is_void_element?(tag)
+      return false if @mode == :xml
+
       VOID_TAGS.include?(tag.to_s)
     end
 
@@ -495,7 +500,9 @@ module P2
     def format_literal(node)
       case node
       when Prism::SymbolNode, Prism::StringNode
-        node.unescaped
+        # since the value is copied verbatim into a quoted string, we need to
+        # add a backslash before any double quote.
+        node.unescaped.gsub('"', '\"')
       when Prism::IntegerNode, Prism::FloatNode
         node.value.to_s
       when Prism::InterpolatedStringNode
@@ -601,6 +608,7 @@ module P2
       last_loc = @html_loc_start
       @pending_html_parts.each do |(loc, part)|
         if (m = part.match(/^#\{(.+)\}$/m))
+          # interpolated part
           emit_html_buffer_push(concatenated, quotes: true) if !concatenated.empty?
           # adjust_whitespace(loc, advance_to_end: false)
           emit_html_buffer_push(m[1], loc:)

data/lib/p2/proc_ext.rb

@@ -2,34 +2,40 @@
 
 require_relative './compiler'
 
-# Extensions to the Proc class
+# Extensions to the Proc class.
 class ::Proc
-  # Returns the compiled form code for the proc
+  # Returns the compiled form code for the proc.
   #
   # @return [String] compiled proc code
   def compiled_code
     P2::Compiler.compile_to_code(self).last
   end
 
+  # Returns the source map for the compiled proc.
+  #
+  # @return [Array<String>] source map
   def source_map
     loc = source_location
     fn = compiled? ? loc.first : P2::Compiler.source_location_to_fn(loc)
     P2::Compiler.source_map_store[fn]
   end
 
+  # Returns the AST for the proc.
+  #
+  # @return [Prism::Node] AST root
   def ast
     Sirop.to_ast(self)
   end
 
-  # Returns true if proc is marked as compiled
+  # Returns true if proc is marked as compiled.
   #
   # @return [bool] is the proc marked as compiled
   def compiled?
     @is_compiled
   end
 
-  # marks the proc as compiled, i.e. can render directly and takes a string
-  # buffer as first argument
+  # Marks the proc as compiled, i.e. can render directly and takes a string
+  # buffer as first argument.
   #
   # @return [self]
   def compiled!
@@ -40,34 +46,43 @@ class ::Proc
   # Returns the compiled proc for the given proc. If marked as compiled, returns
   # self.
   #
+  # @param mode [Symbol] compilation mode (:html, :xml)
   # @return [Proc] compiled proc or self
-  def compiled_proc
-    @compiled_proc ||= @is_compiled ? self : compile
+  def compiled_proc(mode: :html)
+    @compiled_proc ||= @is_compiled ? self : compile(mode:)
   end
 
-  # Compiles the proc into the compiled form
+  # Compiles the proc into the compiled form.
   #
+  # @param mode [Symbol] compilation mode (:html, :xml)
   # @return [Proc] compiled proc
-  def compile
-    P2::Compiler.compile(self).compiled!
-  rescue Sirop::Error => e
-    puts '!' * 40
-    p self
-    p e
+  def compile(mode: :html)
+    P2::Compiler.compile(self, mode:).compiled!
+  rescue Sirop::Error
     raise P2::Error, "Dynamically defined procs cannot be compiled"
   end
 
-  # Renders the proc to HTML with the given arguments
+  # Renders the proc to HTML with the given arguments.
   #
   # @return [String] HTML string
   def render(*a, **b, &c)
     compiled_proc.(+'', *a, **b, &c)
   rescue Exception => e
-    raise P2.translate_backtrace(e)
+    e.is_a?(P2::Error) ? raise : raise(P2.translate_backtrace(e))
   end
 
-  # Renders the proc into the given buffer
+  # Renders the proc to XML with the given arguments.
   #
+  # @return [String] XML string
+  def render_xml(*a, **b, &c)
+    compiled_proc(mode: :xml).(+'', *a, **b, &c)
+  rescue Exception => e
+    e.is_a?(P2::Error) ? raise : raise(P2.translate_backtrace(e))
+  end
+
+  # Renders the proc to HTML with the given arguments into the given buffer.
+  #
+  # @param buf [String] buffer
   # @return [String] HTML string
   def render_to_buffer(buf, *a, **b, &c)
     compiled_proc.(buf, *a, **b, &c)
@@ -75,7 +90,7 @@ class ::Proc
     raise P2.translate_backtrace(e)
   end
 
-  # Returns a proc that applies the given arguments to the original proc
+  # Returns a proc that applies the given arguments to the original proc.
   #
   # @return [Proc] applied proc
   def apply(*a, **b, &c)
@@ -91,7 +106,10 @@ class ::Proc
     }.compiled!
   end
 
-  # Caches and returns 
+  # Caches and returns the rendered HTML for the template with the given
+  # arguments.
+  #
+  # @return [String] HTML string
   def render_cached(*args, **kargs, &block)
     @render_cache ||= {}
     key = args.empty? && kargs.empty? && !block ? nil : [args, kargs, block&.source_location]

data/lib/p2/template.rb

@@ -4,10 +4,25 @@ 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
+    attr_reader :proc, :mode
+
+    # @param proc [Proc] template proc
+    # @param mode [Symbol] mode (:html, :xml)
+    def initialize(proc, mode: :html)
+      @proc = proc
+      @mode = mode
+    end
+
+    def render(*, **, &)
+      (mode == :xml) ? @proc.render_xml(*, **, &) : @proc.render(*, **, &)
+    end
+
+    def apply(*, **, &)
+      Template.new(@proc.apply(*, **, &), mode: @mode)
+    end
+    
+    def compiled_proc
+      @proc.compiled_proc(mode: @mode)
+    end
   end
 end

data/lib/p2/version.rb

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

data/lib/p2.rb

@@ -16,7 +16,7 @@ module P2
   Extensions = {}
 
   # Registers extensions to the P2 syntax.
-  # 
+  #
   # @param spec [Hash] hash mapping symbols to procs
   # @return [self]
   def extension(spec)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: p2
 version: !ruby/object:Gem::Version
-  version: '2.9'
+  version: '2.11'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -135,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: 'P2: component-based HTML templating for Ruby'
 test_files: []