deas-erubis 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.log
+*.rbc
+.rbx/
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'rake'
+gem 'pry', "~> 0.9.0"
+
+platform :rbx do
+  gem 'rubysl'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014-Present Kelly Redding and Collin Redding
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Deas::Erubis
+
+[Deas](https://github.com/redding/deas) template engine for rendering [Erubis](http://www.kuwata-lab.com/erubis/) templates
+
+## Usage
+
+TODO: Write code samples and usage instructions here
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'deas-erubis'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install deas-erubis
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/deas-erubis.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "deas-erubis/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "deas-erubis"
+  gem.version     = Deas::Erubis::VERSION
+  gem.authors     = ["Kelly Redding", "Collin Redding"]
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
+  gem.description = %q{Deas template engine for rendering erb templates using Erubis}
+  gem.summary     = %q{Deas template engine for rendering erb templates using Erubis}
+  gem.homepage    = "http://github.com/redding/deas-erubis"
+  gem.license     = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency("assert", ["~> 2.12"])
+
+  gem.add_dependency("deas", ["~> 0.29"])
+  gem.add_dependency("erubis")
+
+end

data/lib/deas-erubis/source.rb

@@ -0,0 +1,134 @@
+require 'pathname'
+require 'erubis'
+require 'deas-erubis/template_helpers'
+
+module Deas; end
+module Deas::Erubis
+
+  class Source
+
+    EXT           = '.erb'.freeze
+    CACHE_EXT     = '.cache'.freeze
+    BUFVAR_NAME   = '@_erb_buf'.freeze
+    DEFAULT_ERUBY = ::Erubis::Eruby
+
+    attr_reader :root, :cache_root, :eruby_class, :context_class
+
+    def initialize(root, opts)
+      @root        = Pathname.new(root.to_s)
+      @eruby_class = opts[:eruby] || DEFAULT_ERUBY
+
+      should_cache = !!opts[:cache]
+      @cache_root  = opts[:cache] == true ? @root : Pathname.new(opts[:cache].to_s)
+      @cache_root.mkpath if should_cache && !@cache_root.exist?
+
+      if should_cache
+        # use `load_file` to lookup and cache templates (faster renders)
+        if @cache_root == @root
+          # use the `load_file` default and don't bother with looking up, setting,
+          # and making sure the cache file path exists - by default `load_file`
+          # caches alongside the source with the `CACHE_EXT` appended.
+          add_meta_eruby_method do |file_name|
+            @eruby_class.load_file(source_file_path(file_name), {
+              :bufvar => BUFVAR_NAME
+            })
+          end
+        else
+          # lookup and ensure the custom cache location exists (more expensive)
+          add_meta_eruby_method do |file_name|
+            @eruby_class.load_file(source_file_path(file_name), {
+              :bufvar    => BUFVAR_NAME,
+              :cachename => cache_file_path(file_name)
+            })
+          end
+        end
+      else
+        # don't cache template files (slower renders, but no cache files created)
+        add_meta_eruby_method do |file_name|
+          filename = source_file_path(file_name).to_s
+          template = File.send(File.respond_to?(:binread) ? :binread : :read, filename)
+          @eruby_class.new(template, {
+            :bufvar   => BUFVAR_NAME,
+            :filename => filename
+          })
+        end
+      end
+
+      @deas_source   = opts[:deas_source]
+      @context_class = build_context_class(opts)
+    end
+
+    def eruby(file_name)
+      # should be overridden by a metaclass equivalent on init
+      # the implementation changes whether you are caching templates or not
+      # and the goal here is to not add a bunch of conditional overhead as this
+      # will be called on every render
+      raise NotImplementedError
+    end
+
+    def render(file_name, locals, &content)
+      eruby(file_name).evaluate(@context_class.new(@deas_source, locals), &content)
+    end
+
+    def compile(file_name, content)
+      @eruby_class.new(content, {
+        :bufvar   => BUFVAR_NAME,
+        :filename => file_name
+      }).evaluate(@context_class.new(@deas_source, {}))
+    end
+
+    def inspect
+      "#<#{self.class}:#{'0x0%x' % (object_id << 1)}"\
+      " @root=#{@root.inspect}"\
+      " @eruby=#{@eruby_class.inspect}>"
+    end
+
+    private
+
+    def source_file_path(file_name)
+      self.root.join("#{file_name}#{EXT}").to_s
+    end
+
+    def cache_file_path(file_name)
+      self.cache_root.join("#{file_name}#{EXT}#{CACHE_EXT}").tap do |path|
+        path.dirname.mkpath if !path.dirname.exist?
+      end.to_s
+    end
+
+    def add_meta_eruby_method(&method)
+      metaclass = class << self; self; end
+      metaclass.class_eval do
+        define_method(:eruby, &method)
+      end
+    end
+
+    def build_context_class(opts)
+      Class.new do
+        include ::Deas::Erubis::TemplateHelpers
+        # TODO: mixin context helpers? `opts[:template_helpers]`
+        (opts[:default_locals] || {}).each{ |k, v| define_method(k){ v } }
+
+        def initialize(deas_source, locals)
+          @deas_source = deas_source
+
+          metaclass = class << self; self; end
+          metaclass.class_eval do
+            locals.each do |key, value|
+              define_method(key){ value }
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+  class DefaultSource < Source
+
+    def initialize
+      super('/', {})
+    end
+
+  end
+
+end

data/lib/deas-erubis/template_helpers.rb

@@ -0,0 +1,58 @@
+require 'deas-erubis/source'
+
+module Deas; end
+module Deas::Erubis
+
+  module TemplateHelpers
+
+    def self.included(receiver)
+      receiver.class_eval{ include Methods }
+    end
+
+    module Methods
+
+      def partial(*args)
+        @deas_source.partial(*args)
+      end
+
+      def capture_partial(*args, &content)
+        _erb_buffer @deas_source.partial(*args, &Proc.new{ _erb_capture(&content) })
+      end
+
+      private
+
+      def _erb_capture(&content)
+        begin
+          # copy original buffer state
+          orig_buf_value = _erb_bufvar
+          instance_variable_set(_erb_bufvar_name, "\n")
+
+          # evaluate the given content
+          result = instance_eval(&content)
+          new_buf_value = _erb_bufvar
+
+          # return result if nothing buffered; otherwise return what was buffered
+          new_buf_value == "\n" ? "\n#{result}" : new_buf_value
+        ensure
+          # reset buffer to original state
+          instance_variable_set(_erb_bufvar_name, orig_buf_value)
+        end
+      end
+
+      def _erb_buffer(content)
+        _erb_bufvar << content
+      end
+
+      def _erb_bufvar
+        instance_variable_get(_erb_bufvar_name)
+      end
+
+      def _erb_bufvar_name
+        Deas::Erubis::Source::BUFVAR_NAME
+      end
+
+    end
+
+  end
+
+end

data/lib/deas-erubis/version.rb

@@ -0,0 +1,4 @@
+module Deas; end
+module Deas::Erubis
+  VERSION = "0.1.0"
+end

data/lib/deas-erubis.rb

@@ -0,0 +1,53 @@
+require 'deas/template_engine'
+require 'erubis'
+
+require 'deas-erubis/version'
+require 'deas-erubis/source'
+
+module Deas::Erubis
+
+  class TemplateEngine < Deas::TemplateEngine
+
+    DEFAULT_HANDLER_LOCAL = 'view'.freeze
+    DEFAULT_LOGGER_LOCAL  = 'logger'.freeze
+
+    def erb_source
+      @erb_source ||= Source.new(self.source_path, {
+        :eruby          => self.opts['eruby'],
+        :cache          => self.opts['cache'],
+        :deas_source    => self.opts['deas_template_source'],
+        :default_locals => { self.erb_logger_local => self.logger }
+      })
+    end
+
+    def erb_handler_local
+      @erb_handler_local ||= (self.opts['handler_local'] || DEFAULT_HANDLER_LOCAL)
+    end
+
+    def erb_logger_local
+      @erb_logger_local ||= (self.opts['logger_local'] || DEFAULT_LOGGER_LOCAL)
+    end
+
+    # render the template including the handler as a local
+    def render(template_name, view_handler, locals, &content)
+      self.erb_source.render(template_name, render_locals(view_handler, locals), &content)
+    end
+
+    # render the template against the given locals
+    def partial(template_name, locals, &content)
+      self.erb_source.render(template_name, locals, &content)
+    end
+
+    def compile(template_name, compiled_content)
+      self.erb_source.compile(template_name, compiled_content)
+    end
+
+    private
+
+    def render_locals(view_handler, locals)
+      { self.erb_handler_local => view_handler }.merge(locals)
+    end
+
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+# this file is automatically required when you run `assert`
+# put any test helpers here
+
+require 'pathname'
+
+# add the root dir to the load path
+ROOT = Pathname.new(File.expand_path("../..", __FILE__))
+$LOAD_PATH.unshift(ROOT.to_s)
+
+TEST_SUPPORT_PATH = ROOT.join('test/support')
+TEMPLATE_ROOT = TEST_SUPPORT_PATH.join('templates')
+TEMPLATE_CACHE_ROOT = ROOT.join('tmp/templates')
+
+# require pry for debugging (`binding.pry`)
+require 'pry'
+
+require 'test/support/factory'

data/test/support/factory.rb

@@ -0,0 +1,84 @@
+require 'assert/factory'
+
+module Factory
+  extend Assert::Factory
+
+  def self.template_root
+    TEMPLATE_ROOT.to_s
+  end
+
+  def self.template_file(name)
+    TEMPLATE_ROOT.join(name).to_s
+  end
+
+  def self.basic_erb_rendered(locals)
+    "<h1>name: #{locals['name']}</h1>\n"\
+    "<h2>local1: #{locals['local1']}</h2>\n"
+  end
+
+  def self.yield_erb_rendered(locals, &content)
+    "<h1>name: #{locals['name']}</h1>\n"\
+    "<h2>local1: #{locals['local1']}</h2>\n"\
+    "<div>\n"\
+    "  #{content.call}\n"\
+    "</div>\n"
+  end
+
+  def self.view_erb_rendered(engine, view_handler, locals)
+    "<h1>name: #{view_handler.name}</h1>\n"\
+    "<h2>local1: #{locals['local1']}</h2>\n"\
+    "<p>id: #{view_handler.identifier}</p>\n"\
+    "<p>logger: #{engine.logger.to_s}</p>\n"
+  end
+
+  def self.yield_view_erb_rendered(engine, view_handler, locals, &content)
+    "<h1>name: #{view_handler.name}</h1>\n"\
+    "<h2>local1: #{locals['local1']}</h2>\n"\
+    "<p>id: #{view_handler.identifier}</p>\n"\
+    "<p>logger: #{engine.logger.to_s}</p>\n"\
+    "<div>\n"\
+    "  #{content.call}\n"\
+    "</div>\n"
+  end
+
+  def self.partial_erb_rendered(engine, locals)
+    "<h1>local1: #{locals['local1']}</h1>\n"\
+    "<p>logger: #{engine.logger.to_s}</p>\n"
+  end
+
+  def self.yield_partial_erb_rendered(engine, locals, &content)
+    "<h1>local1: #{locals['local1']}</h1>\n"\
+    "<p>logger: #{engine.logger.to_s}</p>\n"\
+    "<div>\n"\
+    "  #{content.call}\n"\
+    "</div>\n"
+  end
+
+  def self.partial_with_partial_erb_rendered(engine, locals)
+    "<div>\n"\
+    "  <h1>local1: #{locals['local1']}</h1>\n"\
+    "<p>logger: #{engine.logger.to_s}</p>\n\n"\
+    "</div>\n"
+  end
+
+  def self.partial_with_capture_partial_erb_rendered(engine, locals)
+    "<div>\n"\
+    "<h1>local1: #{locals['local1']}</h1>\n"\
+    "<p>logger: #{engine.logger.to_s}</p>\n"\
+    "<div>\n"\
+    "  \n"\
+    "    <span>some content</span>\n"\
+    "\n"\
+    "</div>\n"\
+    "<h1>local1: #{locals['local1']}</h1>\n"\
+    "<p>logger: #{engine.logger.to_s}</p>\n"\
+    "</div>\n"
+  end
+
+  def self.compile_erb_rendered(engine)
+    "<h1>compile</h1>\n"\
+    "<p>2</p>\n"\
+    "<p>logger: #{engine.logger.to_s}</p>\n"
+  end
+
+end

data/test/support/templates/_partial.erb

@@ -0,0 +1,2 @@
+<h1>local1: <%= local1 %></h1>
+<p>logger: <%= logger %></p>

data/test/support/templates/_yield_partial.erb

@@ -0,0 +1,5 @@
+<h1>local1: <%= local1 %></h1>
+<p>logger: <%= logger %></p>
+<div>
+  <%= yield %>
+</div>

data/test/support/templates/basic.erb

@@ -0,0 +1,2 @@
+<h1>name: <%= name %></h1>
+<h2>local1: <%= local1 %></h2>

data/test/support/templates/compile.erb

@@ -0,0 +1,3 @@
+<h1>compile</h1>
+<p><%= 1 + 1 %></p>
+<p>logger: <%= logger %></p>

data/test/support/templates/view.erb

@@ -0,0 +1,4 @@
+<h1>name: <%= view.name %></h1>
+<h2>local1: <%= local1 %></h2>
+<p>id: <%= view.identifier %></p>
+<p>logger: <%= logger %></p>

data/test/support/templates/with_capture_partial.erb

@@ -0,0 +1,6 @@
+<div>
+  <% capture_partial '_yield_partial', 'local1' => local1 do %>
+    <span>some content</span>
+  <% end %>
+  <% capture_partial '_partial', 'local1' => local1 %>
+</div>

data/test/support/templates/with_partial.erb

@@ -0,0 +1,3 @@
+<div>
+  <%= partial '_partial', 'local1' => local1 %>
+</div>

data/test/support/templates/yield.erb

@@ -0,0 +1,5 @@
+<h1>name: <%= name %></h1>
+<h2>local1: <%= local1 %></h2>
+<div>
+  <%= yield %>
+</div>

data/test/support/templates/yield_view.erb

@@ -0,0 +1,7 @@
+<h1>name: <%= view.name %></h1>
+<h2>local1: <%= local1 %></h2>
+<p>id: <%= view.identifier %></p>
+<p>logger: <%= logger %></p>
+<div>
+  <%= yield %>
+</div>

data/test/system/template_engine_tests.rb

@@ -0,0 +1,74 @@
+require 'assert'
+require 'deas-erubis'
+
+require 'deas/template_source'
+
+class Deas::Erubis::TemplateEngine
+
+  class SystemTests < Assert::Context
+    desc "Deas::Erubis::TemplateEngine"
+    setup do
+      @view = OpenStruct.new({
+        :identifier => Factory.integer,
+        :name => Factory.string
+      })
+      @locals = { 'local1' => Factory.string }
+      @content = Proc.new{ "<span>some content</span>" }
+
+      @engine = Deas::Erubis::TemplateEngine.new('source_path' => TEMPLATE_ROOT)
+    end
+    subject{ @engine }
+
+    should "render templates" do
+      exp = Factory.view_erb_rendered(subject, @view, @locals)
+      assert_equal exp, subject.render('view', @view, @locals)
+    end
+
+    should "render templates yielding to given content blocks" do
+      exp = Factory.yield_view_erb_rendered(subject, @view, @locals, &@content)
+      assert_equal exp, subject.render('yield_view', @view, @locals, &@content)
+    end
+
+    should "render partial templates" do
+      exp = Factory.partial_erb_rendered(subject, @locals)
+      assert_equal exp, subject.partial('_partial', @locals)
+    end
+
+    should "render partial templates yielding to given content blocks" do
+      exp = Factory.yield_partial_erb_rendered(subject, @locals, &@content)
+      assert_equal exp, subject.partial('_yield_partial', @locals, &@content)
+    end
+
+    should "compile raw template markup" do
+      file_name = 'compile'
+      file_path = TEMPLATE_ROOT.join("#{file_name}#{Deas::Erubis::Source::EXT}").to_s
+      file_content = File.read(file_path)
+
+      exp = Factory.compile_erb_rendered(subject)
+      assert_equal exp, subject.compile(file_name, file_content)
+    end
+
+  end
+
+  class TemplateHelperTests < SystemTests
+    desc "template helpers"
+    setup do
+      @deas_source = Deas::TemplateSource.new(TEMPLATE_ROOT).tap do |s|
+        s.engine 'erb', Deas::Erubis::TemplateEngine
+      end
+      @engine = @deas_source.engines['erb']
+    end
+
+    should "render partials" do
+      exp = Factory.partial_with_partial_erb_rendered(subject, @locals)
+      assert_equal exp, subject.partial('with_partial', @locals)
+    end
+
+    should "capture render partials" do
+      exp = Factory.partial_with_capture_partial_erb_rendered(subject, @locals).to_s
+      assert_equal exp, subject.partial('with_capture_partial', @locals)
+    end
+
+  end
+
+end

data/test/unit/source_tests.rb

@@ -0,0 +1,271 @@
+require 'assert'
+require 'deas-erubis/source'
+
+require 'erubis'
+
+class Deas::Erubis::Source
+
+  class UnitTests < Assert::Context
+    desc "Deas::Erubis::Source"
+    setup do
+      @source_class = Deas::Erubis::Source
+    end
+    subject{ @source_class }
+
+    should "know its extensions" do
+      assert_equal '.erb',   subject::EXT
+      assert_equal '.cache', subject::CACHE_EXT
+    end
+
+    should "know the bufvar name to use" do
+      assert_equal '@_erb_buf', subject::BUFVAR_NAME
+    end
+
+    should "know its default eruby class" do
+      assert_equal ::Erubis::Eruby, subject::DEFAULT_ERUBY
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @root = Factory.template_root
+      @source = @source_class.new(@root, {})
+    end
+    subject{ @source }
+
+    should have_readers :root, :cache_root, :eruby_class, :context_class
+    should have_imeths :eruby, :render, :compile
+
+    should "know its root" do
+      assert_equal @root, subject.root.to_s
+    end
+
+    should "default its eruby class" do
+      assert_equal Deas::Erubis::Source::DEFAULT_ERUBY, subject.eruby_class
+    end
+
+    should "optionally take a custom eruby class" do
+      eruby = 'some-eruby-class'
+      source = @source_class.new(@root, :eruby => eruby)
+      assert_equal eruby, source.eruby_class
+    end
+
+    should "build eruby instances for a given template file" do
+      assert_kind_of subject.eruby_class, subject.eruby('basic')
+    end
+
+    should "build its eruby instances with the correct bufvar name" do
+      exp = Deas::Erubis::Source::BUFVAR_NAME
+      assert_equal exp, subject.eruby('basic').instance_variable_get('@bufvar')
+    end
+
+    should "default its cache root" do
+      assert_equal Pathname.new('').to_s, subject.cache_root.to_s
+    end
+
+    should "use the root as its cache root if :cache opt is `true`" do
+      source = @source_class.new(@root, :cache => true)
+      assert_equal @root.to_s, source.cache_root.to_s
+    end
+
+    should "optionally use a custom cache root" do
+      source = @source_class.new(@root, :cache => TEMPLATE_CACHE_ROOT)
+      assert_equal TEMPLATE_CACHE_ROOT.to_s, source.cache_root.to_s
+    end
+
+    should "create the cache root if it doesn't exist already" do
+      FileUtils.rm_rf(TEMPLATE_CACHE_ROOT) if TEMPLATE_CACHE_ROOT.exist?
+      source = @source_class.new(@root, :cache => TEMPLATE_CACHE_ROOT)
+      assert_file_exists TEMPLATE_CACHE_ROOT.to_s
+    end
+
+    should "know its context class" do
+      assert_instance_of ::Class, subject.context_class
+    end
+
+    should "mixin template helpers to its context class" do
+      assert_includes Deas::Erubis::TemplateHelpers, subject.context_class
+
+      context = subject.context_class.new('deas-source', {})
+      assert_responds_to :partial, context
+      assert_responds_to :capture_partial, context
+    end
+
+    should "optionally take and apply default locals to its context class" do
+      local_name, local_val = [Factory.string, Factory.string]
+      source = @source_class.new(@root, {
+        :default_locals => { local_name => local_val }
+      })
+      context = source.context_class.new('deas-source', {})
+
+      assert_responds_to local_name, context
+      assert_equal local_val, context.send(local_name)
+    end
+
+    should "apply custom locals to its context class instances on init" do
+      local_name, local_val = [Factory.string, Factory.string]
+      context = subject.context_class.new('deas-source', local_name => local_val)
+
+      assert_responds_to local_name, context
+      assert_equal local_val, context.send(local_name)
+    end
+
+    should "set any deas source given to its context class as in ivar on init" do
+      deas_source = 'a-deas-source'
+      context = subject.context_class.new(deas_source, {})
+
+      assert_equal deas_source, context.instance_variable_get('@deas_source')
+    end
+
+  end
+
+  class RenderSetupTests < InitTests
+    setup do
+      @file_locals = {
+        'name'   => Factory.string,
+        'local1' => Factory.integer
+      }
+    end
+    teardown do
+      root = TEMPLATE_ROOT.join("*#{@source_class::CACHE_EXT}").to_s
+      Dir.glob(root).each{ |f| FileUtils.rm_f(f) }
+      root = TEMPLATE_CACHE_ROOT.join("*#{@source_class::CACHE_EXT}").to_s
+      Dir.glob(root).each{ |f| FileUtils.rm_f(f) }
+    end
+
+  end
+
+  class RenderTests < RenderSetupTests
+    desc "`render` method"
+    setup do
+      @file_name = "basic"
+    end
+
+    should "render a template for the given file name and return its data" do
+      exp = Factory.basic_erb_rendered(@file_locals)
+      assert_equal exp, subject.render(@file_name, @file_locals)
+    end
+
+    should "pass its deas source to its context class" do
+      deas_source = 'a-deas-source'
+      source = @source_class.new(@root, :deas_source => deas_source)
+      context_class = nil
+      Assert.stub(source.context_class, :new) do |s, l|
+        context_class = ContextClassSpy.new(s, l)
+      end
+      source.render(@file_name, @file_locals)
+
+      assert_equal deas_source, context_class.deas_source
+    end
+
+  end
+
+  class RenderEnabledCacheTests < RenderTests
+    desc "when caching is enabled"
+    setup do
+      @source = @source_class.new(@root, :cache => true)
+    end
+
+    should "cache templates in the root (cache root) alongside the source" do
+      f = "#{@file_name}#{@source_class::EXT}#{@source_class::CACHE_EXT}"
+      cache_file = subject.root.join(f)
+
+      assert_not_file_exists cache_file
+      subject.render(@file_name, @file_locals)
+      assert_file_exists cache_file
+    end
+
+  end
+
+  class RenderCustomCacheTests < RenderTests
+    desc "when caching is enabled on a custom cache root"
+    setup do
+      @source = @source_class.new(@root, :cache => TEMPLATE_CACHE_ROOT)
+    end
+
+    should "cache templates in the cache root" do
+      f = "#{@file_name}#{@source_class::EXT}#{@source_class::CACHE_EXT}"
+      cache_file = TEMPLATE_CACHE_ROOT.join(f)
+
+      assert_not_file_exists cache_file
+      subject.render(@file_name, @file_locals)
+      assert_file_exists cache_file
+    end
+
+  end
+
+  class RenderNoCacheTests < RenderTests
+    desc "when caching is disabled"
+    setup do
+      @source = @source_class.new(@root, :cache => false)
+    end
+
+    should "not cache templates" do
+      f = "#{@file_name}#{@source_class::EXT}#{@source_class::CACHE_EXT}"
+      cache_file = subject.root.join(f)
+
+      assert_not_file_exists cache_file
+      subject.render(@file_name, @file_locals)
+      assert_not_file_exists cache_file
+    end
+
+  end
+
+  class RenderContentTests < RenderTests
+    desc "when yielding to a given content block"
+    setup do
+      @file_name = "yield"
+      @content = Proc.new{ "<span>some content</span>" }
+    end
+
+    should "render the template for the given file name and return its data" do
+      exp = Factory.yield_erb_rendered(@file_locals, &@content)
+      assert_equal exp, subject.render(@file_name, @file_locals, &@content)
+    end
+
+  end
+
+  class CompileTests < RenderSetupTests
+    desc "`compile` method"
+
+    should "compile raw content file name and return its data" do
+      raw = "<p><%= 1 + 1 %></p>"
+      exp = "<p>2</p>"
+      assert_equal exp, subject.compile('compile', raw)
+    end
+
+  end
+
+  class DefaultSource < UnitTests
+    desc "DefaultSource"
+    setup do
+      @source = Deas::Erubis::DefaultSource.new
+    end
+    subject{ @source }
+
+    should "be a Source" do
+      assert_kind_of @source_class, subject
+    end
+
+    should "use `/` as its root" do
+      assert_equal '/', subject.root.to_s
+    end
+
+  end
+
+  class ContextClassSpy
+    attr_reader :deas_source
+    def initialize(deas_source, locals)
+      @deas_source = deas_source
+      metaclass = class << self; self; end
+      metaclass.class_eval do
+        locals.each do |key, value|
+          define_method(key){ value }
+        end
+      end
+    end
+  end
+
+end

data/test/unit/template_engine_tests.rb

@@ -0,0 +1,74 @@
+require 'assert'
+require 'deas-erubis'
+
+require 'deas/template_engine'
+require 'deas-erubis/source'
+
+class Deas::Erubis::TemplateEngine
+
+  class UnitTests < Assert::Context
+    desc "Deas::Erubis::TemplateEngine"
+    setup do
+      @engine = Deas::Erubis::TemplateEngine.new({
+        'source_path' => TEST_SUPPORT_PATH
+      })
+    end
+    subject{ @engine }
+
+    should have_imeths :erb_source, :erb_handler_local, :erb_logger_local
+    should have_imeths :render, :partial
+
+    should "be a Deas template engine" do
+      assert_kind_of Deas::TemplateEngine, subject
+    end
+
+    should "memoize its erb source" do
+      assert_kind_of Deas::Erubis::Source, subject.erb_source
+      assert_equal subject.source_path, subject.erb_source.root
+      assert_same subject.erb_source, subject.erb_source
+    end
+
+    should "allow custom eruby classes on its source" do
+      custom_eruby = 'some-eruby'
+      engine = Deas::Erubis::TemplateEngine.new('eruby' => custom_eruby)
+      assert_equal custom_eruby, engine.erb_source.eruby_class
+    end
+
+    should "allow custom cache roots on its source" do
+      engine = Deas::Erubis::TemplateEngine.new('cache' => TEMPLATE_CACHE_ROOT)
+      assert_equal TEMPLATE_CACHE_ROOT.to_s, engine.erb_source.cache_root.to_s
+    end
+
+    should "pass any given deas template source to its source" do
+      deas_source = 'a-deas-source'
+      source_opts = nil
+
+      Assert.stub(Deas::Erubis::Source, :new){ |root, opts| source_opts = opts }
+      Deas::Erubis::TemplateEngine.new('deas_template_source' => deas_source).erb_source
+
+      assert_equal deas_source, source_opts[:deas_source]
+    end
+
+    should "use 'view' as the handler local name by default" do
+      assert_equal 'view', subject.erb_handler_local
+    end
+
+    should "allow custom handler local names" do
+      handler_local = Factory.string
+      engine = Deas::Erubis::TemplateEngine.new('handler_local' => handler_local)
+      assert_equal handler_local, engine.erb_handler_local
+    end
+
+    should "use 'logger' as the logger local name by default" do
+      assert_equal 'logger', subject.erb_logger_local
+    end
+
+    should "allow custom logger local names" do
+      logger_local = Factory.string
+      engine = Deas::Erubis::TemplateEngine.new('logger_local' => logger_local)
+      assert_equal logger_local, engine.erb_logger_local
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification 
+name: deas-erubis
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kelly Redding
+- Collin Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2015-01-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 12
+        version: "2.12"
+  type: :development
+  name: assert
+  version_requirements: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 29
+        version: "0.29"
+  type: :runtime
+  name: deas
+  version_requirements: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  name: erubis
+  version_requirements: *id003
+  prerelease: false
+description: Deas template engine for rendering erb templates using Erubis
+email: 
+- kelly@kellyredding.com
+- collin.redding@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- deas-erubis.gemspec
+- lib/deas-erubis.rb
+- lib/deas-erubis/source.rb
+- lib/deas-erubis/template_helpers.rb
+- lib/deas-erubis/version.rb
+- log/.gitkeep
+- test/helper.rb
+- test/support/factory.rb
+- test/support/templates/_partial.erb
+- test/support/templates/_yield_partial.erb
+- test/support/templates/basic.erb
+- test/support/templates/compile.erb
+- test/support/templates/view.erb
+- test/support/templates/with_capture_partial.erb
+- test/support/templates/with_partial.erb
+- test/support/templates/yield.erb
+- test/support/templates/yield_view.erb
+- test/system/template_engine_tests.rb
+- test/unit/source_tests.rb
+- test/unit/template_engine_tests.rb
+- tmp/.gitkeep
+homepage: http://github.com/redding/deas-erubis
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Deas template engine for rendering erb templates using Erubis
+test_files: 
+- test/helper.rb
+- test/support/factory.rb
+- test/support/templates/_partial.erb
+- test/support/templates/_yield_partial.erb
+- test/support/templates/basic.erb
+- test/support/templates/compile.erb
+- test/support/templates/view.erb
+- test/support/templates/with_capture_partial.erb
+- test/support/templates/with_partial.erb
+- test/support/templates/yield.erb
+- test/support/templates/yield_view.erb
+- test/system/template_engine_tests.rb
+- test/unit/source_tests.rb
+- test/unit/template_engine_tests.rb