tilt 0.8 → 1.0

data/README.md

@@ -30,9 +30,10 @@ Support for these template engines is included with the package:
     Less CSS                   .less             less
     Builder                    .builder          builder
     Liquid                     .liquid           liquid
-    Mustache                   .mustache         mustache
     RDiscount                  .markdown         rdiscount
     RedCloth                   .textile          redcloth
+    RDoc                       .rdoc             rdoc
+    Radius                     .radius           radius
 
 See [TEMPLATES.md][t] for detailed information on template engine
 options and supported features.

data/Rakefile

@@ -11,11 +11,17 @@ end
 desc 'Run tests (default)'
 Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/*_test.rb']
-  t.ruby_opts = ['-rubygems'] if defined? Gem
+  t.ruby_opts = ['-Itest']
+  t.ruby_opts << '-rubygems' if defined? Gem
 end
 
 # PACKAGING =================================================================
 
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
 if defined?(Gem)
   SPEC = eval(File.read('tilt.gemspec'))
 
@@ -72,26 +78,3 @@ file 'tilt.gemspec' => FileList['{lib,test}/**','Rakefile'] do |f|
   File.open(f.name, 'w') { |io| io.write(spec) }
   puts "updated #{f.name}"
 end
-
-# DOC =======================================================================
-
-# requires the hanna gem:
-#   gem install mislav-hanna --source=http://gems.github.com
-desc 'Build API documentation (doc/api)'
-task 'rdoc' => 'rdoc/index.html' 
-file 'rdoc/index.html' => FileList['lib/**/*.rb'] do |f|
-  rm_rf 'rdoc'
-  sh((<<-SH).gsub(/[\s\n]+/, ' ').strip)
-  hanna
-    --op doc/api
-    --promiscuous
-    --charset utf8
-    --fmt html
-    --inline-source
-    --line-numbers
-    --accessor option_accessor=RW
-    --main Tilt
-    --title 'Tilt API Documentation'
-    #{f.prerequisites.join(' ')}
-  SH
-end

data/TEMPLATES.md

@@ -9,7 +9,6 @@ documentation on each supported template engine is provided below.
  * [Erubis](#erubis) - `Tilt::ErubisTemplate`
  * [Haml](#haml) - `Tilt::HamlTemplate`
  * [Liquid](#liquid) - `Tilt::LiquidTemplate`
- * [Mustache](#mustache) - `Tilt::MustachTemplate`
 
 Tilt includes support for CSS processors like [lesscss](http://lesscss.org)
 and [sass](http://sass-lang.com/), in addition, it also supports simple
@@ -94,15 +93,16 @@ the extensions as follows:
 
 ### Options
 
-#### `:trim => true`
-
-Delete spaces around '<% %>'. (But, spaces around '<%= %>' are preserved.)
+#### `:engine_class => Erubis::Eruby`
 
-#### `:pattern => '<% %>'`
+Allows you to specify a custom engine class to use instead of the
+default which is `Erubis::Eruby`.
 
-Set pattern for embedded Ruby code.
+#### `:escape_html => false`
 
-See the [ERB](#erb) template documentation for examples, usage, and options.
+When `true`, `Erubis::EscapedEruby` will be used as the engine class
+instead of the default. All content within `<%= %>` blocks will be
+automatically html escaped.
 
 #### `:outvar => '_erbout'`
 
@@ -110,6 +110,16 @@ The name of the variable used to accumulate template output. This can be
 any valid Ruby expression but must be assignable. By default a local
 variable named `_erbout` is used.
 
+#### `:pattern => '<% %>'`
+
+Set pattern for embedded Ruby code.
+
+See the [ERB](#erb) template documentation for examples, usage, and options.
+
+#### `:trim => true`
+
+Delete spaces around '<% %>'. (But, spaces around '<%= %>' are preserved.)
+
 ### See also
 
   * [Erubis Home](http://www.kuwata-lab.com/erubis/)
@@ -293,53 +303,6 @@ time when using this template engine within a threaded environment.
   * [Liquid Docs](http://liquid.rubyforge.org/)
   * GitHub: [tobi/liquid](http://github.com/tobi/liquid/)
 
-<a name='mustache'></a>
-Mustache (`mustache`)
----------------------
-
-Mustache is a framework-agnostic way to render logic-free views.
-
-__NOTE:__ It's suggested that your program `require 'mustache'` at load time
-when using this template engine in a threaded environment.
-
-### Options
-
-#### `:path => Dir.pwd`
-
-The base path where mustache templates (`.html` files) are located.  Defaults to
-the current working directory.
-
-#### `:template_extension => 'html'`
-
-The file extension used on mustache templates. Default is `'html'`.
-
-#### `:namespace => Object`
-
-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 => nil` or `:view_path => nil`
-
-Where mustache views (`.rb` files) are located, or `nil` to 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:
-
-#### `:view => nil`
-
-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.
-
-### See also
-
-  * [Mustache Docs](http://defunkt.github.com/mustache/)
-  * GitHub: [defunkt/mustache](http://github.com/defunkt/mustache)
-
-
 <a name='markdown'></a>
 Markdown (`markdown`, `md`, `mkd`)
 ----------------------------------
@@ -421,3 +384,56 @@ engine in a threaded environment.
 ### See also
 
  * [RDoc](http://rdoc.sourceforge.net/doc/index.html)
+
+
+<a name='radius'></a>
+Radius (`radius`)
+-----------------
+
+Radius is the template language used by Radiant CMS. It is a tag
+language designed to be valid XML/HTML.
+
+### Example
+
+    <html>
+    <body>
+      <h1><r:title /></h1>
+      <ul class="<r:type />">
+      <r:repeat times="3">
+        <li><r:hello />!</li>
+      </r:repeat>
+      </ul>
+      <r:yield />
+    </body>
+    </html>
+
+### Usage
+
+To render a template such as the one above.
+
+    scope = OpenStruct.new
+    scope.title = "Radius Example"
+    scope.hello = "Hello, World!"
+
+    require 'radius'
+    template = Tilt::RadiusTemplate.new('example.radius', :tag_prefix=>'r')
+    template.render(scope, :type=>'hlist'){ "Jackpot!" }
+
+The result will be:
+
+    <html>
+    <body>
+      <h1>Radius Example</h1>
+      <ul class="hlist">
+        <li>Hello, World!</li>
+        <li>Hello, World!</li>
+        <li>Hello, World!</li>
+      </ul>
+      Jackpot!
+    </body>
+    </html>
+
+### See also
+
+* [Radius](http://radius.rubyforge.org/)
+* [Radiant](http://radiantcms.org/)

data/lib/tilt.rb

@@ -1,7 +1,7 @@
 require 'digest/md5'
 
 module Tilt
-  VERSION = '0.8'
+  VERSION = '1.0'
 
   @template_mappings = {}
 
@@ -16,6 +16,11 @@ module Tilt
     mappings[ext.downcase] = template_class
   end
 
+  # Returns true when a template exists on an exact match of the provided file extension
+  def self.registered?(ext)
+    mappings.key?(ext.downcase)
+  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)
@@ -29,20 +34,12 @@ module Tilt
   # Lookup a template class for the given filename or file
   # extension. Return nil when no implementation is found.
   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
+    pattern = file.to_s.downcase
+    unless registered?(pattern)
+      pattern = File.basename(pattern)
+      pattern.sub!(/^[^.]*\.?/, '') until (pattern.empty? || registered?(pattern))
     end
+    @template_mappings[pattern]
   end
 
   # Mixin allowing template compilation on scope objects.
@@ -100,7 +97,7 @@ module Tilt
         case
         when arg.respond_to?(:to_str)  ; @file = arg.to_str
         when arg.respond_to?(:to_int)  ; @line = arg.to_int
-        when arg.respond_to?(:to_hash) ; @options = arg.to_hash
+        when arg.respond_to?(:to_hash) ; @options = arg.to_hash.dup
         else raise TypeError
         end
       end
@@ -353,18 +350,29 @@ module Tilt
   # ERB template implementation. See:
   # http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/classes/ERB.html
   class ERBTemplate < Template
+    @@default_output_variable = '_erbout'
+
+    def self.default_output_variable
+      @@default_output_variable
+    end
+
+    def self.default_output_variable=(name)
+      @@default_output_variable = name
+    end
+
     def initialize_engine
       return if defined? ::ERB
       require_template_library 'erb'
     end
 
     def prepare
-      @outvar = (options[:outvar] || '_erbout').to_s
+      @outvar = options[:outvar] || self.class.default_output_variable
       @engine = ::ERB.new(data, options[:safe], options[:trim], @outvar)
     end
 
     def precompiled_template(locals)
-      @engine.src
+      source = @engine.src
+      source
     end
 
     def precompiled_preamble(locals)
@@ -399,6 +407,16 @@ module Tilt
 
   # Erubis template implementation. See:
   # http://www.kuwata-lab.com/erubis/
+  #
+  # ErubisTemplate supports the following additional options, which are not
+  # passed down to the Erubis engine:
+  #
+  #   :engine_class   allows you to specify a custom engine class to use
+  #                   instead of the default (which is ::Erubis::Eruby).
+  #
+  #   :escape_html    when true, ::Erubis::EscapedEruby will be used as
+  #                   the engine class instead of the default. All content
+  #                   within <%= %> blocks will be automatically html escaped.
   class ErubisTemplate < ERBTemplate
     def initialize_engine
       return if defined? ::Erubis
@@ -407,8 +425,10 @@ module Tilt
 
     def prepare
       @options.merge!(:preamble => false, :postamble => false)
-      @outvar = (options.delete(:outvar) || '_erbout').to_s
-      @engine = ::Erubis::Eruby.new(data, options)
+      @outvar = options.delete(:outvar) || self.class.default_output_variable
+      engine_class = options.delete(:engine_class)
+      engine_class = ::Erubis::EscapedEruby if options.delete(:escape_html)
+      @engine = (engine_class || ::Erubis::Eruby).new(data, options)
     end
 
     def precompiled_preamble(locals)
@@ -651,55 +671,6 @@ module Tilt
   register 'textile', RedClothTemplate
 
 
-  # Mustache is written and maintained by Chris Wanstrath. See:
-  # http://github.com/defunkt/mustache
-  #
-  # When a scope argument is provided to MustacheTemplate#render, the
-  # instance variables are copied from the scope object to the Mustache
-  # view.
-  class MustacheTemplate < Template
-    attr_reader :engine
-
-    def initialize_engine
-      return if defined? ::Mustache
-      require_template_library 'mustache'
-    end
-
-    def prepare
-      Mustache.view_namespace = options[:namespace]
-      Mustache.view_path = options[:view_path] || options[:mustaches]
-      @engine = options[:view] || Mustache.view_class(name)
-      options.each do |key, value|
-        next if %w[view view_path namespace mustaches].include?(key.to_s)
-        @engine.send("#{key}=", value) if @engine.respond_to? "#{key}="
-      end
-    end
-
-    def evaluate(scope=nil, locals={}, &block)
-      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
-  end
-  register 'mustache', MustacheTemplate
-
-
   # RDoc template. See:
   # http://rdoc.rubyforge.org/
   #
@@ -726,21 +697,36 @@ module Tilt
   register 'rdoc', RDocTemplate
 
 
-  # CoffeeScript info:
-  # http://jashkenas.github.com/coffee-script/
-  class CoffeeTemplate < Template
+  # Radius Template
+  # http://github.com/jlong/radius/
+  class RadiusTemplate < Template
     def initialize_engine
-      return if defined? ::CoffeeScript
-      require_template_library 'coffee-script'
+      return if defined? ::Radius
+      require_template_library 'radius'
     end
 
     def prepare
-      @output = nil
     end
 
     def evaluate(scope, locals, &block)
-      @output ||= ::CoffeeScript::compile(data, options)
+      context = Class.new(Radius::Context).new
+      context.define_tag("yield") do
+        block.call
+      end
+      locals.each do |tag, value|
+        context.define_tag(tag) do
+          value
+        end
+      end
+      (class << context; self; end).class_eval do
+        define_method :tag_missing do |tag, attr, &block|
+          scope.__send__(tag)  # any way to support attr as args?
+        end
+      end
+      options = {:tag_prefix => 'r'}.merge(@options)
+      parser = Radius::Parser.new(context, options)
+      parser.parse(data)
     end
   end
-  register 'coffee', CoffeeTemplate
+  register 'radius', RadiusTemplate
 end

data/test/contest.rb

@@ -0,0 +1,68 @@
+require "test/unit"
+
+# Test::Unit loads a default test if the suite is empty, whose purpose is to
+# fail. Since having empty contexts is a common practice, we decided to
+# overwrite TestSuite#empty? in order to allow them. Having a failure when no
+# tests have been defined seems counter-intuitive.
+class Test::Unit::TestSuite
+  def empty?
+    false
+  end
+end
+
+# Contest adds +teardown+, +test+ and +context+ as class methods, and the
+# instance methods +setup+ and +teardown+ now iterate on the corresponding
+# blocks. Note that all setup and teardown blocks must be defined with the
+# block syntax. Adding setup or teardown instance methods defeats the purpose
+# of this library.
+class Test::Unit::TestCase
+  def self.setup(&block)
+    define_method :setup do
+      super(&block)
+      instance_eval(&block)
+    end
+  end
+
+  def self.teardown(&block)
+    define_method :teardown do
+      instance_eval(&block)
+      super(&block)
+    end
+  end
+
+  def self.context(name, &block)
+    subclass = Class.new(self)
+    remove_tests(subclass)
+    subclass.class_eval(&block) if block_given?
+    const_set(context_name(name), subclass)
+  end
+
+  def self.test(name, &block)
+    define_method(test_name(name), &block)
+  end
+
+  class << self
+    alias_method :should, :test
+    alias_method :describe, :context
+  end
+
+private
+
+  def self.context_name(name)
+    "Test#{sanitize_name(name).gsub(/(^| )(\w)/) { $2.upcase }}".to_sym
+  end
+
+  def self.test_name(name)
+    "test_#{sanitize_name(name).gsub(/\s+/,'_')}".to_sym
+  end
+
+  def self.sanitize_name(name)
+    name.gsub(/\W+/, ' ').strip
+  end
+
+  def self.remove_tests(subclass)
+    subclass.public_instance_methods.grep(/^test_/).each do |meth|
+      subclass.send(:undef_method, meth.to_sym)
+    end
+  end
+end

data/test/tilt_erbtemplate_test.rb

@@ -29,6 +29,23 @@ class ERBTemplateTest < Test::Unit::TestCase
     assert_equal "Hey Joe!", template.render(scope)
   end
 
+  class MockOutputVariableScope
+    attr_accessor :exposed_buffer
+  end
+
+  test "exposing the buffer to the template by default" do
+    begin
+      Tilt::ERBTemplate.default_output_variable = '@_out_buf'
+      template = Tilt::ERBTemplate.new { '<% self.exposed_buffer = @_out_buf %>hey' }
+      scope = MockOutputVariableScope.new
+      template.render(scope)
+      assert_not_nil scope.exposed_buffer
+      assert_equal scope.exposed_buffer, 'hey'
+    ensure
+      Tilt::ERBTemplate.default_output_variable = '_erbout'
+    end
+  end
+
   test "passing a block for yield" do
     template = Tilt::ERBTemplate.new { 'Hey <%= yield %>!' }
     assert_equal "Hey Joe!", template.render { 'Joe' }

data/test/tilt_erubistemplate_test.rb

@@ -26,6 +26,23 @@ begin
       assert_equal "Hey Joe!", template.render(scope)
     end
 
+    class MockOutputVariableScope
+      attr_accessor :exposed_buffer
+    end
+
+    test "exposing the buffer to the template by default" do
+      begin
+        Tilt::ErubisTemplate.default_output_variable = '@_out_buf'
+        template = Tilt::ErubisTemplate.new { '<% self.exposed_buffer = @_out_buf %>hey' }
+        scope = MockOutputVariableScope.new
+        template.render(scope)
+        assert_not_nil scope.exposed_buffer
+        assert_equal scope.exposed_buffer, 'hey'
+      ensure
+        Tilt::ErubisTemplate.default_output_variable = '_erbout'
+      end
+    end
+
     test "passing a block for yield" do
       template = Tilt::ErubisTemplate.new { 'Hey <%= yield %>!' }
       assert_equal "Hey Joe!", template.render { 'Joe' }
@@ -77,6 +94,32 @@ begin
       assert_equal '2', template.render(scope)
       assert_equal 'original value', scope.instance_variable_get(:@buf)
     end
+
+    test "using Erubis::EscapedEruby subclass via :engine_class option" do
+      template = Tilt::ErubisTemplate.new(nil, :engine_class => ::Erubis::EscapedEruby) { |t| %(<%= "<p>Hello World!</p>" %>) }
+      assert_equal "&lt;p&gt;Hello World!&lt;/p&gt;", template.render
+    end
+
+    test "using :escape_html => true option" do
+      template = Tilt::ErubisTemplate.new(nil, :escape_html => true) { |t| %(<%= "<p>Hello World!</p>" %>) }
+      assert_equal "&lt;p&gt;Hello World!&lt;/p&gt;", template.render
+    end
+
+    test "using :escape_html => false option" do
+      template = Tilt::ErubisTemplate.new(nil, :escape_html => false) { |t| %(<%= "<p>Hello World!</p>" %>) }
+      assert_equal "<p>Hello World!</p>", template.render
+    end
+
+    test "erubis default does not escape html" do
+      template = Tilt::ErubisTemplate.new { |t| %(<%= "<p>Hello World!</p>" %>) }
+      assert_equal "<p>Hello World!</p>", template.render
+    end
+
+    test "does not modify options argument" do
+      options_hash = {:escape_html => true}
+      template = Tilt::ErubisTemplate.new(nil, options_hash) { |t| "Hello World!" }
+      assert_equal({:escape_html => true}, options_hash)
+    end
   end
 rescue LoadError => boom
   warn "Tilt::ErubisTemplate (disabled)\n"

data/test/tilt_radiustemplate_test.rb

@@ -0,0 +1,66 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'radius'
+
+  class RadiusTemplateTest < Test::Unit::TestCase
+    test "registered for '.radius' files" do
+      assert_equal Tilt::RadiusTemplate, Tilt['test.radius']
+    end
+
+    test "preparing and evaluating templates on #render" do
+      template = Tilt::RadiusTemplate.new { |t| "Hello World!" }
+      assert_equal "Hello World!", template.render
+    end
+
+    test "passing locals" do
+      template = Tilt::RadiusTemplate.new { "Hey <r:name />!" }
+      assert_equal "Hey Joe!", template.render(nil, :name => 'Joe')
+    end
+
+    class ExampleRadiusScope
+      def beer; 'wet'; end
+      def whisky; 'wetter'; end
+    end
+
+    test "combining scope and locals when scope responds" do
+      template = Tilt::RadiusTemplate.new {
+        'Beer is <r:beer /> but Whisky is <r:whisky />.'
+      }
+      scope = ExampleRadiusScope.new
+      assert_equal "Beer is wet but Whisky is wetter.", template.render(scope)
+    end
+
+    test "precedence when locals and scope define same variables" do
+      template = Tilt::RadiusTemplate.new {
+        'Beer is <r:beer /> but Whisky is <r:whisky />.'
+      }
+      scope = ExampleRadiusScope.new
+      assert_equal "Beer is great but Whisky is greater.",
+        template.render(scope, :beer => 'great', :whisky => 'greater')
+    end
+
+    #test "handles local scope" do
+    #  beer   = 'wet'
+    #  whisky = 'wetter'
+    #
+    #  template = Tilt::RadiusTemplate.new {
+    #    'Beer is <r:beer /> but Whisky is <r:whisky />.'
+    #  }
+    #  assert_equal "Beer is wet but Whisky is wetter.", template.render(self)
+    #end
+
+    test "passing a block for yield" do
+      template = Tilt::RadiusTemplate.new {
+        'Beer is <r:yield /> but Whisky is <r:yield />ter.'
+      }
+      assert_equal "Beer is wet but Whisky is wetter.",
+        template.render({}) { 'wet' }
+    end
+  end
+
+rescue LoadError => boom
+  warn "Tilt::RadiusTemplate (disabled)\n"
+end
+

data/test/tilt_sasstemplate_test.rb

@@ -11,8 +11,8 @@ begin
     end
 
     test "compiles and evaluates the template on #render" do
-      template = Tilt::SassTemplate.new { |t| "#main\n  :background-color #0000ff" }
-      assert_equal "#main {\n  background-color: #0000ff; }\n", template.render
+      template = Tilt::SassTemplate.new { |t| "#main\n  :background-color #0000f1" }
+      assert_equal "#main {\n  background-color: #0000f1; }\n", template.render
     end
   end
 

data/test/tilt_template_test.rb

@@ -122,6 +122,8 @@ class TiltTemplateTest < Test::Unit::TestCase
   end
 
   class Person
+    CONSTANT = "Bob"
+
     attr_accessor :name
     def initialize(name)
       @name = name
@@ -138,4 +140,20 @@ class TiltTemplateTest < Test::Unit::TestCase
     inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{yield}!' }
     assert_equal "Hey Joe!", inst.render(Object.new){ 'Joe' }
   end
+
+  test "template which accesses a constant" do
+    inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{CONSTANT}!' }
+    assert_equal "Hey Bob!", inst.render(Person.new("Joe"))
+  end
+
+  class FastPerson < Person
+    include Tilt::CompileSite
+  end
+
+  # FAILING CONSTANT TEST. DISABLED FOR 1.0.
+
+  # test "template which accesses a constant with Tilt::CompileSite" do
+  #   inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{CONSTANT}!' }
+  #   assert_equal "Hey Bob!", inst.render(FastPerson.new("Joe"))
+  # end
 end

data/test/tilt_test.rb

@@ -14,15 +14,23 @@ class TiltTest < Test::Unit::TestCase
     Tilt.register('mock', MockTemplate)
   end
 
+  test "an extension is registered if explicit handle is found" do
+    Tilt.register('mock', MockTemplate)
+    assert Tilt.registered?('mock')
+  end
+
   test "registering template classes by symbol file extension" do
     Tilt.register(:mock, MockTemplate)
   end
 
-  test "looking up template classes by file extension" do
+  test "looking up template classes by exact file extension" do
     Tilt.register('mock', MockTemplate)
     impl = Tilt['mock']
     assert_equal MockTemplate, impl
+  end
 
+  test "looking up template classes by implicit file extension" do
+    Tilt.register('mock', MockTemplate)
     impl = Tilt['.mock']
     assert_equal MockTemplate, impl
   end

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.8'
-  s.date = '2010-03-07'
+  s.version = '1.0'
+  s.date = '2010-06-15'
 
   s.description = "Generic interface to multiple Ruby template engines"
   s.summary     = s.description
@@ -20,17 +20,16 @@ Gem::Specification.new do |s|
     TEMPLATES.md
     bin/tilt
     lib/tilt.rb
+    test/contest.rb
     test/tilt_buildertemplate_test.rb
     test/tilt_cache_test.rb
-    test/tilt_coffeetemplate_test.rb
     test/tilt_compilesite_test.rb
     test/tilt_erbtemplate_test.rb
     test/tilt_erubistemplate_test.rb
     test/tilt_hamltemplate_test.rb
     test/tilt_lesstemplate_test.rb
     test/tilt_liquidtemplate_test.rb
-    test/tilt_mustache_views/external.rb
-    test/tilt_mustachetemplate_test.rb
+    test/tilt_radiustemplate_test.rb
     test/tilt_rdiscounttemplate_test.rb
     test/tilt_rdoctemplate_test.rb
     test/tilt_redclothtemplate_test.rb
@@ -42,6 +41,9 @@ Gem::Specification.new do |s|
   ]
   # = MANIFEST =
 
+  s.default_executable = 'tilt'
+  s.executables = ['tilt']
+
   s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/}
   s.add_development_dependency 'contest'
   s.add_development_dependency 'builder'
@@ -52,6 +54,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'liquid'
   s.add_development_dependency 'less'
   s.add_development_dependency 'coffee-script'
+  s.add_development_dependency 'radius'
 
   s.extra_rdoc_files = %w[COPYING]
 

metadata

@@ -3,9 +3,9 @@ name: tilt
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
-  - 8
-  version: "0.8"
+  version: "1.0"
 platform: ruby
 authors: 
 - Ryan Tomayko
@@ -13,8 +13,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-07 00:00:00 -08:00
-default_executable: 
+date: 2010-06-15 00:00:00 -07:00
+default_executable: tilt
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: contest
@@ -126,10 +126,22 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: radius
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id010
 description: Generic interface to multiple Ruby template engines
 email: r@tomayko.com
-executables: []
-
+executables: 
+- tilt
 extensions: []
 
 extra_rdoc_files: 
@@ -141,17 +153,16 @@ files:
 - TEMPLATES.md
 - bin/tilt
 - lib/tilt.rb
+- test/contest.rb
 - test/tilt_buildertemplate_test.rb
 - test/tilt_cache_test.rb
-- test/tilt_coffeetemplate_test.rb
 - test/tilt_compilesite_test.rb
 - test/tilt_erbtemplate_test.rb
 - test/tilt_erubistemplate_test.rb
 - test/tilt_hamltemplate_test.rb
 - test/tilt_lesstemplate_test.rb
 - test/tilt_liquidtemplate_test.rb
-- test/tilt_mustache_views/external.rb
-- test/tilt_mustachetemplate_test.rb
+- test/tilt_radiustemplate_test.rb
 - test/tilt_rdiscounttemplate_test.rb
 - test/tilt_rdoctemplate_test.rb
 - test/tilt_redclothtemplate_test.rb
@@ -198,14 +209,13 @@ summary: Generic interface to multiple Ruby template engines
 test_files: 
 - test/tilt_buildertemplate_test.rb
 - test/tilt_cache_test.rb
-- test/tilt_coffeetemplate_test.rb
 - test/tilt_compilesite_test.rb
 - test/tilt_erbtemplate_test.rb
 - test/tilt_erubistemplate_test.rb
 - test/tilt_hamltemplate_test.rb
 - test/tilt_lesstemplate_test.rb
 - test/tilt_liquidtemplate_test.rb
-- test/tilt_mustachetemplate_test.rb
+- test/tilt_radiustemplate_test.rb
 - test/tilt_rdiscounttemplate_test.rb
 - test/tilt_rdoctemplate_test.rb
 - test/tilt_redclothtemplate_test.rb

data/test/tilt_coffeetemplate_test.rb

@@ -1,20 +0,0 @@
-require 'contest'
-require 'tilt'
-
-begin
-  require 'coffee-script'
-
-  class CoffeeTemplateTest < Test::Unit::TestCase
-    test "is registered for '.coffee' files" do
-      assert_equal Tilt::CoffeeTemplate, Tilt['test.coffee']
-    end
-
-    test "compiles and evaluates the template on #render" do
-      template = Tilt::CoffeeTemplate.new { |t| "greeting: \"Hello CoffeeScript\"" }
-      assert_equal "(function(){\n  var greeting;\n  greeting = \"Hello CoffeeScript\";\n})();", template.render
-    end
-  end
-
-rescue LoadError => boom
-  warn "Tilt::CoffeeTemplate (disabled)\n"
-end

data/test/tilt_mustache_views/external.rb

@@ -1,9 +0,0 @@
-require 'mustache'
-
-module Views
-  class External < Mustache
-    def hello
-      "Stached"
-    end
-  end
-end

data/test/tilt_mustachetemplate_test.rb

@@ -1,70 +0,0 @@
-require 'contest'
-require 'tilt'
-
-begin
-  require 'mustache'
-  raise LoadError, "mustache version must be > 0.2.2" if !Mustache.respond_to?(:compiled?)
-
-  module Views
-    class Foo < Mustache
-      attr_reader :foo
-    end
-  end
-
-  class MustacheTemplateTest < Test::Unit::TestCase
-    test "registered for '.mustache' files" do
-      assert_equal Tilt::MustacheTemplate, Tilt['test.mustache']
-    end
-
-    test "preparing and evaluating templates on #render" do
-      template = Tilt::MustacheTemplate.new { |t| "Hello World!" }
-      assert_equal "Hello World!", template.render
-    end
-
-    test "passing locals" do
-      template = Tilt::MustacheTemplate.new { "<p>Hey {{name}}!</p>" }
-      assert_equal "<p>Hey Joe!</p>", template.render(nil, :name => 'Joe')
-    end
-
-    test "passing a block for yield" do
-      template = Tilt::MustacheTemplate.new { "<p>Hey {{yield}}!</p>" }
-      assert_equal "<p>Hey Joe!</p>", template.render { 'Joe' }
-    end
-
-    test "locating views defined at the top-level" do
-      template = Tilt::MustacheTemplate.new('foo.mustache') { "<p>Hey {{foo}}!</p>" }
-      assert_equal Views::Foo, template.engine
-    end
-
-    module Bar
-      module Views
-        class Bizzle < Mustache
-        end
-      end
-    end
-
-    test "locating views defined in a custom namespace" do
-      template = Tilt::MustacheTemplate.new('bizzle.mustache', :namespace => Bar) { "<p>Hello World!</p>" }
-      assert_equal Bar::Views::Bizzle, template.engine
-      assert_equal "<p>Hello World!</p>", template.render
-    end
-
-    test "locating views in files" do
-      view_path = File.expand_path('../tilt_mustache_views', __FILE__)
-      template = Tilt::MustacheTemplate.new('external.mustache', :view_path => view_path) { "<p>{{hello}}!</p>" }
-      assert defined?(Views::External), "external.rb should have been required"
-      assert_equal Views::External, template.engine
-      assert_equal "<p>Stached!</p>", template.render
-    end
-
-    test "copying 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!')
-      assert_equal "<p>Hey Jane!!</p>", template.render(scope)
-    end
-  end
-
-rescue LoadError => boom
-  warn "Tilt::MustacheTemplate (disabled)\n"
-end