rubyoshka 0.1 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcac0e7abbbb0bad4f11b3c3b500ed7c14f506d06c6aa8ecbcec4cfc3503ce16
-  data.tar.gz: 8fd105613444edd272644aff2cb054b4c0a540789f5e63f41a4d9c033fc36577
+  metadata.gz: ba3dd09fc4ab56c9af5a69c47d9da50949180b0c636c788ed74660bbc04b4b5d
+  data.tar.gz: faf523787f5ff11bb3e0d5346ad684b8e3c22c8fdf522e30ff0f43ff4da40a74
 SHA512:
-  metadata.gz: 4f693a62532ae3235383068ed789cc144fd38ec7723c5ff728ace5b0a5b0ae267e61fc3e8140ac8972420a8c35fa0731b543dbd84016bda049843038ae5bafa4
-  data.tar.gz: 3ca48bcd081c077635cffa99d36823e2f19c1ac832a26426ae510e233d1054880a0e74b3047aeef389dcb88b4905a95339e90145cd131efcd2a8edba23599dea
+  metadata.gz: e10f0611cc2596ac27dd3f93df91db2d77e6ba12bc3159cdb3f29ab1b6abd3caedc66161e14a18b776cba72164a7dad725c1d60e8b4a09bcc39f96a34fb1790f
+  data.tar.gz: ad0b35a97f0d76fa7c82fd456751004f75af759b9d98efc824f3ae99d6fdb5d3a6905aecbb083dc5f44d272cd828c6728e27330ceab5355f1d25c24a7090f3fc

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+0.6 2021-03-03
+--------------
+
+* Fix Rubyoshka on Ruby 3.0
+* Refactor and add more tests
+
+0.5 2021-02-27
+--------------
+
+* 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
 --------------
 

data/README.md

@@ -2,7 +2,8 @@
 
 [INSTALL](#installing-rubyoshka) |
 [TUTORIAL](#getting-started) |
-[EXAMPLES](examples)
+[EXAMPLES](examples) |
+[REFERENCE](#api-reference)
 
 ## What is Rubyoshka
 
@@ -11,19 +12,34 @@ features:
 
 - HTML templating using plain Ruby syntax
 - Minimal boilerplate
+- Mix logic and tags freely
+- Use global and local contexts to pass values to reusable components
 - Automatic HTML escaping
 - Composable nested components
-- Access to a global context from anywhere in the component hierarchy
-- High performance
+- Template caching from fragments to whole templates
+
+> **Note** Rubyoshka is a new library and as such may be missing features and
+> contain bugs. Also, its API may change unexpectedly. Your issue reports and
+> code contributions are most welcome!
 
 With Rubyoshka you can structure your templates like a Russian doll, each
-component containing any number of nested components, in a similar fashion to
-React. The name *Rubyoshka* is a nod to Matryoshka, the Russian nesting doll.
+component containing any number of nested components, in a somewhat similar
+fashion to React. The name *Rubyoshka* is a nod to 
+[Matryoshka](https://en.wikipedia.org/wiki/Matryoshka_doll), the Russian
+nesting doll.
 
 ## Installing Rubyoshka
 
+Using bundler:
+
+```ruby
+gem 'rubyoshka'
+```
+
+Or manually:
+
 ```bash
-$ gem install polyphony
+$ gem install rubyoshka
 ```
 
 ## Getting started
@@ -49,7 +65,9 @@ html = H {
 }
 ```
 
-To render the template use `render`:
+## Rendering a template
+
+To render a Rubyoshka template use the `#render` method:
 
 ```ruby
 H { span 'best span' }.render  #=> "<span>best span</span>"
@@ -102,15 +120,123 @@ H { img src: '/my.gif' }.render #=> "<img src="/my.gif"/>
 H { p "foobar", class: 'important' }.render #=> "<p class=\"important\">foobar</p>"
 ```
 
+## Logic in templates
+
+Since Rubyoshka templates are just a bunch of Ruby, you can easily write your
+view logic right in the template:
+
+```ruby
+def user_message(user)
+  H {
+    if user
+      span "Hello, #{user.name}!"
+    else
+      span "Hello, guest!"
+    end
+  }
+end
+```
+
+## Local context
+
+When writing logic and referring to application values in you templates, there
+are some ground rules to obey. Since the template code is evaluated using
+`#instance_eval` that means that you will not be able to directly use instance
+variables or do unqualified method calls (calls to `self`).
+
+In order to facilitate exposing values to your template logic, Rubyoshka
+provides an API for setting a local context. The local context is simply a set
+of values that are accessible for a given block of code, and to any nested
+blocks within it. The local context is primarily set using the `#with` method:
+
+```ruby
+H {
+  with(name: 'world') {
+    div {
+      span "Hello, #{name}"
+    }
+  }
+}
+```
+
+The local context can alternatively be set by passing hash values to `#H`:
+
+```ruby
+H(name: 'world') {
+  div { span "Hello, #{name}" }
+}
+```
+
+A local context can also be set for a component (see the next section) simply by
+passing arguments to the component call:
+
+```ruby
+Greeting = H { span "Hello, #{name}" }
+
+H {
+  div {
+    Greeting(name: 'world')
+  }
+}
+```
+
+### Tip: accessing `self` and instance variables from a template
+
+In order to be able to access the object in the context of which the template is
+defined or any of its methods, you can pass it in the local context:
+
+```ruby
+class User
+  ...
+  def greeting_template
+    H(user: self) {
+      ...
+      span "Hello, #{user.name}"
+      span "your email: #{user.email}"
+    }
+  end
+end
+```
+
+Instance variables can be passed to the template in a similar fashion:
+
+```ruby
+H(name: @name) { span "Hello, #{name}" }
+```
+
+## Global context
+
+In addition to the local context, Rubyoshka also provides a way to set a global
+context, accessible from anywhere in the template, and also in sub-components 
+used in the template.
+
+The global context is a simple hash that can be accessed from within the
+template with the `#context` method:
+
+```ruby
+greeting = H { span "Hello, #{context[:name]}" }
+```
+
+The global context can be set upon rendering the template:
+
+```ruby
+greeting.render(name: 'world')
+```
+
 ## Templates as components
 
-Rubyoshka makes it easy to compose multiple 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:
+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 can be defined as either a Rubyoshka
+instance (using `#H`), a `proc` that returns a Rubyoshka instance, or using
+`Rubyoshka.component`:
 
 ```ruby
-# Item is actually a Proc that returns a template
+# Simple component relying on global/local context
+Title = H { h1 title }
+
+# Proc component that returns a template
+# Notice how the lambda expression takes keyword arguments
 Item = ->(id:, text:, checked:) {
   H {
     li {
@@ -120,37 +246,114 @@ 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
 ```
 
-## Wrapping arbitrary HTML
+Note that a component is invoked as a method, which means that if no arguments
+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
+non-constant components by invoking the `#emit` method:
+
+```ruby
+greeting = H { span "Hello, world" }
+
+H {
+  div {
+    emit greeting
+  }
+}
+```
+
+## Fragment caching
+
+Any part of a Rubyoshka template can be cached - a fragment, a component, or a
+whole template. It is up to you, the user, to determine which parts of the 
+template to cache. By default, a call to `#cache` creates a cache entry based on
+the source location of the cached block:
+
+```ruby
+Head = H {
+  cache {
+    head {
+      title 'My app'
+      style "@import '/app.css';"
+    }
+  }
+}
+```
+
+However, if your template references local or global variables, you'll want to
+take those into account when caching. This is done by passing any variables used
+in the template to `#cache` in order to create separate cache entries for each
+discrete value or combination of values:
+
+```ruby
+Greeting = H {
+  cache(name) {
+    div {
+      span "Hello, #{name}"
+    }
+  }
+}
+
+names = %w{tommy dolly world}
+App = H {
+  names.each { |n| Greeting(name: n) }
+}
+```
+
+In the above example a separate cache entry will be created for each name. The 
+use of caching in components is especially beneficial since components may be 
+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` method (see API
+[reference](#rubyoshkacache)).
 
-Components can be used to wrap arbitrary HTML content by defining them as procs
-that accept blocks:
+## Wrapping arbitrary HTML with a component
+
+Components can also be used to wrap arbitrary HTML with addional markup. This is
+done by implementing the component as a `proc` that takes a block:
 
 ```ruby
 Header = ->(&inner_html) {
   header {
-    h1 'title'
+    h1 'This is a title'
     emit inner_html
   }
 }
 
-H { Header { button 'OK'} }.render #=> "<header><h1>title</h1><button>OK</button></header>"
+Greeting = H { span "Hello, #{name}" }
+
+H { Header { Greeting(name: 'world') }.render #=> "<header><h1>This is a title</h1><span>Hello, world</span></header>"
 ```
 
 ## Some interesting use cases
 
 Rubyoshka opens up all kinds of new possibilities when it comes to putting
-together pieces of HTML. Feel free to explore the possibilities!
+together pieces of HTML. Feel free to explore the API!
 
 ### Routing in the view
 
@@ -163,12 +366,7 @@ Router = ->(path) {
   when '/'
     PostIndex()
   when /^posts\/(.+)$/
-    post = get_post($1)
-    if post
-      Post(post)
-    else
-      ErrorPage(404)
-    end
+    Post(get_post($1))
   end
 }
 
@@ -184,4 +382,166 @@ Blog = H {
     }
   }
 }
+```
+
+### A general purpose router
+
+A more flexible, reusable approach could be achieved by implementing a
+higher-order routing component, in a similar fashion to
+[React Router](https://reacttraining.com/react-router/web/guides/quick-start):
+
+```ruby
+Route = ->(path, &block) {
+  match = path.is_a?(Regexp) ?
+    context[:path] =~ path : context[:path] == /^#{path}/
+  emit block if match
+}
+
+Blog = H {
+  html {
+    head {
+      title: 'My blog'
+    }
+    body {
+      Topbar()
+      Sidebar()
+      div id: 'content' {
+        Route '/'             { PostIndex() }
+        Route /^posts\/(.+)$/ { Post(get_post($1)) }
+      }
+    }
+  }
+}
+```
+
+### A higher-order list component
+
+Here's another demonstration of a higher-order component, a list component that
+takes an item component as an argument. The `List` component can be reused for
+rendering any kind of unordered list, and with any kind of item component:
+
+```ruby
+List = ->(items, item_component) {
+  H {
+    ul {
+      items.each { |item|
+        with(item: item) { 
+          li { emit item_component }
+        }
+      }
+    }
+  }
+}
+
+TodoItem = H {
+  span item.text, class: item.completed ? 'completed' : 'pending'
+}
+
+def todo_list(items)
+  H {
+    div { List(items, TodoItem) }
+  }
+end
+```
+
+## API Reference
+
+#### `Rubyoshka#initialize(**context, &block)` a.k.a. `Kernel#H`
+
+- `context`: local context hash
+- `block`: template block
+
+Initializes a new Rubyoshka instance. This method takes a block of template 
+code, and an optional [local context](#local-context) in the form of a hash.
+The `Kernel#H` method serves as a shortcut for creating Rubyoshka instances.
+
+#### `Rubyoshka#render(**context)`
+
+- `context`: global context hash
+
+Renders the template with an optional [global context](#global-context)
+hash.
+
+#### Methods accessible inside template blocks
+
+#### `#<tag/component>(*args, **props, &block)`
+
+- `args`: tag arguments. For an HTML tag Rubyoshka expects a single `String`
+  argument containing the inner text of the tag.
+- `props`: hash of tag attributes
+- `block`: inner HTML block
+
+Adds a tag or component to the current template. If the method name starts with
+an upper-case letter, it is considered a [component](#templates-as-components).
+
+If a text argument is given for a tag, it will be escaped.
+
+#### `#cache(*vary, &block)`
+
+- `vary`: variables used in cached block. The given values will be used to
+  create a separate cache entry.
+- `block`: inner HTML block
+
+Caches the markup in the given block, storing it in the Rubyoshka cache store.
+If a cache entry for the given block is found, it will be used instead of
+invoking the block. If one or more variables given, those will be used to create
+a separate cache entry.
+
+#### `#context`
+
+Accesses the [global context](#global-context).
+
+#### `#emit(object)` a.k.a. `#e(object)`
+
+- `object`: `Proc`, `Rubyoshka` instance or `String`
+
+Adds the given object to the current template. If a `String` is given, it is
+rendered verbatim, i.e. without escaping.
+
+#### `html5(&block)`
+
+- `block`: inner HTML block
+
+Adds an HTML5 `doctype` tag, followed by an `html` tag with the given block.
+
+#### `#text(data)`
+
+- `data` - text to add
+
+Adds text without wrapping it in a tag. The text will be escaped.
+
+#### `#with(**context, &block)`
+
+- `context`: local context hash
+- `block`: HTML block
+
+Sets a [local context](#local-context) for use inside the given block. The
+previous local context will be restored upon exiting the given block.
+
+#### `Rubyoshka.cache`
+
+Returns the cache store. A cache store should implement two methods - `#[]` and
+`#[]=`. Here's an example implementing a Redis-based cache store:
+
+```ruby
+class RedisTemplateCache
+  def initialize(conn, prefix)
+    @conn = conn
+    @prefix = prefix
+  end
+
+  def [](key)
+    @conn.get("#{prefix}:#{key}")
+  end
+
+  def []=(key, value)
+    @conn.set("#{prefix}:#{key}", value)
+  end
+end
+
+TEMPLATE_CACHE = RedisTemplaceCache.new(redis_conn, "templates:cache")
+
+def Rubyoshka.cache
+  TEMPLATE_CACHE
+end
 ```

data/lib/rubyoshka.rb

@@ -1,189 +1,64 @@
 # frozen_string_literal: true
 
-require 'modulation/gem'
 require 'escape_utils'
 
-export_default :Rubyoshka
+require_relative 'rubyoshka/renderer'
 
 # 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
-  
-    S_TAG_METHOD = <<~EOF
-      def %1$s(*args, &block)
-        tag(:%1$s, *args, &block)
-      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)
-      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) { emit o }
-          emit(o)
-        when ::String
-          @buffer << o
-        else
-          e = StandardError.new "Cannot render #{o.inspect}"
-          e.set_backtrace(caller)
-          raise e
-        end
-      else
-        self.class.class_eval(S_TAG_METHOD % sym)
-        tag(sym, *args, &block)
-      end
-    end
-  
-    # Emits the given object into the rendering buffer
-    # @param o [Proc, Rubyoshka, String] emitted object
-    # @return [void]
-    def emit(o)
-      case o
-      when ::Proc
-        instance_eval(&o)
-      when Rubyoshka
-        instance_eval(&o.block)
-      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           = '"'
-
-    E = EscapeUtils
-  
-    # Emits an HTML tag
-    # @param sym [Symbol] HTML tag
-    # @param text [String] text content of tag
-    # @param props [Hash] tag attributes
-    # @param block [Proc] nested HTML block
-    # @return [void]
-    def tag(sym, text = nil, **props, &block)
-      sym = sym.to_s
-  
-      @buffer << S_LT << sym
-      emit_props(props) unless props.empty?
-  
-      if block
-        @buffer << S_GT
-        instance_eval(&block)
-        @buffer << S_LT_SLASH << sym << S_GT
-      elsif Rubyoshka === text
-        @buffer << S_GT
-        emit(text)
-        @buffer << S_LT_SLASH << sym << S_GT
-      elsif text
-        @buffer << S_GT << E.escape_html(text.to_s) <<
-          S_LT_SLASH << sym << S_GT
-      else
-        @buffer << S_SLASH_GT
-      end
-    end
-
-    # 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 :text
-        when :src, :href
-          @buffer << S_SPACE << k.to_s << S_EQUAL_QUOTE <<
-            E.escape_uri(v) << S_QUOTE
-        else
-          if v == true
-            @buffer << S_SPACE << k.to_s
-          else
-            @buffer << S_SPACE << k.to_s << S_EQUAL_QUOTE << v << S_QUOTE
-          end
-        end
-      }
-    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)
-      tag(: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
-
-    # Emits text into the rendering buffer
-    # @param data [String] text
-    def text(data)
-      @buffer << E.escape_html(text)
-    end
-  end
-
   attr_reader :block
 
   # Initializes a Rubyoshka with the given block
+  # @param ctx [Hash] local context
   # @param block [Proc] nested HTML block
   # @param [void]
-  def initialize(&block)
-    @block = block
+  def initialize(mode: :html, **ctx, &block)
+    @mode = mode
+    @block = ctx.empty? ? block : proc { with(**ctx, &block) }
   end
 
+  H_EMPTY = {}.freeze
+
   # Renders the associated block and returns the string result
   # @param context [Hash] context
   # @return [String]
-  def render(context = {})
-    Rendering.new(context, &block).to_s
+  def render(context = H_EMPTY)
+    renderer_class.new(context, &block).to_s
+  end
+
+  def renderer_class
+    case @mode
+    when :html
+      HTMLRenderer
+    when :xml
+      XMLRenderer
+    else
+      raise "Invalid mode #{@mode.inspect}"
+    end
+  end
+
+  @@cache = {}
+
+  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
 
 module ::Kernel
   # Convenience method for creating a new Rubyoshka
-  def H(&block)
-    Rubyoshka.new(&block)
+  # @param ctx [Hash] local context
+  # @param block [Proc] nested block
+  # @return [Rubyoshka] Rubyoshka template
+  def H(**ctx, &block)
+    Rubyoshka.new(**ctx, &block)
   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,197 @@
+# 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, &block)
+      @context = context
+      @buffer = +''
+      instance_eval(&block)
+    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.block)
+      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
+  
+    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.1'
+  VERSION = '0.6'
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rubyoshka
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.6'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-06 00:00:00.000000000 Z
+date: 2021-03-03 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
@@ -80,6 +66,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.7.0
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.9
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.9
 description: 
 email: ciconia@gmail.com
 executables: []
@@ -90,6 +90,8 @@ files:
 - CHANGELOG.md
 - README.md
 - lib/rubyoshka.rb
+- lib/rubyoshka/html.rb
+- lib/rubyoshka/renderer.rb
 - lib/rubyoshka/version.rb
 homepage: http://github.com/digital-fabric/rubyoshka
 licenses:
@@ -115,8 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: 'Rubyoshka: composable HTML templating for Ruby'