tilt 0.2 → 0.3

data/README.md

@@ -1,10 +1,10 @@
 Tilt
 ====
 
-Tilt provides a thin interface over a bunch of different template engines to
-make their usage as generic possible. This is useful for web frameworks,
-static site generators, and other systems that support multiple template
-engines but don't want to code for each of them explicitly.
+Tilt is a thin interface over a bunch of different Ruby template engines in
+an attempt to make their usage as generic possible. This is useful for web
+frameworks, static site generators, and other systems that support multiple
+template engines but don't want to code for each of them individually.
 
 The following features are supported for all template engines (assuming the
 feature is relevant to the engine):
@@ -15,61 +15,130 @@ feature is relevant to the engine):
  * Backtraces with correct filenames and line numbers
  * Template compilation caching and reloading
 
-These template engines are currently supported with (many) more on the way:
+The primary goal is to get all of the things listed above right for all
+template engines included in the distribution.
 
- * ERB
- * Interpolated Ruby String
- * Haml (with the `haml` gem/library)
- * Sass (with the `haml` gem/library)
- * Builder (with the `builder` gem/library)
- * Liquid (with the `liquid` gem/library)
+Support for these template engines is included with the package:
 
-Usage
------
+    ENGINE                     FILE EXTENSIONS   REQUIRED LIBRARIES
+    -------------------------- ----------------- ----------------------------
+    ERB                        .erb              none (included ruby stdlib)
+    Interpolated String        .str              none (included ruby core)
+    Haml                       .haml             haml
+    Sass                       .sass             haml
+    Builder                    .builder          builder
+    Liquid                     .liquid           liquid
+    Mustache                   .mustache         mustache
+    RDiscount                  .markdown         rdiscount
 
-All supported templates have an implementation class under the `Tilt` module.
-Each template implementation follows the exact same interface for creation
-and rendering:
+Basic Usage
+-----------
+
+Instant gratification:
+
+    require 'erb'
+    require 'tilt'
+    template = Tilt.new('templates/foo.erb')
+    => #<Tilt::ERBTemplate @file="templates/foo.rb" ...>
+    output = template.render
+    => "Hello world!"
+
+It's recommended that calling programs explicitly require template engine
+libraries (like 'erb' above) at load time. Tilt attempts to lazy require the
+template engine library the first time a template is created but this is
+prone to error in threaded environments.
+
+The `Tilt` module contains generic implementation classes for all supported
+template engines. Each template class adheres to the same interface for
+creation and rendering. In the instant gratification example, we let Tilt
+determine the template implementation class based on the filename, but
+`Tilt::Template` implementations can also be used directly:
 
     template = Tilt::HamlTemplate.new('templates/foo.haml')
     output = template.render
 
 The `render` method takes an optional evaluation scope and locals hash
-arguments. In the following example, the template is evaluated within the
-context of the person object and can access the locals `x` and `y`:
+arguments. Here, the template is evaluated within the context of the
+`Person` object with locals `x` and `y`:
 
     template = Tilt::ERBTemplate.new('templates/foo.erb')
     joe = Person.find('joe')
     output = template.render(joe, :x => 35, :y => 42)
 
-The `render` method may be called multiple times without creating a new
-template object. Continuing the previous example, we can render in Jane's
-scope with a different set of locals:
+If no scope is provided, the template is evaluated within the context of an
+object created with `Object.new`.
+
+A single `Template` instance's `render` method may be called multiple times
+with different scope and locals arguments. Continuing the previous example,
+we render the same compiled template but this time in jane's scope:
 
     jane = Person.find('jane')
     output = template.render(jane, :x => 22, :y => nil)
 
-Blocks can be passed to the render method for templates that support running
-arbitrary ruby code and using `yield`. Assuming the following was in a file
-named `foo.erb`:
+Blocks can be passed to `render` for templates that support running
+arbitrary ruby code (usually with some form of `yield`). For instance,
+assuming the following in `foo.erb`:
 
     Hey <%= yield %>!
 
-The block passed to the `render` method is invoked on `yield`:
+The block passed to `render` is called on `yield`:
 
     template = Tilt::ERBTemplate.new('foo.erb')
     template.render { 'Joe' }
     # => "Hey Joe!"
 
-There's also a lightweight file extension to template engine mapping layer.
-You can pass a filename or extension to `Tilt::[]` to retrieve the
-corresponding implementation class:
+Template Mappings
+-----------------
 
-    Tilt['hello.erb']
-    # => Tilt::ERBTemplate
+The `Tilt` module includes methods for associating template implementation
+classes with filename patterns and for locating/instantiating template
+classes based on those associations.
 
-The `Tilt.new` works similarly but returns a new instance of the underlying
-implementation class:
+The `Tilt::register` method associates a filename pattern with a specific
+template implementation. To use ERB for files ending in a `.bar` extension:
 
-    template = Tilt.new('templates/foo.erb')
-    output = template.render
+     >> Tilt.register 'bar', Tilt::ERBTemplate
+     >> Tilt.new('views/foo.bar')
+     => #<Tilt::ERBTemplate @file="views/foo.bar" ...>
+
+Retrieving the template class for a file or file extension:
+
+     >> Tilt['foo.bar']
+     => Tilt::ERBTemplate
+     >> Tilt['haml']
+     => Tilt::HamlTemplate
+
+It's also possible to register template file mappings that are more specific
+than a file extension. To use Erubis for `bar.erb` but ERB for all other `.erb`
+files:
+
+     >> Tilt.register 'bar.erb', Tilt::ErubisTemplate
+     >> Tilt.new('views/foo.erb')
+     => Tilt::ERBTemplate
+     >> Tilt.new('views/bar.erb')
+     => Tilt::ErubisTemplate
+
+The template class is determined by searching for a series of decreasingly
+specific name patterns. When creating a new template with
+`Tilt.new('views/foo.html.erb')`, we check for the following template
+mappings:
+
+  1. `views/foo.html.erb`
+  2. `foo.html.erb`
+  3. `html.erb`
+  4. `erb`
+
+`Tilt::register` can also be used to select between alternative template
+engines. To use Erubis instead of ERB for `.erb` files:
+
+    Tilt.register 'erb', Tilt::ErubisTemplate
+
+Or, use BlueCloth for markdown instead of RDiscount:
+
+    Tilt.register 'markdown', Tilt::BlueClothTemplate
+
+LICENSE
+-------
+
+Tilt is Copyright (c) 2009 [Ryan Tomayko](http://tomayko.com/about) and
+distributed under the MIT license. See the COPYING file for more info.

data/Rakefile

@@ -6,6 +6,7 @@ desc 'Generate test coverage report'
 task :rcov do
   sh "rcov -Ilib:test test/*_test.rb"
 end
+
 desc 'Run specs with unit test style output'
 task :test do |t|
   sh 'bacon -qa'
@@ -18,11 +19,8 @@ end
 
 # PACKAGING =================================================================
 
-# load gemspec like github's gem builder to surface any SAFE issues.
-Thread.new do
-  require 'rubygems/specification'
-  $spec = eval("$SAFE=3\n#{File.read('tilt.gemspec')}")
-end.join
+require 'rubygems/specification'
+$spec ||= eval(File.read('tilt.gemspec'))
 
 def package(ext='')
   "dist/tilt-#{$spec.version}" + ext
@@ -58,8 +56,12 @@ end
 # GEMSPEC ===================================================================
 
 file 'tilt.gemspec' => FileList['{lib,test}/**','Rakefile'] do |f|
+  # read version from tilt.rb
+  version = File.read('lib/tilt.rb')[/VERSION = '(.*)'/] && $1
   # read spec file and split out manifest section
-  spec = File.read(f.name)
+  spec = File.
+    read(f.name).
+    sub(/s\.version\s*=\s*'.*'/, "s.version = '#{version}'")
   parts = spec.split("  # = MANIFEST =\n")
   # determine file list from git ls-files
   files = `git ls-files`.

data/TEMPLATES.md

@@ -0,0 +1,49 @@
+Templates
+=========
+
+ERB (`erb`, `rhtml`)
+--------------------
+
+[Docs](http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html) |
+[Syntax](http://vision-media.ca/resources/ruby/ruby-rdoc-documentation-syntax)
+
+### Example
+
+    Hello <%= world %>!
+
+### Usage
+
+The `Tilt::ERBTemplate` class is registered for all files ending in `.erb` or
+`.rhtml` by default. ERB templates support custom evaluation scopes and locals:
+
+    >> require 'erb'
+    >> template = Tilt.new('hello.html.erb', :trim => '<>')
+    => #<Tilt::ERBTemplate @file='hello.html.erb'>
+    >> template.render(self, :world => 'World!')
+    => "Hello World!"
+
+Or, use the `Tilt::ERBTemplate` class directly to process strings:
+
+    require 'erb'
+    template = Tilt::ERBTemplate.new(nil, :trim => '<>') { "Hello <%= world %>!" }
+    template.render(self, :world => 'World!')
+
+### Options
+
+`:trim => '-'`
+
+The ERB trim mode flags. This is a string consisting
+of any combination of the following characters:
+
+  * `'>'`  omits newlines for lines ending in `>`
+  * `'<>'` omits newlines for lines starting with `<%` and ending in `%>`
+  * `'-'`  omits newlines for lines ending in `-%>`.
+  * `'%'`  enables processing of lines beginning with `%`
+
+`:safe => nil`
+
+The `$SAFE` level; when set, ERB code will be run in a
+separate thread with `$SAFE` set to the provided level.
+
+It's suggested that your program require 'erb' at load time when using this
+template engine.

data/bin/tilt

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+require 'ostruct'
+require 'optparse'
+require 'tilt'
+
+usage = <<EOF
+Usage: tilt [OPTIONS] [FILE]
+Process template FILE and generate output. With no FILE or when FILE
+is '-', read template from stdin and use the --type option to determine
+the template's type.
+
+Options
+  -l, --list           List supported template engines + file patterns and exit.
+  -t, --type=PATTERN   Use this template engine; required when FILE is stdin.
+
+  -h, --help           Show this help message.
+
+Convert markdown to HTML:
+  $ tilt foo.markdown > foo.html
+
+Process ERB template:
+  $ echo "Answer: <%= 2 + 2 %>" | tilt -t erb
+  Answer: 4
+EOF
+
+script_name = File.basename($0)
+pattern = nil
+layout = nil
+
+ARGV.options do |o|
+  o.program_name = script_name
+
+  # list all available template engines
+  o.on("-l", "--list") do
+    groups = {}
+    Tilt.mappings.each do |pattern,engine|
+      key = engine.name.split('::').last.sub(/Template$/, '')
+      (groups[key] ||= []) << pattern
+    end
+    groups.sort { |(k1,v1),(k2,v2)| k1 <=> k2 }.each do |engine,files|
+      printf "%-15s %s\n", engine, files.sort.join(', ')
+    end
+    exit
+  end
+
+  # the template type / pattern
+  o.on("-t", "--type=PATTERN") do |val|
+    fail "unknown template type: #{val}" if Tilt[val].nil?
+    pattern = val
+  end
+
+  # pass template output into the specified layout template
+  o.on("-y", "--layout=FILE")  do |file|
+    paths = [file, "~/.tilt/#{file}", "/etc/tilt/#{file}"]
+    layout = paths.
+      map  { |p| File.expand_path(p) }.
+      find { |p| File.exist?(p) }
+    fail "no such layout: #{file}" if layout.nil?
+  end
+
+  o.on_tail("-h", "--help") { puts usage; exit }
+
+  o.parse!
+end
+
+file = ARGV.first || '-'
+pattern = file if pattern.nil?
+template =
+  Tilt[pattern].new(file) {
+    if file == '-'
+      $stdin.read
+    else
+      File.read(file)
+    end
+  }
+output = template.render
+
+# process layout
+output = Tilt.new(layout).render { output } if layout
+
+$stdout.write(output)

data/lib/tilt.rb

@@ -1,16 +1,24 @@
 module Tilt
+  VERSION = '0.3'
+
   @template_mappings = {}
 
+  # Hash of template path pattern => template implementation
+  # class mappings.
+  def self.mappings
+    @template_mappings
+  end
+
   # Register a template implementation by file extension.
   def self.register(ext, template_class)
-    ext = ext.sub(/^\./, '')
-    @template_mappings[ext.downcase] = template_class
+    ext = ext.to_s.sub(/^\./, '')
+    mappings[ext.downcase] = template_class
   end
 
   # Create a new template for the given file using the file's extension
   # to determine the the template mapping.
   def self.new(file, line=nil, options={}, &block)
-    if template_class = self[File.basename(file)]
+    if template_class = self[file]
       template_class.new(file, line, options, &block)
     else
       fail "No template engine registered for #{File.basename(file)}"
@@ -19,13 +27,21 @@ module Tilt
 
   # Lookup a template class given for the given filename or file
   # extension. Return nil when no implementation is found.
-  def self.[](filename)
-    ext = filename.to_s.downcase
-    until ext.empty?
-      return @template_mappings[ext]  if @template_mappings.key?(ext)
-      ext = ext.sub(/^[^.]*\.?/, '')
+  def self.[](file)
+    if @template_mappings.key?(pattern = file.to_s.downcase)
+      @template_mappings[pattern]
+    elsif @template_mappings.key?(pattern = File.basename(pattern))
+      @template_mappings[pattern]
+    else
+      while !pattern.empty?
+        if @template_mappings.key?(pattern)
+          return @template_mappings[pattern]
+        else
+          pattern = pattern.sub(/^[^.]*\.?/, '')
+        end
+      end
+      nil
     end
-    nil
   end
 
   # Base class for template implementations. Subclasses must implement
@@ -52,26 +68,44 @@ module Tilt
     # file is nil, a block is required.
     def initialize(file=nil, line=1, options={}, &block)
       raise ArgumentError, "file or block required" if file.nil? && block.nil?
+      options, line = line, 1 if line.is_a?(Hash)
       @file = file
       @line = line || 1
       @options = options || {}
       @reader = block || lambda { |t| File.read(file) }
     end
 
-    # Render the template in the given scope with the locals specified. If a
-    # block is given, it is typically available within the template via
-    # +yield+.
-    def render(scope=Object.new, locals={}, &block)
+    # Load template source and compile the template. The template is
+    # loaded and compiled the first time this method is called; subsequent
+    # calls are no-ops.
+    def compile
       if @data.nil?
         @data = @reader.call(self)
         compile!
       end
+    end
+
+    # Render the template in the given scope with the locals specified. If a
+    # block is given, it is typically available within the template via
+    # +yield+.
+    def render(scope=Object.new, locals={}, &block)
+      compile
       evaluate scope, locals || {}, &block
     end
 
+    # The basename of the template file.
+    def basename(suffix='')
+      File.basename(file, suffix) if file
+    end
+
+    # The template file's basename with all extensions chomped off.
+    def name
+      basename.split('.', 2).first if basename
+    end
+
     # The filename used in backtraces to describe the template.
     def eval_file
-      @file || '(__TEMPLATE__)'
+      file || '(__TEMPLATE__)'
     end
 
   protected
@@ -107,8 +141,10 @@ module Tilt
     end
 
     def require_template_library(name)
-      warn "WARN: loading '#{name}' library in a non thread-safe way; " +
-           "explicit require '#{name}' suggested."
+      if Thread.list.size > 1
+        warn "WARN: tilt autoloading '#{name}' in a non thread-safe way; " +
+             "explicit require '#{name}' suggested."
+      end
       require name
     end
   end
@@ -152,7 +188,7 @@ module Tilt
   class ERBTemplate < Template
     def compile!
       require_template_library 'erb' unless defined?(::ERB)
-      @engine = ::ERB.new(data, nil, nil, '@_out_buf')
+      @engine = ::ERB.new(data, options[:safe], options[:trim], '@_out_buf')
     end
 
     def template_source
@@ -188,6 +224,20 @@ module Tilt
   end
   %w[erb rhtml].each { |ext| register ext, ERBTemplate }
 
+  # Erubis template implementation. See:
+  # http://www.kuwata-lab.com/erubis/
+  #
+  # It's suggested that your program require 'erubis' at load
+  # time when using this template engine.
+  class ErubisTemplate < ERBTemplate
+    def compile!
+      require_template_library 'erubis' unless defined?(::Erubis)
+      Erubis::Eruby.class_eval(%Q{def add_preamble(src) src << "@_out_buf = _buf = '';" end})
+      @engine = ::Erubis::Eruby.new(data)
+    end
+  end
+  register 'erubis', ErubisTemplate
+
   # Haml template implementation. See:
   # http://haml.hamptoncatlin.com/
   #
@@ -293,5 +343,107 @@ module Tilt
     end
   end
   register 'markdown', RDiscountTemplate
+  register 'md', RDiscountTemplate
 
+  # Mustache is written and maintained by Chris Wanstrath. See:
+  # http://github.com/defunkt/mustache
+  #
+  # It's suggested that your program require 'mustache' at load
+  # time when using this template engine.
+  #
+  # Mustache templates support the following options:
+  #
+  # * :view - The Mustache subclass that should be used a the view. When
+  #   this option is specified, the template file will be determined from
+  #   the view class, and the :namespace and :mustaches options are
+  #   irrelevant.
+  #
+  # * :namespace - The class or module where View classes are located.
+  #   If you have Hurl::App::Views, namespace should be Hurl:App. This
+  #   defaults to Object, causing ::Views to be searched for classes.
+  #
+  # * :mustaches - Where mustache views (.rb files) are located, or nil
+  #   disable auto-requiring of views based on template names. By default,
+  #   the view file is assumed to be in the same directory as the template
+  #   file.
+  #
+  # All other options are assumed to be attribute writer's on the Mustache
+  # class and are set when a template is compiled. They are:
+  #
+  # * :path - The base path where mustache templates (.html files) are
+  #   located. This defaults to the current working directory.
+  #
+  # * :template_extension - The file extension used on mustache templates.
+  #   The default is 'html'.
+  #
+  class MustacheTemplate < Template
+    attr_reader :engine
+
+    # Locates and compiles the Mustache object used to create new views. The
+    def compile!
+      require_template_library 'mustache' unless defined?(::Mustache)
+
+      @view_name = Mustache.classify(name.to_s)
+      @namespace = options[:namespace] || Object
+
+      # Figure out which Mustache class to use.
+      @engine =
+        if options[:view]
+          @view_name = options[:view].name
+          options[:view]
+        elsif @namespace.const_defined?(:Views) &&
+          @namespace::Views.const_defined?(@view_name)
+          @namespace::Views.const_get(@view_name)
+        elsif load_mustache_view
+          engine = @namespace::Views.const_get(@view_name)
+          engine.template = data
+          engine
+        else
+          Mustache
+        end
+
+      # set options on the view class
+      options.each do |key, value|
+        next if %w[view namespace mustaches].include?(key.to_s)
+        @engine.send("#{key}=", value) if @engine.respond_to? "#{key}="
+      end
+    end
+
+    def evaluate(scope=nil, locals={}, &block)
+      # Create a new instance for playing with
+      instance = @engine.new
+
+      # Copy instance variables from scope to the view
+      scope.instance_variables.each do |name|
+        instance.instance_variable_set(name, scope.instance_variable_get(name))
+      end
+
+      # Locals get added to the view's context
+      locals.each do |local, value|
+        instance[local] = value
+      end
+
+      # If we're passed a block it's a subview. Sticking it in yield
+      # lets us use {{yield}} in layout.html to render the actual page.
+      instance[:yield] = block.call if block
+
+      instance.template = data unless instance.compiled?
+
+      instance.to_html
+    end
+
+    # Require the mustache view lib if it exists.
+    def load_mustache_view
+      return if name.nil?
+      path = "#{options[:mustaches]}/#{name}.rb"
+      if options[:mustaches] && File.exist?(path)
+        require path.chomp('.rb')
+        path
+      elsif File.exist?(path = file.sub(/\.[^\/]+$/, '.rb'))
+        require path.chomp('.rb')
+        path
+      end
+    end
+  end
+  register 'mustache', MustacheTemplate
 end

data/test/spec_tilt.rb

@@ -1,7 +1,7 @@
 require 'bacon'
 require 'tilt'
 
-describe "Tilt" do
+describe Tilt do
   class MockTemplate
     attr_reader :args, :block
     def initialize(*args, &block)
@@ -14,6 +14,10 @@ describe "Tilt" do
     lambda { Tilt.register('mock', MockTemplate) }.should.not.raise
   end
 
+  it "registers template implementation classes by a file extension given as a symbol" do
+    lambda { Tilt.register(:mock, MockTemplate) }.should.not.raise
+  end
+
   it "looks up template implementation classes by file extension" do
     impl = Tilt['mock']
     impl.should.equal MockTemplate
@@ -36,6 +40,11 @@ describe "Tilt" do
     Tilt['none'].should.be.nil
   end
 
+  it "exposes the file pattern -> template class Hash at Tilt::mappings" do
+    Tilt.should.respond_to :mappings
+    Tilt.mappings.should.respond_to :[]
+  end
+
   it "creates a new template instance given a filename" do
     template = Tilt.new('foo.mock', 1, :key => 'val') { 'Hello World!' }
     template.args.should.equal ['foo.mock', 1, {:key => 'val'}]

data/test/spec_tilt_buildertemplate.rb

@@ -1,8 +1,9 @@
 require 'bacon'
 require 'tilt'
 require 'erb'
+require 'builder'
 
-describe "Tilt::BuilderTemplate" do
+describe Tilt::BuilderTemplate do
   it "is registered for '.builder' files" do
     Tilt['test.builder'].should.equal Tilt::BuilderTemplate
     Tilt['test.xml.builder'].should.equal Tilt::BuilderTemplate

data/test/spec_tilt_erbtemplate.rb

@@ -2,7 +2,7 @@ require 'bacon'
 require 'tilt'
 require 'erb'
 
-describe "Tilt::ERBTemplate" do
+describe Tilt::ERBTemplate do
   it "is registered for '.erb' files" do
     Tilt['test.erb'].should.equal Tilt::ERBTemplate
     Tilt['test.html.erb'].should.equal Tilt::ERBTemplate
@@ -65,6 +65,21 @@ describe "Tilt::ERBTemplate" do
       line.should.equal '6'
     end
   end
+
+  it "renders erb templates with new lines by default" do
+    template = Tilt.new('test.erb', 1) { "\n<%= 1 + 1 %>\n" }
+    template.render.should.equal "\n2\n"
+  end
+
+  it "strips new lines explicitly when :trim option is set to '-'" do
+    template = Tilt.new('test.erb', 1, :trim => '-') { "\n<%= 1 + 1 -%>\n" }
+    template.render.should.equal "\n2"
+  end
+
+  it "processes lines start with % when :trim option is set to '%'" do
+    template = Tilt.new('test.erb', 1, :trim => '%') { "\n% if true\nhello\n%end\n" }
+    template.render.should.equal "\nhello\n"
+  end
 end
 
 __END__

data/test/spec_tilt_erubistemplate.rb

@@ -0,0 +1,78 @@
+require 'bacon'
+require 'tilt'
+
+begin
+  require 'erubis'
+  describe "Tilt::ErubisTemplate" do
+    it "is registered for '.erubis' files" do
+      Tilt['test.erubis'].should.equal Tilt::ErubisTemplate
+      Tilt['test.html.erubis'].should.equal Tilt::ErubisTemplate
+    end
+
+    it "compiles and evaluates the template on #render" do
+      template = Tilt::ErubisTemplate.new { |t| "Hello World!" }
+      template.render.should.equal "Hello World!"
+    end
+
+    it "supports locals" do
+      template = Tilt::ErubisTemplate.new { 'Hey <%= name %>!' }
+      template.render(Object.new, :name => 'Joe').should.equal "Hey Joe!"
+    end
+
+    it "is evaluated in the object scope provided" do
+      template = Tilt::ErubisTemplate.new { 'Hey <%= @name %>!' }
+      scope = Object.new
+      scope.instance_variable_set :@name, 'Joe'
+      template.render(scope).should.equal "Hey Joe!"
+    end
+
+    it "evaluates template_source with yield support" do
+      template = Tilt::ErubisTemplate.new { 'Hey <%= yield %>!' }
+      template.render { 'Joe' }.should.equal "Hey Joe!"
+    end
+
+    it "reports the file and line properly in backtraces without locals" do
+      data = File.read(__FILE__).split("\n__END__\n").last
+      fail unless data[0] == ?<
+      template = Tilt::ErubisTemplate.new('test.erubis', 11) { data }
+      begin
+        template.render
+        flunk 'should have raised an exception'
+      rescue => boom
+        boom.should.be.kind_of NameError
+        line = boom.backtrace.first
+        file, line, meth = line.split(":")
+        file.should.equal 'test.erubis'
+        line.should.equal '13'
+      end
+    end
+
+    it "reports the file and line properly in backtraces with locals" do
+      data = File.read(__FILE__).split("\n__END__\n").last
+      fail unless data[0] == ?<
+      template = Tilt::ErubisTemplate.new('test.erubis', 1) { data }
+      begin
+        template.render(nil, :name => 'Joe', :foo => 'bar')
+        flunk 'should have raised an exception'
+      rescue => boom
+        boom.should.be.kind_of RuntimeError
+        line = boom.backtrace.first
+        file, line, meth = line.split(":")
+        file.should.equal 'test.erubis'
+        line.should.equal '6'
+      end
+    end
+  end
+rescue LoadError => boom
+  warn "Tilt::ErubisTemplate (disabled)\n"
+end
+
+__END__
+<html>
+<body>
+  <h1>Hey <%= name %>!</h1>
+
+
+  <p><% fail %></p>
+</body>
+</html>

data/test/spec_tilt_hamltemplate.rb

@@ -6,7 +6,8 @@ begin
   end
 
   require 'haml'
-  describe "Tilt::HamlTemplate" do
+
+  describe Tilt::HamlTemplate do
     it "is registered for '.haml' files" do
       Tilt['test.haml'].should.equal Tilt::HamlTemplate
     end

data/test/spec_tilt_liquid_template.rb

@@ -3,7 +3,8 @@ require 'tilt'
 
 begin
   require 'liquid'
-  describe "Tilt::LiquidTemplate" do
+
+  describe Tilt::LiquidTemplate do
     it "is registered for '.liquid' files" do
       Tilt['test.liquid'].should.equal Tilt::LiquidTemplate
     end

data/test/spec_tilt_mustachetemplate.rb

@@ -0,0 +1,64 @@
+require 'bacon'
+require 'tilt'
+
+begin
+  require 'mustache'
+  raise LoadError, "mustache version must be > 0.2.2" if !Mustache.respond_to?(:compiled?)
+
+  describe Tilt::MustacheTemplate do
+    it "is registered for '.mustache' files" do
+      Tilt['test.mustache'].should.equal Tilt::MustacheTemplate
+    end
+
+    it "compiles and evaluates the template on #render" do
+      template = Tilt::MustacheTemplate.new { |t| "Hello World!" }
+      template.render.should.equal "Hello World!"
+    end
+
+    it "supports locals" do
+      template = Tilt::MustacheTemplate.new { "<p>Hey {{name}}!</p>" }
+      template.render(nil, :name => 'Joe').should.equal "<p>Hey Joe!</p>"
+    end
+
+    it "evaluates template_source with yield support" do
+      template = Tilt::MustacheTemplate.new { "<p>Hey {{yield}}!</p>" }
+      template.render { 'Joe' }.should.equal "<p>Hey Joe!</p>"
+    end
+
+    module Views
+      class Foo < Mustache
+        attr_reader :foo
+      end
+    end
+
+    it "locates views defined at the top-level by default" do
+      template = Tilt::MustacheTemplate.new('foo.mustache') { "<p>Hey {{foo}}!</p>" }
+      template.compile
+      template.engine.should.equal Views::Foo
+    end
+
+    module Bar
+      module Views
+        class Bizzle < Mustache
+        end
+      end
+    end
+
+    it "locates views defined in a custom namespace" do
+      template = Tilt::MustacheTemplate.new('bizzle.mustache', :namespace => Bar) { "<p>Hello World!</p>" }
+      template.compile
+      template.engine.should.equal Bar::Views::Bizzle
+      template.render.should.equal "<p>Hello World!</p>"
+    end
+
+    it "copies instance variables from scope object" do
+      template = Tilt::MustacheTemplate.new('foo.mustache') { "<p>Hey {{foo}}!</p>" }
+      scope = Object.new
+      scope.instance_variable_set(:@foo, 'Jane!')
+      template.render(scope).should.equal "<p>Hey Jane!!</p>"
+    end
+  end
+
+rescue LoadError => boom
+  warn "Tilt::MustacheTemplate (disabled)\n"
+end

data/test/spec_tilt_rdiscount.rb

@@ -3,7 +3,8 @@ require 'tilt'
 
 begin
   require 'rdiscount'
-  describe "Tilt::RDiscountTemplate" do
+
+  describe Tilt::RDiscountTemplate do
     it "is registered for '.markdown' files" do
       Tilt['test.markdown'].should.equal Tilt::RDiscountTemplate
     end

data/test/spec_tilt_sasstemplate.rb

@@ -3,7 +3,9 @@ require 'tilt'
 
 begin
   require 'haml'
-  describe "Tilt::SassTemplate" do
+  require 'sass'
+
+  describe Tilt::SassTemplate do
     it "is registered for '.sass' files" do
       Tilt['test.sass'].should.equal Tilt::SassTemplate
     end

data/test/spec_tilt_stringtemplate.rb

@@ -1,7 +1,7 @@
 require 'bacon'
 require 'tilt'
 
-describe "Tilt::StringTemplate" do
+describe Tilt::StringTemplate do
   it "is registered for '.str' files" do
     Tilt['test.str'].should.equal Tilt::StringTemplate
   end

data/test/spec_tilt_template.rb

@@ -1,7 +1,7 @@
 require 'bacon'
 require 'tilt'
 
-describe "Tilt::Template" do
+describe Tilt::Template do
   it "raises ArgumentError when a file or block not given" do
     lambda { Tilt::Template.new }.should.raise ArgumentError
   end
@@ -28,6 +28,16 @@ describe "Tilt::Template" do
     inst.eval_file.should.not.include "\n"
   end
 
+  it "responds to #basename with the file's basename" do
+    inst = Tilt::Template.new('/tmp/templates/foo.html.erb')
+    inst.basename.should.equal 'foo.html.erb'
+  end
+
+  it "responds to #name with the file's basename minus file extensions" do
+    inst = Tilt::Template.new('/tmp/templates/foo.html.erb')
+    inst.name.should.equal 'foo'
+  end
+
   it "can be constructed with a data loading block" do
     lambda {
       Tilt::Template.new { |template| "Hello World!" }

data/tilt.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'tilt'
-  s.version = '0.2'
-  s.date = '2009-06-07'
+  s.version = '0.3'
+  s.date = '2009-10-16'
 
   s.description = "Generic interface to multiple Ruby template engines"
   s.summary     = s.description
@@ -17,13 +17,17 @@ Gem::Specification.new do |s|
     COPYING
     README.md
     Rakefile
+    TEMPLATES.md
+    bin/tilt
     lib/tilt.rb
     test/.bacon
     test/spec_tilt.rb
     test/spec_tilt_buildertemplate.rb
     test/spec_tilt_erbtemplate.rb
+    test/spec_tilt_erubistemplate.rb
     test/spec_tilt_hamltemplate.rb
     test/spec_tilt_liquid_template.rb
+    test/spec_tilt_mustachetemplate.rb
     test/spec_tilt_rdiscount.rb
     test/spec_tilt_sasstemplate.rb
     test/spec_tilt_stringtemplate.rb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tilt
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: "0.3"
 platform: ruby
 authors: 
 - Ryan Tomayko
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-07 00:00:00 -07:00
+date: 2009-10-16 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,13 +25,17 @@ files:
 - COPYING
 - README.md
 - Rakefile
+- TEMPLATES.md
+- bin/tilt
 - lib/tilt.rb
 - test/.bacon
 - test/spec_tilt.rb
 - test/spec_tilt_buildertemplate.rb
 - test/spec_tilt_erbtemplate.rb
+- test/spec_tilt_erubistemplate.rb
 - test/spec_tilt_hamltemplate.rb
 - test/spec_tilt_liquid_template.rb
+- test/spec_tilt_mustachetemplate.rb
 - test/spec_tilt_rdiscount.rb
 - test/spec_tilt_sasstemplate.rb
 - test/spec_tilt_stringtemplate.rb
@@ -39,6 +43,8 @@ files:
 - tilt.gemspec
 has_rdoc: true
 homepage: http://github.com/rtomayko/tilt/
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --line-numbers
@@ -64,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: wink
-rubygems_version: 1.3.1
+rubygems_version: 1.3.4
 signing_key: 
 specification_version: 2
 summary: Generic interface to multiple Ruby template engines
@@ -72,8 +78,10 @@ test_files:
 - test/spec_tilt.rb
 - test/spec_tilt_buildertemplate.rb
 - test/spec_tilt_erbtemplate.rb
+- test/spec_tilt_erubistemplate.rb
 - test/spec_tilt_hamltemplate.rb
 - test/spec_tilt_liquid_template.rb
+- test/spec_tilt_mustachetemplate.rb
 - test/spec_tilt_rdiscount.rb
 - test/spec_tilt_sasstemplate.rb
 - test/spec_tilt_stringtemplate.rb