rubyoshka 0.2 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff842a3a48141bcef19e1298cb26ff59cd9dbb0a58075efe50b3f73892a75c2f
-  data.tar.gz: 4556f2fc468d48d9a98b4582ab25f0068d814d933e0e0c198d45fce9f692960b
+  metadata.gz: ae561e0250334107b9b82a72fc72ab672622a7f037044e8e18154e79b71a54b5
+  data.tar.gz: e5cddea7df6231799b38339bc014373a6c9d6a96bb60d3c7b7107e48321b3c6d
 SHA512:
-  metadata.gz: 79e2fd4e9f970201191e576f1b4bd971bef99cd1a7fbcbaee2102d6be8b8e0ec59e6ad0d26f6770ba756bd2e7b92ab84128a6bded62219417af94e1f9dbce159
-  data.tar.gz: 9d78ee6402ddc3e873d7b47073c655cb6501c46f91e8f4f6bb2041581367ee7cc5c661cc63e6f356e17a8d9cab59f9cf719e4497166f3fa890b4b320c62473c0
+  metadata.gz: 675b83551aa791f6bb1539c80c40d267e3caa1aceed3748af04ca1d2a49bcac3ad237a8d8c0f0dd69d24714eadbb47bf4a929af77c3ef2c71155e806ff611c66
+  data.tar.gz: 7dd19daa9df716417c894130ff8fdae0505f83a63de17709634b2c7c83384f56453c13adbee109e4961f44a64f1c46e151752d1fc5bf690ad6738402b023f9bf

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+0.6.1 2021-03-03
+----------------
+
+* Remove support for Ruby 2.6
+
+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
 --------------
 

data/README.md

@@ -3,7 +3,7 @@
 [INSTALL](#installing-rubyoshka) |
 [TUTORIAL](#getting-started) |
 [EXAMPLES](examples) |
-[REFERENCE](reference)
+[REFERENCE](#api-reference)
 
 ## What is Rubyoshka
 
@@ -16,21 +16,30 @@ features:
 - 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
-- About 4 times faster than ERubis (see [benchmark](examples/perf.rb)).
+- Template caching from fragments to whole templates
 
 > **Note** Rubyoshka is a new library and as such may be missing features and
-> contain bugs. Your issue reports and code conributions are most welcome!
+> 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 somewhat similar
-fashion to React. The name *Rubyoshka* is a nod to Matryoshka, the Russian
+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
@@ -217,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 {
@@ -236,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
@@ -265,6 +284,54 @@ H {
 }
 ```
 
+## 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)).
+
 ## Wrapping arbitrary HTML with a component
 
 Components can also be used to wrap arbitrary HTML with addional markup. This is
@@ -347,7 +414,37 @@ Blog = H {
 }
 ```
 
-## Reference
+### 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`
 
@@ -379,6 +476,17 @@ 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).
@@ -409,3 +517,31 @@ Adds text without wrapping it in a tag. The text will be escaped.
 
 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,204 +1,57 @@
 # 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)
-      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
-        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)
-      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           = '"'
-
-    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(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
-  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(**ctx, &block)
-    @block = ctx.empty? ? block : proc { with(ctx, &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
@@ -206,6 +59,6 @@ module ::Kernel
   # @param block [Proc] nested block
   # @return [Rubyoshka] Rubyoshka template
   def H(**ctx, &block)
-    Rubyoshka.new(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,198 @@
+# 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)) }
+          STDOUT.puts({o: o, args: args, opts: opts, block: block}.inspect)
+          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.2'
+  VERSION = '0.6.1'
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rubyoshka
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: 0.6.1
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-07 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:
@@ -108,14 +110,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'