rubyoshka 0.4 → 0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c084b7ff1e4a364ea95df6fa3824c1a67a190aae85c8ad50812132ef7acd5cf
-  data.tar.gz: 8b04fd36caf85ca4dc7883f2efad96ed53753d5b59548e19a9a3c5ec85f6fa28
+  metadata.gz: 82ae63e4b9ff27ff20f8635c7e619b4a1dd88c1a6b2e1e7c4a7dbdad64381b40
+  data.tar.gz: ff00cf661c6394e2cd00443cbc7204dff6bbff434d9602cb244a274b257f1059
 SHA512:
-  metadata.gz: 27c7bafa5f1851982ee05ccf9f90e1513c4b426217531f6daa205ce872ad57be9c672ba35ce1e5f0a6b882aa93dbf3987dab2375282e0bda22c897df1cf2ff5f
-  data.tar.gz: 8a35f8f8ef434e21a48208d079d62acb4df497d6a44234caee41c4a1df92de8d20c8bc3329ce624eed2691fde5205961681b4a8ebd2e80966b99ee65e58c8b4f
+  metadata.gz: 8a2aff7151025e7a83466da15c21878868bc1160bb6bab37396a38ce6ecad08a49c807c8177bc153f22785ff6e6cdfe2eadb82950d4b06cc4d492d5654aa37b0
+  data.tar.gz: f11bfa4d801a259d0825f91267217009be156feba3fc567ea68de4941779fa40c07755a63a2f9812507c2858d7fb54d0d78f5601546003165fe27b912caf6f1e

data/CHANGELOG.md

@@ -1,23 +1,39 @@
-0.4 2019-02-05
---------------
+## 0.7 2021-09-29
 
-* Add support for emitting component modules
+- Add `#emit_yield` for rendering layouts
+- Add experimental template compilation (WIP)
 
-0.3 2019-01-13
---------------
+## 0.6.1 2021-03-03
 
-* Implement caching
-* Improve performance
-* Handle attributes with `false` value correctly
+- Remove support for Ruby 2.6
 
-0.2 2019-01-07
---------------
+## 0.6 2021-03-03
 
-* Better documentation
-* Fix #text
-* Add local context
+- Fix Rubyoshka on Ruby 3.0
+- Refactor and add more tests
 
-0.1 2019-01-06
---------------
+## 0.5 2021-02-27
 
-* First working version
+- Add support for rendering XML
+- Add Rubyoshka.component method
+- Remove Modulation dependency
+
+## 0.4 2019-02-05
+
+- Add support for emitting component modules
+
+## 0.3 2019-01-13
+
+- Implement caching
+- Improve performance
+- Handle attributes with `false` value correctly
+
+## 0.2 2019-01-07
+
+- Better documentation
+- Fix #text
+- Add local context
+
+## 0.1 2019-01-06
+
+- First working version

data/README.md

@@ -226,16 +226,17 @@ greeting.render(name: 'world')
 ## Templates as components
 
 Rubyoshka makes it easy to compose multiple separate templates into a whole HTML
-document. Each template can be defined as a self-contained component that can
-be reused inside other components. Components should be defined as constants,
-either in the global namespace, or on the `Rubyoshka` namespace. Each component
-can be defined as either a Rubyoshka instance (using `#H`) or as a `proc` that
-returns a Rubyoshka instance:
+document. Each template can be defined as a self-contained component that can be
+reused inside other components. Components can be defined as either a Rubyoshka
+instance (using `#H`), a `proc` that returns a Rubyoshka instance, or using
+`Rubyoshka.component`:
 
 ```ruby
+# Simple component relying on global/local context
 Title = H { h1 title }
 
-# Item is actually a Proc that returns a template
+# Proc component that returns a template
+# Notice how the lambda expression takes keyword arguments
 Item = ->(id:, text:, checked:) {
   H {
     li {
@@ -245,20 +246,29 @@ Item = ->(id:, text:, checked:) {
   }
 }
 
-def render_items(items)
+# Components using Rubyoshka.component (or H.component) are a bit more compact.
+# Any parameters are passed as arguments to the block.
+NavBar = Rubyoshka.component do |links|
+  div {
+    links.each { |l| a l[:title], href: l[:url] }
+  }
+end
+
+def render_items(items, links)
   html = H {
     Title()
+    NavBar(links)
     ul {
       items.each { |id, attributes|
         Item id: id, text: attributes[:text], checked: attributes[:active]
       }
     }
-  }.render
+  }.render(title: 'Hello from components')
 end
 ```
 
 Note that a component is invoked as a method, which means that if no arguments
-are passed, you should add an empty pair of parens, as shown in the example
+are passed, you must add an empty pair of parens, as shown in the example
 above.
 
 In addition to using components defined as constants, you can also use
@@ -274,6 +284,43 @@ H {
 }
 ```
 
+## Layout templates
+
+Rubyoshka templates can also be used to implement layout templates by using
+`#emit_yield`:
+
+```ruby
+layout = H {
+  html5 {
+    head { ... }
+    body {
+      header { ... }
+      body {
+        emit_yield
+      }
+      footer { ... }
+    }
+  }
+}
+```
+
+To use the layout, supply a block when calling `#render`:
+
+```ruby
+layout.render {
+  h1 'foo'
+  p 'bar'
+}
+
+# you can also pass a template as the block
+inner = H {
+  h1 'foo'
+  p 'bar'
+}
+
+layout.render(&inner)
+```
+
 ## Fragment caching
 
 Any part of a Rubyoshka template can be cached - a fragment, a component, or a
@@ -319,8 +366,8 @@ reused in multiple different templates in your app.
 ### Changing the cache store
 
 Rubyoshka ships with a naïve in-memory cache store built-in. You can use
-another cache store by overriding the `Rubyoshka.cache_get` and
-`Rubyoshka.cache_set` methods (see API [reference](#api-reference)).
+another cache store by overriding the `Rubyoshka.cache` method (see API
+[reference](#rubyoshkacache)).
 
 ## Wrapping arbitrary HTML with a component
 

data/lib/rubyoshka/compiler.rb

@@ -0,0 +1,428 @@
+# frozen_string_literal: true
+
+class Rubyoshka
+  # The Compiler class compiles Rubyoshka templates
+  class Compiler
+    DEFAULT_CODE_BUFFER_CAPACITY = 8192
+    DEFAULT_EMIT_BUFFER_CAPACITY = 4096
+
+    def initialize
+      @level = 1
+      @code_buffer = String.new(capacity: DEFAULT_CODE_BUFFER_CAPACITY)
+    end
+
+    def emit_output
+      @output_mode = true
+      yield
+      @output_mode = false
+    end
+
+    def emit_code_line_break
+      return if @code_buffer.empty?
+
+      @code_buffer << "\n" if @code_buffer[-1] != "\n"
+      @line_break = nil
+    end
+
+    def emit_literal(lit)
+      if @output_mode
+        emit_code_line_break if @line_break
+        @emit_buffer ||= String.new(capacity: DEFAULT_EMIT_BUFFER_CAPACITY)
+        @emit_buffer << lit
+      else
+        emit_code(lit)
+      end
+    end
+
+    def emit_text(str, encoding: :html)
+      emit_code_line_break if @line_break
+      @emit_buffer ||= String.new(capacity: DEFAULT_EMIT_BUFFER_CAPACITY)
+      @emit_buffer << encode(str, encoding).inspect[1..-2]
+    end
+
+    def encode(str, encoding)
+      case encoding
+      when :html
+        __html_encode__(str)
+      when :uri
+        __uri_encode__(str)
+      else
+        raise "Invalid encoding #{encoding.inspect}"
+      end
+    end
+
+    def emit_expression
+      if @output_mode
+        emit_literal('#{__html_encode__(')
+        yield
+        emit_literal(')}')
+      else
+        yield
+      end
+    end
+
+    def flush_emit_buffer
+      return if !@emit_buffer
+
+      @code_buffer << "#{'  ' * @level}__buffer__ << \"#{@emit_buffer}\"\n"
+      @emit_buffer = nil
+      true
+    end
+
+    def emit_code(code)
+      if flush_emit_buffer || @line_break
+        emit_code_line_break if @line_break
+        @code_buffer << "#{'  ' * @level}#{code}"
+      else
+        if @code_buffer.empty? || (@code_buffer[-1] == "\n")
+          @code_buffer << "#{'  ' * @level}#{code}"
+        else
+          @code_buffer << "#{code}"
+        end
+      end
+    end
+
+    def compile(template)
+      @block = template.to_proc
+      ast = RubyVM::AbstractSyntaxTree.of(@block)
+      # Compiler.pp_ast(ast)
+      parse(ast)
+      flush_emit_buffer
+      self
+    end
+
+    attr_reader :code_buffer
+
+    def to_code
+      "->(__buffer__, __context__) do\n#{@code_buffer}end"
+    end
+
+    def to_proc
+      @block.binding.eval(to_code)
+    end
+
+    def parse(node)
+      @line_break = @last_node && node.first_lineno != @last_node.first_lineno
+      @last_node = node
+      # puts "- parse(#{node.type}) (break: #{@line_break.inspect})"
+      send(:"parse_#{node.type.downcase}", node)
+    end
+
+    def parse_scope(node)
+      parse(node.children[2])
+    end
+
+    def parse_iter(node)
+      call, scope = node.children
+      if call.type == :FCALL
+        parse_fcall(call, scope)
+      else
+        parse(call)
+        emit_code(" do")
+        args = scope.children[0]
+        emit_code(" |#{args.join(', ')}|") if args
+        emit_code("\n")
+        @level += 1
+        parse(scope)
+        flush_emit_buffer
+        @level -= 1
+        emit_code("end\n")
+      end
+    end
+
+    def parse_ivar(node)
+      ivar = node.children.first.match(/^@(.+)*/)[1]
+      emit_literal("__context__[:#{ivar}]")
+    end
+
+    def parse_fcall(node, block = nil)
+      tag, args = node.children
+      args = args.children.compact if args
+      text = fcall_inner_text_from_args(args)
+      atts = fcall_attributes_from_args(args)
+      if block
+        emit_tag(tag, atts) { parse(block) }
+      elsif text
+        emit_tag(tag, atts) do
+          emit_output do
+            if text.is_a?(String)
+              emit_text(text)
+            else
+              emit_expression { parse(text) }
+            end
+          end
+        end
+      else
+        emit_tag(tag, atts)
+      end
+    end
+
+    def fcall_inner_text_from_args(args)
+      return nil if !args
+
+      first = args.first
+      case first.type
+      when :STR
+        first.children.first
+      when :LIT
+        first.children.first.to_s
+      when :HASH
+        nil
+      else
+        first
+      end
+    end
+
+    def fcall_attributes_from_args(args)
+      return nil if !args
+
+      last = args.last
+      (last.type == :HASH) ? last : nil
+    end
+
+    def emit_tag(tag, atts, &block)
+      emit_output do
+        if atts
+          emit_literal("<#{tag}")
+          emit_tag_attributes(atts)
+          emit_literal(block ? '>' : '/>')
+        else
+          emit_literal(block ? "<#{tag}>" : "<#{tag}/>")
+        end
+      end
+      if block
+        block.call
+        emit_output { emit_literal("</#{tag}>") }
+      end
+    end
+
+    def emit_tag_attributes(atts)
+      list = atts.children.first.children
+      while true
+        key = list.shift
+        break unless key
+
+        value = list.shift
+        value_type = value.type
+        case value_type
+        when :FALSE, :NIL
+          next
+        end
+
+        emit_literal(' ')
+        emit_tag_attribute_key(key)
+        next if value_type == :TRUE
+        
+        emit_literal('=\"')
+        emit_tag_attribute_value(value, key)
+        emit_literal('\"')
+      end
+    end
+
+    def emit_tag_attribute_key(key)
+      case key.type
+      when :STR
+        emit_literal(key.children.first)
+      when :LIT
+        emit_literal(key.children.first.to_s)
+      when :NIL
+        emit_literal('nil')
+      else
+        emit_expression { parse(key) }
+      end
+    end
+
+    def emit_tag_attribute_value(value, key)
+      case value.type
+      when :STR
+        encoding = (key.type == :LIT) && (key.children.first == :href) ? :uri : :html
+        emit_text(value.children.first, encoding: encoding)
+      when :LIT
+        emit_text(value.children.first.to_s)
+      else
+        parse(value)
+      end
+    end
+
+    def parse_call(node)
+      receiver, method, args = node.children
+      if receiver.type == :VCALL && receiver.children == [:context]
+        emit_literal('__context__')
+      else
+        parse(receiver)
+      end
+      if method == :[]
+        emit_literal('[')
+        args = args.children.compact
+        while true
+          arg = args.shift
+          break unless arg
+
+          parse(arg)
+          emit_literal(', ') if !args.empty?
+        end
+        emit_literal(']')
+      else
+        emit_literal('.')
+        emit_literal(method.to_s)
+        if args
+          emit_literal('(')
+          args = args.children.compact
+          while true
+            arg = args.shift
+            break unless arg
+
+            parse(arg)
+            emit_literal(', ') if !args.empty?
+          end
+          emit_literal(')')
+        end
+      end
+    end
+
+    def parse_str(node)
+      str = node.children.first
+      emit_literal(str.inspect)
+    end
+
+    def parse_lit(node)
+      value = node.children.first
+      emit_literal(value.inspect)
+    end
+
+    def parse_true(node)
+      emit_expression { emit_literal('true') }
+    end
+
+    def parse_false(node)
+      emit_expression { emit_literal('true') }
+    end
+
+    def parse_list(node)
+      emit_literal('[')
+      items = node.children.compact
+      while true
+        item = items.shift
+        break unless item
+
+        parse(item)
+        emit_literal(', ') if !items.empty?
+      end
+      emit_literal(']')
+    end
+
+    def parse_vcall(node)
+      tag = node.children.first
+      emit_tag(tag, nil)
+    end
+
+    def parse_opcall(node)
+      left, op, right = node.children
+      parse(left)
+      emit_literal(" #{op} ")
+      right.children.compact.each { |c| parse(c) }
+    end
+
+    def parse_block(node)
+      node.children.each { |c| parse(c) }
+    end
+
+    def parse_if(node)
+      cond, then_branch, else_branch = node.children
+      if @output_mode
+        emit_if_output(cond, then_branch, else_branch)
+      else
+        emit_if_code(cond, then_branch, else_branch)
+      end
+    end
+
+    def parse_unless(node)
+      cond, then_branch, else_branch = node.children
+      if @output_mode
+        emit_unless_output(cond, then_branch, else_branch)
+      else
+        emit_unless_code(cond, then_branch, else_branch)
+      end
+    end
+
+    def emit_if_output(cond, then_branch, else_branch)
+      parse(cond)
+      emit_literal(" ? ")
+      parse(then_branch)
+      emit_literal(" : ")
+      if else_branch
+        parse(else_branch)
+      else
+        emit_literal(nil)
+      end
+    end
+
+    def emit_unless_output(cond, then_branch, else_branch)
+      parse(cond)
+      emit_literal(" ? ")
+      if else_branch
+        parse(else_branch)
+      else
+        emit_literal(nil)
+      end
+      emit_literal(" : ")
+      parse(then_branch)
+    end
+
+    def emit_if_code(cond, then_branch, else_branch)
+      emit_code('if ')
+      parse(cond)
+      emit_code("\n")
+      @level += 1
+      parse(then_branch)
+      flush_emit_buffer
+      @level -= 1
+      if else_branch
+        emit_code("else\n")
+        @level += 1
+        parse(else_branch)
+        flush_emit_buffer
+        @level -= 1
+      end
+      emit_code("end\n")
+    end
+
+    def emit_unless_code(cond, then_branch, else_branch)
+      emit_code('unless ')
+      parse(cond)
+      emit_code("\n")
+      @level += 1
+      parse(then_branch)
+      flush_emit_buffer
+      @level -= 1
+      if else_branch
+        emit_code("else\n")
+        @level += 1
+        parse(else_branch)
+        flush_emit_buffer
+        @level -= 1
+      end
+      emit_code("end\n")
+    end
+
+    def parse_dvar(node)
+      
+      emit_literal(node.children.first.to_s)
+    end
+
+    def self.pp_ast(node, level = 0)
+      case node
+      when RubyVM::AbstractSyntaxTree::Node
+        puts "#{'  ' * level}#{node.type.inspect}"
+        node.children.each { |c| pp_ast(c, level + 1) }
+      when Array
+        puts "#{'  ' * level}["
+        node.each { |c| pp_ast(c, level + 1) }
+        puts "#{'  ' * level}]"
+      else
+        puts "#{'  ' * level}#{node.inspect}"
+        return
+      end
+    end
+  end
+end

data/lib/rubyoshka/html.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative './html'
+
+class Rubyoshka
+  # Markup extensions 
+  module HTML
+    # Emits the p tag (overrides Object#p)
+    # @param text [String] text content of tag
+    # @param props [Hash] tag attributes
+    # @para block [Proc] nested HTML block
+    # @return [void]
+    def p(text = nil, **props, &block)
+      method_missing(:p, text, **props, &block)
+    end
+  
+    S_HTML5_DOCTYPE = '<!DOCTYPE html>'
+  
+    # Emits an HTML5 doctype tag and an html tag with the given block
+    # @param block [Proc] nested HTML block
+    # @return [void]
+    def html5(&block)
+      @buffer << S_HTML5_DOCTYPE
+      self.html(&block)
+    end
+
+    def link_stylesheet(href, custom_attributes = nil)
+      attributes = {
+        rel: 'stylesheet',
+        href: href
+      }
+      if custom_attributes
+        attributes = custom_attributes.merge(attributes)
+      end
+      link(**attributes)
+    end
+  end
+end

data/lib/rubyoshka/renderer.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require_relative './html'
+
+class Rubyoshka
+  # A Renderer is a rendering of a Rubyoshka
+  class Renderer
+    attr_reader :context
+  
+    # Initializes attributes and renders the given block
+    # @param context [Hash] rendering context
+    # @param block [Proc] template block
+    # @return [void]
+    def initialize(context, template)
+      @context = context
+      @buffer = +''
+      instance_eval(&template)
+    end
+  
+    # Returns the result of the rendering
+    # @return [String]
+    def to_s
+      @buffer
+    end
+
+    def escape_text(text)
+      raise NotImplementedError
+    end
+
+    def escape_uri(uri)
+      EscapeUtils.escape_uri(v)
+    end
+
+    S_TAG_METHOD_LINE = __LINE__ + 1
+    S_TAG_METHOD = <<~EOF
+      S_TAG_%<TAG>s_PRE = '<%<tag>s'
+      S_TAG_%<TAG>s_CLOSE = '</%<tag>s>'
+      
+      def %<tag>s(text = nil, **props, &block)
+        @buffer << S_TAG_%<TAG>s_PRE
+        emit_props(props) unless props.empty?
+      
+        if block
+          @buffer << S_GT
+          instance_eval(&block)
+          @buffer << S_TAG_%<TAG>s_CLOSE
+        elsif Rubyoshka === text
+          @buffer << S_GT
+          emit(text)
+          @buffer << S_TAG_%<TAG>s_CLOSE
+        elsif text
+          @buffer << S_GT << escape_text(text.to_s) << S_TAG_%<TAG>s_CLOSE
+        else
+          @buffer << S_SLASH_GT
+        end
+      end
+    EOF
+
+    R_CONST_SYM = /^[A-Z]/
+  
+    # Catches undefined tag method call and handles them by defining the method
+    # @param sym [Symbol] HTML tag or component identifier
+    # @param args [Array] method call arguments
+    # @param block [Proc] block passed to method call
+    # @return [void]
+    def method_missing(sym, *args, **opts, &block)
+      value = @local && @local[sym]
+      return value if value
+
+      if sym =~ R_CONST_SYM
+        # Component reference (capitalized method name)
+        o = instance_eval(sym.to_s) rescue Rubyoshka.const_get(sym) \
+            rescue Object.const_get(sym)
+        case o
+        when ::Proc
+          self.class.define_method(sym) { |*a, **c, &b| emit(o.(*a, **c, &b)) }
+          emit(o.(*args, **opts, &block))
+        when Rubyoshka
+          self.class.define_method(sym) do |**ctx|
+            ctx.empty? ? emit(o) : with(**ctx) { emit(o) }
+          end
+          Hash === opts.empty? ? emit(o) : with(**opts) { emit(o) }
+        when ::String
+          @buffer << o
+        else
+          e = StandardError.new "Cannot render #{o.inspect}"
+          e.set_backtrace(caller)
+          raise e
+        end
+      else
+        tag = sym.to_s
+        code = S_TAG_METHOD % { tag: tag, TAG: tag.upcase }
+        self.class.class_eval(code, __FILE__, S_TAG_METHOD_LINE)
+        send(sym, *args, **opts, &block)
+      end
+    end
+  
+    # Emits the given object into the rendering buffer
+    # @param o [Proc, Rubyoshka, Module, String] emitted object
+    # @return [void]
+    def emit(o)
+      case o
+      when ::Proc
+        instance_eval(&o)
+      when Rubyoshka
+        instance_eval(&o.template)
+      when Module
+        # If module is given, the component is expected to be a const inside the module
+        emit(o::Component)
+      when nil
+      else
+        @buffer << o.to_s
+      end
+    end
+    alias_method :e, :emit
+
+    def emit_yield
+      block = @context[:__block__]
+      raise LocalJumpError, "no block given (emit_yield)" unless block
+
+      instance_eval(&block)
+    end
+  
+    S_LT              = '<'
+    S_GT              = '>'
+    S_LT_SLASH        = '</'
+    S_SPACE_LT_SLASH  = ' </'
+    S_SLASH_GT        = '/>'
+    S_SPACE           = ' '
+    S_EQUAL_QUOTE     = '="'
+    S_QUOTE           = '"'
+
+    # Emits tag attributes into the rendering buffer
+    # @param props [Hash] tag attributes
+    # @return [void]
+    def emit_props(props)
+      props.each { |k, v|
+        case k
+        when :src, :href
+          @buffer << S_SPACE << k.to_s << S_EQUAL_QUOTE <<
+            EscapeUtils.escape_uri(v) << S_QUOTE
+        else
+          case v
+          when true
+            @buffer << S_SPACE << k.to_s
+          when false, nil
+            # emit nothing
+          else
+            @buffer << S_SPACE << k.to_s << S_EQUAL_QUOTE << v << S_QUOTE
+          end
+        end
+      }
+    end
+
+    # Emits text into the rendering buffer
+    # @param data [String] text
+    def text(data)
+      @buffer << escape_text(data)
+    end
+
+    # Sets a local context for the given block
+    # @param ctx [Hash] context hash
+    # @param block [Proc] nested HTML block
+    # @return [void]
+    def with(**ctx, &block)
+      old_local, @local = @local, ctx
+      instance_eval(&block)
+    ensure
+      @local = old_local
+    end
+
+    # Caches the given block with the given arguments as cache key
+    # @param vary [*Object] cache key
+    # @param block [Proc] nested HTML block
+    # @return [void]
+    def cache(*vary, **opts, &block)
+      key = [block.source_location.hash, vary.hash, opts.hash]
+
+      if (cached = Rubyoshka.cache[key])
+        @buffer << cached
+        return
+      end
+
+      cache_pos = @buffer.length
+      instance_eval(&block)
+      diff = @buffer[cache_pos..-1]
+      Rubyoshka.cache[key] = diff
+    end
+  end
+
+  class HTMLRenderer < Renderer
+    include HTML
+    
+    def escape_text(text)
+      EscapeUtils.escape_html(text.to_s)
+    end
+  end
+
+  class XMLRenderer < Renderer
+    def escape_text(text)
+      EscapeUtils.escape_xml(text.to_s)
+    end
+  end
+end

data/lib/rubyoshka/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Rubyoshka
-  VERSION = '0.4'
+  VERSION = '0.7'
 end

data/lib/rubyoshka.rb

@@ -1,208 +1,31 @@
 # frozen_string_literal: true
 
-require 'modulation/gem'
 require 'escape_utils'
 
-export_default :Rubyoshka
+require_relative 'rubyoshka/renderer'
+require_relative 'rubyoshka/compiler'
 
 # A Rubyoshka is a template representing a piece of HTML
 class Rubyoshka
-  # A Rendering is a rendering of a Rubyoshka
-  class Rendering
-    attr_reader :context
-  
-    # Initializes attributes and renders the given block
-    # @param context [Hash] rendering context
-    # @param block [Proc] template block
-    # @return [void]
-    def initialize(context, &block)
-      @context = context
-      @buffer = +''
-      instance_eval(&block)
-    end
-  
-    # Returns the result of the rendering
-    # @return [String]
-    def to_s
-      @buffer
-    end
-
-    E = EscapeUtils
-  
-    S_TAG_METHOD = <<~EOF
-      S_TAG_%<TAG>s_PRE = '<%<tag>s'
-      S_TAG_%<TAG>s_CLOSE = '</%<tag>s>'
-      
-      def %<tag>s(text = nil, **props, &block)
-        @buffer << S_TAG_%<TAG>s_PRE
-        emit_props(props) unless props.empty?
-      
-        if block
-          @buffer << S_GT
-          instance_eval(&block)
-          @buffer << S_TAG_%<TAG>s_CLOSE
-        elsif Rubyoshka === text
-          @buffer << S_GT
-          emit(text)
-          @buffer << S_TAG_%<TAG>s_CLOSE
-        elsif text
-          @buffer << S_GT << E.escape_html(text.to_s) << S_TAG_%<TAG>s_CLOSE
-        else
-          @buffer << S_SLASH_GT
-        end
-      end
-    EOF
-
-    R_CONST_SYM = /^[A-Z]/
-  
-    # Catches undefined tag method call and handles them by defining the method
-    # @param sym [Symbol] HTML tag or component identifier
-    # @param args [Array] method call arguments
-    # @param block [Proc] block passed to method call
-    # @return [void]
-    def method_missing(sym, *args, &block)
-      value = @local && @local[sym]
-      return value if value
-
-      if sym =~ R_CONST_SYM
-        o = instance_eval(sym.to_s) rescue Rubyoshka.const_get(sym) \
-            rescue Object.const_get(sym)
-        case o
-        when ::Proc
-          self.class.define_method(sym) { |*a, &b| emit(o.(*a, &b)) }
-          emit(o.(*args, &block))
-        when Rubyoshka
-          self.class.define_method(sym) { |**ctx|
-            ctx.empty? ? emit(o) : with(ctx) { emit(o) }
-          }
-          ctx = args.first
-          Hash === ctx ? with(ctx) { emit(o) } : emit(o)
-        when ::String
-          @buffer << o
-        else
-          e = StandardError.new "Cannot render #{o.inspect}"
-          e.set_backtrace(caller)
-          raise e
-        end
-      else
-        tag = sym.to_s
-        self.class.class_eval(S_TAG_METHOD % { tag: tag, TAG: tag.upcase })
-        send(sym, *args, &block)
-      end
-    end
-  
-    # Emits the given object into the rendering buffer
-    # @param o [Proc, Rubyoshka, Module, String] emitted object
-    # @return [void]
-    def emit(o)
-      case o
-      when ::Proc
-        instance_eval(&o)
-      when Rubyoshka
-        instance_eval(&o.block)
-      when Module
-        emit(o::Component)
-      when nil
-      else
-        @buffer << o.to_s
-      end
-    end
-    alias_method :e, :emit
-  
-    S_LT              = '<'
-    S_GT              = '>'
-    S_LT_SLASH        = '</'
-    S_SPACE_LT_SLASH  = ' </'
-    S_SLASH_GT        = '/>'
-    S_SPACE           = ' '
-    S_EQUAL_QUOTE     = '="'
-    S_QUOTE           = '"'
-
-    # Emits tag attributes into the rendering buffer
-    # @param props [Hash] tag attributes
-    # @return [void]
-    def emit_props(props)
-      props.each { |k, v|
-        case k
-        when :src, :href
-          @buffer << S_SPACE << k.to_s << S_EQUAL_QUOTE <<
-            E.escape_uri(v) << S_QUOTE
-        else
-          case v
-          when true
-            @buffer << S_SPACE << k.to_s
-          when false, nil
-            # emit nothing
-          else
-            @buffer << S_SPACE << k.to_s << S_EQUAL_QUOTE << v << S_QUOTE
-          end
-        end
-      }
+  module Encoding
+    def __html_encode__(text)
+      EscapeUtils.escape_html(text.to_s)
     end
 
-    # Emits the p tag
-    # @param text [String] text content of tag
-    # @param props [Hash] tag attributes
-    # @para block [Proc] nested HTML block
-    # @return [void]
-    def p(text = nil, **props, &block)
-      method_missing(:p, text, **props, &block)
+    def __uri_encode__(text)
+      EscapeUtils.escape_uri(text.to_s)
     end
+  end  
   
-    S_HTML5_DOCTYPE = '<!DOCTYPE html>'
-  
-    # Emits an HTML5 doctype tag and an html tag with the given block
-    # @param block [Proc] nested HTML block
-    # @return [void]
-    def html5(&block)
-      @buffer << S_HTML5_DOCTYPE
-      self.html(&block)
-    end
-
-    # Emits text into the rendering buffer
-    # @param data [String] text
-    def text(data)
-      @buffer << E.escape_html(data)
-    end
-
-    # Sets a local context for the given block
-    # @param ctx [Hash] context hash
-    # @param block [Proc] nested HTML block
-    # @return [void]
-    def with(**ctx, &block)
-      old_local, @local = @local, ctx
-      instance_eval(&block)
-    ensure
-      @local = old_local
-    end
-
-    # Caches the given block with the given arguments as cache key
-    # @param vary [*Object] cache key
-    # @param block [Proc] nested HTML block
-    # @return [void]
-    def cache(*vary, &block)
-      key = [block.source_location, *vary]
-
-      if (cached = Rubyoshka.cache[key])
-        @buffer << cached
-        return
-      end
-
-      cache_pos = @buffer.length
-      instance_eval(&block)
-      diff = @buffer[cache_pos..-1]
-      Rubyoshka.cache[key] = diff
-    end
-  end
-
-  attr_reader :block
+  attr_reader :template
 
   # Initializes a Rubyoshka with the given block
   # @param ctx [Hash] local context
   # @param block [Proc] nested HTML block
   # @param [void]
-  def initialize(**ctx, &block)
-    @block = ctx.empty? ? block : proc { with(ctx, &block) }
+  def initialize(mode: :html, **ctx, &block)
+    @mode = mode
+    @template = ctx.empty? ? block : proc { with(**ctx, &block) }
   end
 
   H_EMPTY = {}.freeze
@@ -210,8 +33,31 @@ class Rubyoshka
   # Renders the associated block and returns the string result
   # @param context [Hash] context
   # @return [String]
-  def render(context = H_EMPTY)
-    Rendering.new(context, &block).to_s
+  def render(context = H_EMPTY, &block)
+    if block
+      context = context.dup if context.frozen?
+      context[:__block__] = block
+    end
+    renderer_class.new(context, @template).to_s
+  end
+
+  def renderer_class
+    case @mode
+    when :html
+      HTMLRenderer
+    when :xml
+      XMLRenderer
+    else
+      raise "Invalid mode #{@mode.inspect}"
+    end
+  end
+
+  def compile
+    Rubyoshka::Compiler.new.compile(self)
+  end
+
+  def to_proc
+    @template
   end
 
   @@cache = {}
@@ -219,14 +65,29 @@ class Rubyoshka
   def self.cache
     @@cache
   end
+
+  def self.component(&block)
+    proc { |*args| new { instance_exec(*args, &block) } }
+  end
+
+  def self.xml(**ctx, &block)
+    new(mode: :xml, **ctx, &block)
+  end
 end
+::H = Rubyoshka
 
+# Kernel extensions
 module ::Kernel
   # Convenience method for creating a new Rubyoshka
   # @param ctx [Hash] local context
-  # @param block [Proc] nested block
+  # @param template [Proc] template block
   # @return [Rubyoshka] Rubyoshka template
-  def H(**ctx, &block)
-    Rubyoshka.new(ctx, &block)
+  def H(**ctx, &template)
+    Rubyoshka.new(**ctx, &template)
   end
-end
+end
+
+# Object extensions
+class Object
+  include Rubyoshka::Encoding
+end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rubyoshka
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.7'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-05 00:00:00.000000000 Z
+date: 2021-09-29 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: modulation
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: '0.18'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: escape_utils
   requirement: !ruby/object:Gem::Requirement
@@ -104,6 +90,9 @@ files:
 - CHANGELOG.md
 - README.md
 - lib/rubyoshka.rb
+- lib/rubyoshka/compiler.rb
+- lib/rubyoshka/html.rb
+- lib/rubyoshka/renderer.rb
 - lib/rubyoshka/version.rb
 homepage: http://github.com/digital-fabric/rubyoshka
 licenses:
@@ -122,14 +111,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: 'Rubyoshka: composable HTML templating for Ruby'