RubyGems - p2 - Versions diffs - 2.0 - Mend

p2 2.0

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 (9) hide show

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 37c651c3157074dde83015d5e4e6db8a44ef90b12a8dd890a585539e3eb80b4d
+  data.tar.gz: 384d6a649bc089c24d578185f75a7e5a09b22825d70f1367e55b0e8a7f0e3cd8
+SHA512:
+  metadata.gz: 6565857078969d64aced3c864d295ca9d4627b08bff842eda2578d8759022ac78c3553b3feef99550efee9498a5f0a943ffae2ca12f5dd001162165101bad557
+  data.tar.gz: d0b758535f27c4ec60dac2649d79504c01fcc3e021e318259ea475215cd3d62efec1e360a9529c2bdc6bc1068ed31c44d6339fd44e99aae1bcb4bd8eb97983e8

data/CHANGELOG.md ADDED Viewed

@@ -0,0 +1,7 @@
+## 2.0 2025-08-07
+- Passes all HTML, compilation tests from Papercraft
+- Automatic compilation
+- Plain procs/lambdas as templates
+- Remove everything not having to do with HTML
+- P2: compiled functional templates - they're super fast!

data/README.md ADDED Viewed

@@ -0,0 +1,523 @@
+<h1 align="center">
+  <img src="p2.png">
+  <br>
+  P2
+</h1>
+<h4 align="center">Composable templating for Ruby</h4>
+<p align="center">
+  <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>
+  <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">
+  </a>
+</p>
+<p align="center">
+  <a href="https://www.rubydoc.info/gems/p2">API reference</a>
+</p>
+## What is P2?
+P2 is a templating engine for dynamically producing [HTML](#html-templates). P2
+templates are expressed as Ruby procs, leading to easier debugging, better
+protection against HTML/XML 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.
+In P2, dynamic data is passed explicitly to the template as block arguments,
+making the data flow easy to follow and understand. P2 also lets developers
+create derivative templates using full or partial parameter application.
+P2 includes built-in support for rendering Markdown (using
+[Kramdown](https://github.com/gettalong/kramdown/)).
+P2 automatically escapes all text emitted in templates according to the template
+type. For more information see the section on [escaping
+content](#escaping-content).
+```ruby
+require 'p2'
+page = ->(**props) {
+  html {
+    head { title 'My Title' }
+    body { yield **props }
+  }
+}
+page.render {
+  p 'foo'
+}
+#=> "<html><head><title>Title</title></head><body><p>foo</p></body></html>"
+hello_page = page.apply ->(name:, **) {
+  h1 "Hello, #{name}!"
+}
+hello.render(name: 'world')
+#=> "<html><head><title>Title</title></head><body><h1>Hello, world!</h1></body></html>"
+```
+## Table of Content
+- [Installing P2](#installing-p2)
+- [Basic Usage](#basic-usage)
+- [Adding Tags](#adding-tags)
+- [Tag and Attribute Formatting](#tag-and-attribute-formatting)
+- [Escaping Content](#escaping-content)
+- [Template Parameters](#template-parameters)
+- [Template Logic](#template-logic)
+- [Template Blocks](#template-blocks)
+- [Template Composition](#template-composition)
+- [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 Encoding](#emitting-a-string-with-html-encoding)
+- [Emitting Markdown](#emitting-markdown)
+- [Deferred Evaluation](#deferred-evaluation)
+- [API Reference](#api-reference)
+## Installing P2
+**Note**: P2 requires Ruby version 3.4 or newer.
+Using bundler:
+```ruby
+gem 'p2'
+```
+Or manually:
+```bash
+$ gem install p2
+```
+## Basic Usage
+In P2, an HTML template is expressed as a proc:
+```ruby
+html = -> {
+  div(id: 'greeter') { p 'Hello!' }
+}
+```
+Rendering a template is done using `#render`:
+```ruby
+require 'p2'
+html.render #=> "<div id="greeter"><p>Hello!</p></div>"
+```
+## Adding Tags
+Tags are added using unqualified method calls, and can be nested using blocks:
+```ruby
+-> {
+  html {
+    head {
+      title 'page title'
+    }
+    body {
+      article {
+        h1 'article title'
+      }
+    }
+  }
+}
+```
+Tag methods accept a string argument, a block, or no argument at all:
+```ruby
+-> { p 'hello' }.render #=> "<p>hello</p>"
+-> { p { span '1'; span '2' } }.render #=> "<p><span>1</span><span>2</span></p>"
+-> { hr() }.render #=> "<hr/>"
+```
+Tag methods also accept tag attributes, given as a hash:
+```ruby
+-> { img src: '/my.gif' }.render #=> "<img src=\"/my.gif\"/>"
+-> { p "foobar", class: 'important' }.render #=> "<p class=\"important\">foobar</p>"
+```
+A `true` attribute value will emit a valueless attribute. A `nil` or `false`
+attribute value will emit nothing:
+```ruby
+-> { button disabled: nil }.render #=> "<button></button>"
+-> { button disabled: true }.render #=> "<button disabled></button>"
+```
+An attribute value given as an array will be joined by space characters:
+```ruby
+-> { div class: [:foo, :bar] }.render #=> "<div class=\"foo bar\"></div>"
+```
+## 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
+in tag and attribute names. However, in order to best adhere to the HTML specs
+and common practices, tag names and attributes will be formatted according to
+the following rules, depending on the template type:
+- HTML: underscores are converted to dashes:
+  ```ruby
+  -> {
+    foo_bar { p 'Hello', data_name: 'world' }
+  }.render #=> '<foo-bar><p data-name="world">Hello</p></foo-bar>'
+  ```
+If you need more precise control over tag names, you can use the `#tag` method,
+which takes the tag name as its first parameter, then the rest of the parameters
+normally used for tags:
+```ruby
+-> {
+  tag 'cra_zy__:!tag', 'foo'
+}.render #=> '<cra_zy__:!tag>foo</cra_zy__:!tag>'
+```
+## 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:
+- HTML: `escape_utils.escape_html`
+In order to emit raw HTML, you can use the `#emit` method as [described
+below](#emitting-raw-html).
+## Template Parameters
+In P2, parameters are always passed explicitly. This means that template
+parameters are specified as block parameters, and are passed to the template on
+rendering:
+```ruby
+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.render(name: 'world') #=> "<h1>Hello, world!</h1>"
+```
+## Template Logic
+Since P2 templates are just a bunch of Ruby, you can easily embed your view
+logic right in the template:
+```ruby
+-> { |user = nil|
+  if user
+    span "Hello, #{user.name}!"
+  else
+    span "Hello, guest!"
+  end
+}
+```
+## Template Blocks
+Templates can also accept and render blocks by using `emit_yield`:
+```ruby
+page = -> {
+  html {
+    body { emit_yield }
+  }
+}
+# we pass the inner HTML
+page.render { h1 'hi' }
+```
+## Template Composition
+P2 makes it easy to compose multiple templates into a whole HTML document. A P2
+template can contain other templates, as the following example shows.
+```ruby
+Title = ->(title) { h1 title }
+Item = ->(id:, text:, checked:) {
+  li {
+    input name: id, type: 'checkbox', checked: checked
+    label text, for: id
+  }
+}
+ItemList = ->(items) {
+  ul {
+    items.each { |i|
+      Item(**i)
+    }
+  }
+}
+page = -> { |title, items|
+  html5 {
+    head { Title(title) }
+    body { ItemList(items) }
+  }
+}
+page.render('Hello from composed templates', [
+  { id: 1, text: 'foo', checked: false },
+  { id: 2, text: 'bar', checked: true }
+])
+```
+In addition to using templates defined as constants, you can also use
+non-constant templates by invoking the `#emit` method:
+```ruby
+greeting = -> { span "Hello, world" }
+-> {
+  div {
+    emit greeting
+  }
+}
+```
+## Parameter and Block Application
+Parameters and blocks can be applied to a template without it being rendered, by
+using `#apply`. This mechanism is what allows template composition and the
+creation of higher-order templates.
+The `#apply` method returns a new template which applies the given parameters
+and or block to the original template:
+```ruby
+# parameter application
+hello = -> { |name| h1 "Hello, #{name}!" }
+hello_world = hello.apply('world')
+hello_world.render #=> "<h1>Hello, world!</h1>"
+# block application
+div_wrap = -> { div { emit_yield } }
+wrapped_h1 = div_wrap.apply { h1 'hi' }
+wrapped_h1.render #=> "<div><h1>hi</h1></div>"
+# wrap a template
+wrapped_hello_world = div_wrap.apply(&hello_world)
+wrapped_hello_world.render #=> "<div><h1>Hello, world!</h1></div>"
+```
+## Higher-Order Templates
+P2 also lets you create higher-order templates, that is, templates that take
+other templates as parameters, or as blocks. Higher-order templates are handy
+for creating layouts, wrapping templates in arbitrary markup, enhancing
+templates or injecting template parameters.
+Here is a higher-order template that takes a template as parameter:
+```ruby
+div_wrap = -> { |inner| div { emit inner } }
+greeter = -> { h1 'hi' }
+wrapped_greeter = div_wrap.apply(greeter)
+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 } }
+wrapped_greeter = div_wrap.apply { h1 'hi' }
+wrapped_greeter.render #=> "<div><h1>hi</h1></div>"
+```
+## Layout Template Composition
+One of the principal uses of higher-order templates is the creation of nested
+layouts. Suppose we have a website with a number of different layouts, and we'd
+like to avoid having to repeat the same code in the different layouts. We can do
+this by creating a `default` page template that takes a block, then use `#apply`
+to create the other templates:
+```ruby
+default_layout = -> { |**params|
+  html5 {
+    head {
+      title: params[:title]
+    }
+    body {
+      emit_yield(**params)
+    }
+  }
+}
+article_layout = default_layout.apply { |title:, body:|
+  article {
+    h1 title
+    emit_markdown body
+  }
+}
+article_layout.render(
+  title: 'This is a title',
+  body: 'Hello from *markdown body*'
+)
+```
+## Emitting Raw HTML
+Raw HTML can be emitted using `#emit`:
+```ruby
+wrapped = -> { |html| div { emit html } }
+wrapped.render("<h1>hi</h1>") #=> "<div><h1>hi</h1></div>"
+```
+## Emitting a String with HTML Encoding
+To emit a string with proper HTML encoding, without wrapping it in an HTML
+element, use `#text`:
+```ruby
+-> { text 'hi&lo' }.render #=> "hi&amp;lo"
+```
+## Emitting Markdown
+Markdown is rendered using the
+[Kramdown](https://kramdown.gettalong.org/index.html) gem. To emit Markdown, use
+`#emit_markdown`:
+```ruby
+template = -> { |md| div { emit_markdown md } }
+template.render("Here's some *Markdown*") #=> "<div><p>Here's some <em>Markdown</em><p>\n</div>"
+```
+[Kramdown
+options](https://kramdown.gettalong.org/options.html#available-options) can be
+specified by adding them to the `#emit_markdown` call:
+```ruby
+template = -> { |md| div { emit_markdown md, auto_ids: false } }
+template.render("# title") #=> "<div><h1>title</h1></div>"
+```
+You can also use `P2.markdown` directly:
+```ruby
+P2.markdown('# title') #=> "<h1>title</h1>"
+```
+The default Kramdown options are:
+```ruby
+{
+  entity_output: :numeric,
+  syntax_highlighter: :rouge,
+  input: 'GFM',
+  hard_wrap: false
+}
+```
+The deafult options can be configured by accessing
+`P2.default_kramdown_options`, e.g.:
+```ruby
+P2.default_kramdown_options[:auto_ids] = false
+```
+## Deferred Evaluation
+Deferred evaluation allows deferring the rendering of parts of a template until
+the last moment, thus allowing an inner template to manipulate the state of the
+outer template. To in order to defer a part of a template, use `#defer`, and
+include any markup in the provided block. This technique, in in conjunction with
+holding state in instance variables, is an alternative to passing parameters,
+which can be limiting in some situations.
+A few use cases for deferred evaulation come to mind:
+- Setting the page title.
+- Adding a flash message to a page.
+- Using templates that dynamically add static dependencies (JS and CSS) to the
+  page.
+The last use case is particularly interesting. Imagine a `DependencyMananger`
+class that can collect JS and CSS dependencies from the different templates
+integrated into the page, and adds them to the page's `<head>` element:
+```ruby
+default_layout = -> { |**args|
+  @dependencies = DependencyMananger.new
+  head {
+    defer { emit @dependencies.head_markup }
+  }
+  body { emit_yield **args }
+}
+button = proc { |text, onclick|
+  @dependencies.js '/static/js/button.js'
+  @dependencies.css '/static/css/button.css'
+  button text, onclick: onclick
+}
+heading = proc { |text|
+  @dependencies.js '/static/js/heading.js'
+  @dependencies.css '/static/css/heading.css'
+  h1 text
+}
+page = default_layout.apply {
+  emit heading, "What's your favorite cheese?"
+  emit button, 'Beaufort', 'eat_beaufort()'
+  emit button, 'Mont d''or', 'eat_montdor()'
+  emit button, 'Époisses', 'eat_epoisses()'
+}
+```
+## HTML Utility methods
+HTML templates include a few HTML-specific methods to facilitate writing modern
+HTML:
+- `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
+[HTML docs](https://www.rubydoc.info/gems/p2/P2/HTML)
+## API Reference
+The API reference for this library can be found
+[here](https://www.rubydoc.info/gems/p2).

data/lib/p2/compiler.rb ADDED Viewed

@@ -0,0 +1,547 @@
+# frozen_string_literal: true
+require 'cgi'
+require 'sirop'
+require 'digest/md5'
+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
+  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
+    def self.compile_to_code(proc, 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)
+      transformed_ast = TagTransformer.transform(ast.body)
+      compiler.format_compiled_template(transformed_ast, ast, wrap:, binding: proc.binding)
+      [compiler.source_map, compiler.buffer]
+    end
+    def self.compile(proc, wrap: true)
+      source_map, code = compile_to_code(proc, wrap:)
+      eval(code, proc.binding, source_map[:compiled_fn])
+    end
+    attr_reader :source_map
+    def initialize(**)
+      super(**)
+      @pending_html_parts = []
+      @html_loc_start = nil
+      @html_loc_end = nil
+      @yield_used = nil
+    end
+    def with_source_map(orig_proc, orig_ast)
+      ast_digest = Digest::MD5.hexdigest(orig_ast.inspect)
+      @source_map = {
+        source_fn: orig_proc.source_location.first,
+        compiled_fn: "::#{ast_digest}"
+      }
+      @source_map_line_ofs = 1
+      self
+    end
+    def format_compiled_template(ast, orig_ast, wrap:, binding:)
+      # generate source code
+      @binding = binding
+      visit(ast)
+      flush_html_parts!(semicolon_prefix: true)
+      source_code = @buffer
+      @buffer = +''
+      if wrap
+        emit("(#{@source_map.inspect}).then { |src_map| ->(__buffer__")
+        params = orig_ast.parameters
+        params = params&.parameters
+        if params
+          emit(', ')
+          emit(format_code(params))
+        end
+        if @yield_used
+          emit(', &__block__')
+        end
+        emit(") do\n")
+      end
+      @buffer << source_code
+      emit_postlude
+      if wrap
+        emit('; __buffer__')
+        adjust_whitespace(orig_ast.closing_loc)
+        emit(";") if @buffer !~ /\n\s*$/m
+        emit("rescue Exception => e; P2.translate_backtrace(e, src_map); raise e; end }")
+      end
+      @buffer
+    end
+    def emit_code(loc, semicolon: false, chomp: false, flush_html: true)
+      flush_html_parts! if flush_html
+      super(loc, semicolon:, chomp: )
+    end
+    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
+      is_void = is_void_element?(tag)
+      emit_html(node.tag_location, format_html_tag_open(tag, node.attributes))
+      return if is_void
+      case node.block
+      when Prism::BlockNode
+        visit(node.block.body)
+      when Prism::BlockArgumentNode
+        flush_html_parts!
+        adjust_whitespace(node.block)
+        emit("; #{format_code(node.block.expression)}.render_to_buffer(__buffer__)")
+      end
+      if node.inner_text
+        if is_static_node?(node.inner_text)
+          emit_html(node.location, CGI.escape_html(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)}")
+          else
+            emit_html(node.location, "#\{CGI.escape_html(#{format_code(node.inner_text)})}")
+          end
+        end
+      end
+      emit_html(node.location, format_html_tag_close(tag))
+    end
+    def visit_const_tag_node(node)
+      flush_html_parts!
+      adjust_whitespace(node.location)
+      if node.receiver
+        emit(node.receiver.location)
+        emit('::')
+      end
+      emit("; #{node.name}.render_to_buffer(__buffer__")
+      if node.arguments
+        emit(', ')
+        visit(node.arguments)
+      end
+      emit(');')
+    end
+    def visit_emit_node(node)
+      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)
+        else
+          emit_html(node.location, "#\{P2.render_emit_call(#{format_code(first_arg)})}")
+        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})}")
+      end
+    end
+    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, CGI.escape_html(format_literal(first_arg)))
+        else
+          emit_html(node.location, "#\{CGI.escape_html(#{format_code(first_arg)}.to_s)}")
+        end
+      else
+        raise "Don't know how to compile #{node}"
+      end
+    end
+    def visit_defer_node(node)
+      block = node.block
+      return if !block
+      flush_html_parts!
+      if !@defer_mode
+        adjust_whitespace(node.call_node.message_loc)
+        emit("__orig_buffer__ = __buffer__; __parts__ = __buffer__ = []; ")
+        @defer_mode = true
+      end
+      adjust_whitespace(block.opening_loc)
+      emit("__buffer__ << ->{")
+      visit(block.body)
+      flush_html_parts!
+      adjust_whitespace(block.closing_loc)
+      emit("}")
+    end
+    def visit_custom_tag_node(node)
+      case node.tag
+      when :tag
+        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
+        args = node.call_node.arguments
+        return if !args
+        emit_html(node.location, "#\{P2.markdown(#{format_code(args)})}")
+      end
+    end
+    def visit_yield_node(node)
+      adjust_whitespace(node.location)
+      flush_html_parts!
+      @yield_used = true
+      emit("; (__block__ ? __block__.render_to_buffer(__buffer__")
+      if node.arguments
+        emit(', ')
+        visit(node.arguments)
+      end
+      emit(") : raise(LocalJumpError, 'no block given (yield)'))")
+    end
+    private
+    def format_code(node, klass = TemplateCompiler)
+      klass.new(minimize_whitespace: true).to_source(node)
+    end
+    VOID_TAGS = %w(area base br col embed hr img input link meta param source track wbr)
+    def is_void_element?(tag)
+      VOID_TAGS.include?(tag.to_s)
+    end
+    def format_html_tag_open(tag, attributes)
+      tag = convert_tag(tag)
+      if attributes && attributes&.elements.size > 0
+        "<#{tag} #{format_html_attributes(attributes)}>"
+      else
+        "<#{tag}>"
+      end
+    end
+    def format_html_tag_close(tag)
+      tag = convert_tag(tag)
+      "</#{tag}>"
+    end
+    def convert_tag(tag)
+      case tag
+      when Prism::SymbolNode, Prism::StringNode
+        P2.format_tag(tag.unescaped)
+      when Prism::Node
+        "#\{P2.format_tag(#{format_code(tag)})}"
+      else
+        P2.format_tag(tag)
+      end
+    end
+    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
+        format_code(node)[1..-2]
+      when Prism::TrueNode
+        'true'
+      when Prism::FalseNode
+        'false'
+      when Prism::NilNode
+        ''
+      else
+        "#\{#{format_code(node)}}"
+      end
+    end
+    STATIC_NODE_TYPES = [
+      Prism::FalseNode,
+      Prism::FloatNode,
+      Prism::IntegerNode,
+      Prism::NilNode,
+      Prism::StringNode,
+      Prism::SymbolNode,
+      Prism::TrueNode
+    ]
+    def is_static_node?(node)
+      STATIC_NODE_TYPES.include?(node.class)
+    end
+    STRING_TYPE_NODE_TYPES = [
+      Prism::StringNode,
+      Prism::InterpolatedStringNode
+    ]
+    def is_string_type_node?(node)
+      STRING_TYPE_NODE_TYPES.include?(node.class)
+    end
+    def format_html_attributes(node)
+      elements = node.elements
+      dynamic_attributes = elements.any? do
+        it.is_a?(Prism::AssocSplatNode) ||
+          !is_static_node?(it.key) || !is_static_node?(it.value)
+      end
+      return "#\{P2.format_html_attrs(#{format_code(node)})}" if dynamic_attributes
+      parts = elements.map do
+        key = it.key
+        value = it.value
+        case value
+        when Prism::TrueNode
+          format_literal(key)
+        when Prism::FalseNode, Prism::NilNode
+          nil
+        else
+          k = format_literal(key)
+          if is_static_node?(value)
+            value = format_literal(value)
+            "#{P2.format_html_attr_key(k)}=\\\"#{value}\\\""
+          else
+            "#{P2.format_html_attr_key(k)}=\\\"#\{#{format_code(value)}}\\\""
+          end
+        end
+      end
+      parts.compact.join(' ')
+    end
+    def emit_html(loc, str)
+      @html_loc_start ||= loc
+      @html_loc_end = loc
+      @pending_html_parts << str
+    end
+    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 '; '
+      end
+      str = @pending_html_parts.join
+      @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)
+      @html_loc_start = nil
+      @html_loc_end = nil
+      emit "__buffer__ << \"#{str}\""
+    end
+    def emit_postlude
+      return if !@defer_mode
+      emit("; __buffer__ = __orig_buffer__; __parts__.each { it.is_a?(Proc) ? it.() : (__buffer__ << it) }")
+    end
+  end
+end

data/lib/p2/proc_ext.rb ADDED Viewed

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+require_relative './compiler'
+# Extensions to the Proc class
+class ::Proc
+  def compiled_code
+    P2::TemplateCompiler.compile_to_code(self)
+  end
+  def compiled?
+    @is_compiled
+  end
+  def compiled!
+    @is_compiled = true
+    self
+  end
+  def compiled_proc
+    @compiled_proc ||= @is_compiled ? self : compile
+  end
+  def compile
+    P2.compile(self).compiled!
+  rescue Sirop::Error
+    uncompiled_renderer
+  end
+  def render(*a, **b, &c)
+    compiled_proc.(+'', *a, **b, &c)
+  end
+  def render_to_buffer(buf, *a, **b, &c)
+    compiled_proc.(buf, *a, **b, &c)
+  end
+  def uncompiled_renderer
+    ->(__buffer__, *a, **b, &c) {
+      P2::UncompiledProcWrapper.new(self).call(__buffer__, *a, **b, &c)
+      __buffer__
+    }.compiled!
+  end
+  def apply(*a, **b, &c)
+    compiled = compiled_proc
+    c_compiled = c&.compiled_proc
+    ->(__buffer__, *x, **y, &z) {
+      c_proc = c_compiled && ->(__buffer__, *d, **e) {
+        c_compiled.(__buffer__, *a, *d, **b, **e, &z)
+      }.compiled!
+      compiled.(__buffer__, *a, *x, **b, **y, &c_proc)
+    }.compiled!
+  end
+end
+module P2
+  class UncompiledProcWrapper
+    def initialize(proc)
+      @proc = proc
+    end
+    def call(buffer, *a, **b)
+      @buffer = buffer
+      instance_exec(*a, **b, &@proc)
+    end
+    def method_missing(sym, *a, **b, &c)
+      tag(sym, *a, **b, &c)
+    end
+    def p(*a, **b, &c)
+      tag(:p, *a, **b, &c)
+    end
+    def tag(sym, *a, **b, &block)
+      @buffer << "<#{sym}>"
+      if block
+        instance_eval(&block)
+      end
+      @buffer << "</#{sym}>"
+    end
+  end
+end

data/lib/p2/version.rb ADDED Viewed

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

data/lib/p2.rb ADDED Viewed

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+require_relative 'p2/compiler'
+require_relative 'p2/proc_ext'
+# P2 is a composable templating library
+module P2
+  # Exception class used to signal templating-related errors
+  class Error < RuntimeError; end
+  class << self
+    def compile(proc)
+      P2::TemplateCompiler.compile(proc)
+    end
+    def format_tag(tag)
+      tag.to_s.gsub('_', '-')
+    end
+    def format_html_attr_key(tag)
+      tag.to_s.tr('_', '-')
+    end
+    def format_html_attrs(attrs)
+      attrs.each_with_object(+'') do |(k, v), html|
+        case v
+        when nil, false
+        when true
+          html << ' ' if !html.empty?
+          html << format_html_attr_key(k)
+        else
+          html << ' ' if !html.empty?
+          v = v.join(' ') if v.is_a?(Array)
+          html << "#{format_html_attr_key(k)}=\"#{v}\""
+        end
+      end
+    end
+    def render_emit_call(o, *a, **b, &block)
+      case o
+      when nil
+        # do nothing
+      when ::Proc
+        o.render(*a, **b, &block)
+      else
+        o.to_s
+      end
+    end
+    def translate_backtrace(e, source_map)
+      re = /^(#{source_map[:compiled_fn]}\:(\d+))/
+      source_fn = source_map[:source_fn]
+      backtrace = e.backtrace.map {
+        if (m = it.match(re))
+          line = m[2].to_i
+          source_line = source_map[line] || "?(#{line})"
+          it.sub(m[1], "#{source_fn}:#{source_line}")
+        else
+          it
+        end
+      }
+      e.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.
+    #
+    # @param markdown [String] Markdown
+    # @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'
+      opts = default_kramdown_options.merge(opts)
+      Kramdown::Document.new(markdown, **opts).to_html
+    end
+    # Returns the default Kramdown options used for rendering Markdown.
+    #
+    # @return [Hash] Kramdown options
+    def default_kramdown_options
+      @default_kramdown_options ||= {
+        entity_output: :numeric,
+        syntax_highlighter: :rouge,
+        input: 'GFM',
+        hard_wrap: false
+      }
+    end
+    # Sets the default Kramdown options used for rendering Markdown.
+    #
+    # @param opts [Hash] Kramdown options
+    # @return [void]
+    def default_kramdown_options=(opts)
+      @default_kramdown_options = opts
+    end
+  end
+end

data/p2.png ADDED Viewed

Binary file

metadata ADDED Viewed

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: p2
+version: !ruby/object:Gem::Version
+  version: '2.0'
+platform: ruby
+authors:
+- Sharon Rosner
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sirop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.1
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.5.1
+- !ruby/object:Gem::Dependency
+  name: kramdown-parser-gfm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.25.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.25.4
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.2
+email: sharon@noteflakes.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- p2.png
+files:
+- CHANGELOG.md
+- README.md
+- lib/p2.rb
+- lib/p2/compiler.rb
+- lib/p2/proc_ext.rb
+- lib/p2/version.rb
+- p2.png
+homepage: http://github.com/digital-fabric/p2
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/digital-fabric/p2
+  documentation_uri: https://www.rubydoc.info/gems/p2
+  homepage_uri: https://github.com/digital-fabric/p2
+  changelog_uri: https://github.com/digital-fabric/p2/blob/master/CHANGELOG.md
+rdoc_options:
+- "--title"
+- P2
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'P2: component-based HTML templating for Ruby'
+test_files: []