p2 2.0.1 → 2.2

data/lib/p2/proc_ext.rb

@@ -4,83 +4,73 @@ require_relative './compiler'
 
 # Extensions to the Proc class
 class ::Proc
+  # Returns the compiled form code for the proc
+  #
+  # @return [String] compiled proc code
   def compiled_code
-    P2::TemplateCompiler.compile_to_code(self).last
+    P2::Compiler.compile_to_code(self).last
   end
 
+  # 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
+  #
+  # @return [self]
   def compiled!
     @is_compiled = true
     self
   end
 
+  # Returns the compiled proc for the given proc. If marked as compiled, returns
+  # self.
+  #
+  # @return [Proc] compiled proc or self
   def compiled_proc
     @compiled_proc ||= @is_compiled ? self : compile
   end
-  
+
+  # Compiles the proc into the compiled form
+  #
+  # @return [Proc] compiled proc
   def compile
-    P2.compile(self).compiled!
+    P2::Compiler.compile(self).compiled!
   rescue Sirop::Error
-    uncompiled_renderer
+    raise P2::Error, "Dynamically defined procs cannot be compiled"
   end
 
+  # Renders the proc to HTML with the given arguments
+  #
+  # @return [String] HTML string
   def render(*a, **b, &c)
     compiled_proc.(+'', *a, **b, &c)
   end
 
+  # Renders the proc into the given buffer
+  #
+  # @return [String] HTML string
   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
-
+  # Returns a proc that applies the given arguments to the original proc
+  #
+  # @return [Proc] applied proc
   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

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

data/lib/p2.rb

@@ -3,99 +3,105 @@
 require_relative 'p2/compiler'
 require_relative 'p2/proc_ext'
 
-# P2 is a composable templating library
+# P2 is a functional templating library. In P2, templates are expressed as plain
+# Ruby procs.
 module P2
   # Exception class used to signal templating-related errors
   class Error < RuntimeError; end
 
-  class << self
-    def compile(proc)
-      P2::TemplateCompiler.compile(proc)
-    end
+  extend self
 
-    def format_tag(tag)
-      tag.to_s.gsub('_', '-')
-    end
+  # Formats the given string, converting underscores to dashes.
+  #
+  # @param tag [String, Symbol] input string
+  # @return [String] output string
+  def underscores_to_dashes(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
+  # Formats the given hash as tag attributes.
+  #
+  # @param attrs [Hash] input hash
+  # @return [String] formatted attributes
+  def format_tag_attrs(attrs)
+    attrs.each_with_object(+'') do |(k, v), html|
+      case v
+      when nil, false
+      when true
+        html << ' ' if !html.empty?
+        html << underscores_to_dashes(k)
+      else
+        html << ' ' if !html.empty?
+        v = v.join(' ') if v.is_a?(Array)
+        html << "#{underscores_to_dashes(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)
+  # Translates an exceptions backtrace using a source map.
+  #
+  # @param exception [Exception] raised exception
+  # @param source_map [Hash] source map
+  #
+  # @return [Exception] raised exception
+  def translate_backtrace(exception, source_map)
+    re = compute_source_map_re(source_map)
+    source_fn = source_map[:source_fn]
+    backtrace = exception.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
-        o.to_s
+        it
       end
-    end
+    }
+    exception.set_backtrace(backtrace)
+    exception
+  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
+  # Computes a Regexp for matching hits in a backtrace.
+  #
+  # @param source_map [Hash] source map
+  # @return [Regexp] computed regexp
+  def compute_source_map_re(source_map)
+    escaped = source_map[:compiled_fn].gsub(/[\(\)]/) { "\\#{it[0]}" }
+    /^(#{escaped}\:(\d+))/
+  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
+  # 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'
 
-    # 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
+    opts = default_kramdown_options.merge(opts)
+    Kramdown::Document.new(markdown, **opts).to_html
+  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
+  # 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 [Hash] Kramdown options
+  def default_kramdown_options=(opts)
+    @default_kramdown_options = opts
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: p2
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: '2.2'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 0.8.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 0.8.3
 - !ruby/object:Gem::Dependency
   name: kramdown
   requirement: !ruby/object:Gem::Requirement
@@ -93,20 +93,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.7.2
-- !ruby/object:Gem::Dependency
-  name: tilt
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.0
 email: sharon@noteflakes.com
 executables: []
 extensions: []
@@ -118,6 +104,8 @@ files:
 - README.md
 - lib/p2.rb
 - lib/p2/compiler.rb
+- lib/p2/compiler/nodes.rb
+- lib/p2/compiler/tag_translator.rb
 - lib/p2/proc_ext.rb
 - lib/p2/version.rb
 - p2.png