tilt 1.3.3 → 1.3.5

data/lib/tilt/rdoc.rb

@@ -4,23 +4,34 @@ module Tilt
   # RDoc template. See:
   # http://rdoc.rubyforge.org/
   #
-  # It's suggested that your program require 'rdoc/markup' and
-  # 'rdoc/markup/to_html' at load time when using this template
-  # engine.
+  # It's suggested that your program `require 'rdoc/markup'` and
+  # `require 'rdoc/markup/to_html'` at load time when using this template
+  # engine in a threaded environment.
   class RDocTemplate < Template
     self.default_mime_type = 'text/html'
 
     def self.engine_initialized?
-      defined? ::RDoc::Markup
+      defined? ::RDoc::Markup::ToHtml
     end
 
     def initialize_engine
+      require_template_library 'rdoc'
       require_template_library 'rdoc/markup'
       require_template_library 'rdoc/markup/to_html'
     end
 
+    def markup
+      begin
+        # RDoc 4.0
+        require 'rdoc/options'
+        RDoc::Markup::ToHtml.new(RDoc::Options.new, nil)
+      rescue ArgumentError
+        # RDoc < 4.0
+        RDoc::Markup::ToHtml.new
+      end
+    end
+
     def prepare
-      markup = RDoc::Markup::ToHtml.new
       @engine = markup.convert(data)
       @output = nil
     end
@@ -28,5 +39,9 @@ module Tilt
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_s
     end
+
+    def allows_script?
+      false
+    end
   end
 end

data/lib/tilt/template.rb

@@ -41,6 +41,7 @@ module Tilt
       [options, line, file].compact.each do |arg|
         case
         when arg.respond_to?(:to_str)  ; @file = arg.to_str
+        when arg.respond_to?(:path)    ; @file = arg.path
         when arg.respond_to?(:to_int)  ; @line = arg.to_int
         when arg.respond_to?(:to_hash) ; @options = arg.to_hash.dup
         else raise TypeError
@@ -91,6 +92,15 @@ module Tilt
       file || '(__TEMPLATE__)'
     end
 
+    # Whether or not this template engine allows executing Ruby script
+    # within the template. If this is false, +scope+ and +locals+ will
+    # generally not be used, nor will the provided block be avaiable 
+    # via +yield+.
+    # This should be overridden by template subclasses.
+    def allows_script?
+      true
+    end
+
   protected
     # Called once and only once for each template subclass the first time
     # the template class is initialized. This should be used to require the
@@ -98,7 +108,7 @@ module Tilt
     def initialize_engine
     end
 
-    # Like Kernel::require but issues a warning urging a manual require when
+    # Like Kernel#require but issues a warning urging a manual require when
     # running under a threaded environment.
     def require_template_library(name)
       if Thread.list.size > 1
@@ -123,25 +133,15 @@ module Tilt
       end
     end
 
+    # Execute the compiled template and return the result string. Template
+    # evaluation is guaranteed to be performed in the scope object with the
+    # locals specified and with support for yielding to the block.
+    #
+    # This method is only used by source generating templates. Subclasses that
+    # override render() may not support all features.
     def evaluate(scope, locals, &block)
-      cached_evaluate(scope, locals, &block)
-    end
-
-    # Process the template and return the result. The first time this
-    # method is called, the template source is evaluated with instance_eval.
-    # On the sequential method calls it will compile the template to an
-    # unbound method which will lead to better performance. In any case,
-    # template executation is guaranteed to be performed in the scope object
-    # with the locals specified and with support for yielding to the block.
-    def cached_evaluate(scope, locals, &block)
-      # Redefine itself to use method compilation the next time:
-      def self.cached_evaluate(scope, locals, &block)
-        method = compiled_method(locals.keys)
-        method.bind(scope).call(locals, &block)
-      end
-
-      # Use instance_eval the first time:
-      evaluate_source(scope, locals, &block)
+      method = compiled_method(locals.keys)
+      method.bind(scope).call(locals, &block)
     end
 
     # Generates all template source by combining the preamble, template, and
@@ -186,7 +186,13 @@ module Tilt
     # source line offset, so adding code to the preamble does not effect line
     # reporting in Kernel::caller and backtraces.
     def precompiled_preamble(locals)
-      locals.map { |k,v| "#{k} = locals[#{k.inspect}]" }.join("\n")
+      locals.map do |k,v|
+        if k.to_s =~ /\A[a-z_][a-zA-Z_0-9]*\z/
+          "#{k} = locals[#{k.inspect}]"
+        else
+          raise "invalid locals key: #{k.inspect} (keys must be variable names)"
+        end
+      end.join("\n")
     end
 
     # Generates postamble code for the precompiled template source. The
@@ -203,34 +209,10 @@ module Tilt
     end
 
   private
-    # Evaluate the template source in the context of the scope object.
-    def evaluate_source(scope, locals, &block)
-      source, offset = precompiled(locals)
-      scope.instance_eval(source, eval_file, line - offset)
-    end
-
-    # JRuby doesn't allow Object#instance_eval to yield to the block it's
-    # closed over. This is by design and (ostensibly) something that will
-    # change in MRI, though no current MRI version tested (1.8.6 - 1.9.2)
-    # exhibits the behavior. More info here:
-    #
-    # http://jira.codehaus.org/browse/JRUBY-2599
-    #
-    # We redefine evaluate_source to work around this issues.
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-      undef evaluate_source
-      def evaluate_source(scope, locals, &block)
-        source, offset = precompiled(locals)
-        file, lineno = eval_file, (line - offset)
-        scope.instance_eval { Kernel::eval(source, binding, file, lineno) }
-      end
-    end
-
     def compile_template_method(locals)
       source, offset = precompiled(locals)
-      offset += 5
       method_name = "__tilt_#{Thread.current.object_id.abs}"
-      Object.class_eval <<-RUBY, eval_file, line - offset
+      method_source = <<-RUBY
         #{extract_magic_comment source}
         TOPOBJECT.class_eval do
           def #{method_name}(locals)
@@ -238,12 +220,11 @@ module Tilt
             class << self
               this, locals = Thread.current[:tilt_vars]
               this.instance_eval do
-               #{source}
-              end
-            end
-          end
-        end
       RUBY
+      offset += method_source.count("\n")
+      method_source << source
+      method_source << "\nend;end;end;end"
+      Object.class_eval method_source, eval_file, line - offset
       unbind_compiled_method(method_name)
     end
 
@@ -255,30 +236,10 @@ module Tilt
 
     def extract_magic_comment(script)
       comment = script.slice(/\A[ \t]*\#.*coding\s*[=:]\s*([[:alnum:]\-_]+).*$/)
-      return comment if comment and not %w[ascii-8bit binary].include?($1.downcase)
-      "# coding: #{@default_encoding}" if @default_encoding
-    end
-
-    # Special case Ruby 1.9.1's broken yield.
-    #
-    # http://github.com/rtomayko/tilt/commit/20c01a5
-    # http://redmine.ruby-lang.org/issues/show/3601
-    #
-    # Remove when 1.9.2 dominates 1.9.1 installs in the wild.
-    if RUBY_VERSION =~ /^1.9.1/
-      undef compile_template_method
-      def compile_template_method(locals)
-        source, offset = precompiled(locals)
-        offset += 1
-        method_name = "__tilt_#{Thread.current.object_id}"
-        Object.class_eval <<-RUBY, eval_file, line - offset
-          TOPOBJECT.class_eval do
-            def #{method_name}(locals)
-              #{source}
-            end
-          end
-        RUBY
-        unbind_compiled_method(method_name)
+      if comment && !%w[ascii-8bit binary].include?($1.downcase)
+        comment
+      elsif @default_encoding
+        "# coding: #{@default_encoding}"
       end
     end
   end

data/lib/tilt/textile.rb

@@ -14,12 +14,17 @@ module Tilt
 
     def prepare
       @engine = RedCloth.new(data)
+      options.each {|k, v| @engine.send("#{k}=", v) if @engine.respond_to? "#{k}="}
       @output = nil
     end
 
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_html
     end
+
+    def allows_script?
+      false
+    end
   end
 end
 

data/lib/tilt/wiki.rb

@@ -24,6 +24,10 @@ module Tilt
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_html
     end
+
+    def allows_script?
+      false
+    end
   end
 
   # WikiCloth implementation. See:
@@ -46,5 +50,9 @@ module Tilt
     def evaluate(scope, locals, &block)
       @output ||= @engine.to_html
     end
+
+    def allows_script?
+      false
+    end
   end
 end

data/lib/tilt.rb

@@ -1,5 +1,5 @@
 module Tilt
-  VERSION = '1.3.3'
+  VERSION = '1.3.5'
 
   @preferred_mappings = Hash.new
   @template_mappings = Hash.new { |h, k| h[k] = [] }
@@ -142,6 +142,9 @@ module Tilt
   register ERBTemplate,    'erb', 'rhtml'
   register ErubisTemplate, 'erb', 'rhtml', 'erubis'
 
+  require 'tilt/etanni'
+  register EtanniTemplate, 'etn', 'etanni'
+
   require 'tilt/haml'
   register HamlTemplate,   'haml'
 
@@ -150,6 +153,9 @@ module Tilt
   register ScssTemplate, 'scss'
   register LessTemplate, 'less'
 
+  require 'tilt/csv'
+  register CSVTemplate, 'csv'
+
   require 'tilt/coffee'
   register CoffeeScriptTemplate, 'coffee'
 
@@ -173,6 +179,8 @@ module Tilt
   register KramdownTemplate,  'markdown', 'mkd', 'md'
   register BlueClothTemplate, 'markdown', 'mkd', 'md'
   register RDiscountTemplate, 'markdown', 'mkd', 'md'
+  register RedcarpetTemplate::Redcarpet1, 'markdown', 'mkd', 'md'
+  register RedcarpetTemplate::Redcarpet2, 'markdown', 'mkd', 'md'
   register RedcarpetTemplate, 'markdown', 'mkd', 'md'
 
   require 'tilt/textile'
@@ -187,4 +195,10 @@ module Tilt
 
   require 'tilt/yajl'
   register YajlTemplate, 'yajl'
+
+  require 'tilt/asciidoc'
+  register AsciidoctorTemplate, 'ad', 'adoc', 'asciidoc'
+
+  require 'tilt/plain'
+  register PlainTemplate, 'html'
 end

data/test/tilt_asciidoctor_test.rb

@@ -0,0 +1,44 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'asciidoctor'
+
+  class AsciidoctorTemplateTest < Test::Unit::TestCase
+    HTML5_OUTPUT = "<div class=\"sect1\"><h2 id=\"_hello_world\">Hello World!</h2><div class=\"sectionbody\"></div></div>"
+    DOCBOOK_OUTPUT = "<section id=\"_hello_world\"><title>Hello World!</title></section>"
+
+    def strip_space(str)
+      str.gsub(/>\s+</, '><').strip
+    end
+
+    test "registered for '.ad' files" do
+      assert Tilt.mappings['ad'].include?(Tilt::AsciidoctorTemplate)
+    end
+
+    test "registered for '.adoc' files" do
+      assert Tilt.mappings['adoc'].include?(Tilt::AsciidoctorTemplate)
+    end
+
+    test "registered for '.asciidoc' files" do
+      assert Tilt.mappings['asciidoc'].include?(Tilt::AsciidoctorTemplate)
+    end
+
+    test "preparing and evaluating html5 templates on #render" do
+      template = Tilt::AsciidoctorTemplate.new(:attributes => {"backend" => 'html5'}) { |t| "== Hello World!" } 
+      assert_equal HTML5_OUTPUT, strip_space(template.render)
+    end
+
+    test "preparing and evaluating docbook templates on #render" do
+      template = Tilt::AsciidoctorTemplate.new(:attributes => {"backend" => 'docbook'}) { |t| "== Hello World!" } 
+      assert_equal DOCBOOK_OUTPUT, strip_space(template.render)
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::AsciidoctorTemplate.new(:attributes => {"backend" => 'html5'}) { |t| "== Hello World!" } 
+      3.times { assert_equal HTML5_OUTPUT, strip_space(template.render) }
+    end
+  end
+rescue LoadError => boom
+  warn "Tilt::AsciidoctorTemplate (disabled)"
+end

data/test/tilt_blueclothtemplate_test.rb

@@ -41,5 +41,5 @@ begin
     end
   end
 rescue LoadError => boom
-  warn "Tilt::BlueClothTemplate (disabled)\n"
+  warn "Tilt::BlueClothTemplate (disabled)"
 end

data/test/tilt_coffeescripttemplate_test.rb

@@ -5,10 +5,25 @@ begin
   require 'coffee_script'
 
   class CoffeeScriptTemplateTest < Test::Unit::TestCase
+
+    unless method_defined?(:assert_not_match)
+      # assert_not_match is missing on 1.8.7, which uses assert_no_match
+      def assert_not_match(a, b)
+        unless a.kind_of?(Regexp)
+          a = Regexp.new(Regexp.escape(a))
+        end
+        assert_no_match(a,b)
+      end
+    end
+
     test "is registered for '.coffee' files" do
       assert_equal Tilt::CoffeeScriptTemplate, Tilt['test.coffee']
     end
 
+    test "bare is disabled by default" do
+      assert_equal false, Tilt::CoffeeScriptTemplate.default_bare
+    end
+
     test "compiles and evaluates the template on #render" do
       template = Tilt::CoffeeScriptTemplate.new { |t| "puts 'Hello, World!'\n" }
       assert_match "puts('Hello, World!');", template.render
@@ -20,18 +35,25 @@ begin
     end
 
     test "disabling coffee-script wrapper" do
-      str = "puts 'Hello, World!'\n"
+      str = 'name = "Josh"; puts "Hello #{name}"'
+
+      template = Tilt::CoffeeScriptTemplate.new { str }
+      assert_match "(function() {", template.render
+      assert_match "puts(\"Hello \" + name);\n", template.render
 
       template = Tilt::CoffeeScriptTemplate.new(:bare => true) { str }
-      assert_equal "puts('Hello, World!');", template.render
+      assert_not_match "(function() {", template.render
+      assert_equal "var name;\n\nname = \"Josh\";\n\nputs(\"Hello \" + name);\n", template.render
 
       template2 = Tilt::CoffeeScriptTemplate.new(:no_wrap => true) { str}
-      assert_equal "puts('Hello, World!');", template.render
+      assert_not_match "(function() {", template.render
+      assert_equal "var name;\n\nname = \"Josh\";\n\nputs(\"Hello \" + name);\n", template.render
     end
 
-    context "disabling coffee-script wrapper globally" do
+    context "wrapper globally enabled" do
       setup do
         @bare = Tilt::CoffeeScriptTemplate.default_bare
+        Tilt::CoffeeScriptTemplate.default_bare = false
       end
 
       teardown do
@@ -39,23 +61,54 @@ begin
       end
 
       test "no options" do
-        template = Tilt::CoffeeScriptTemplate.new { |t| "puts 'Hello, World!'\n" }
-        assert_match "puts('Hello, World!');", template.render
+        template = Tilt::CoffeeScriptTemplate.new { |t| 'name = "Josh"; puts "Hello, #{name}"' }
+        assert_match "puts(\"Hello, \" + name);", template.render
         assert_match "(function() {", template.render
       end
 
       test "overridden by :bare" do
-        template = Tilt::CoffeeScriptTemplate.new(:bare => false) { "puts 'Hello, World!'\n" }
-        assert_not_equal "puts('Hello, World!');", template.render
+        template = Tilt::CoffeeScriptTemplate.new(:bare => true) { |t| 'name = "Josh"; puts "Hello, #{name}"' }
+        assert_match "puts(\"Hello, \" + name);", template.render
+        assert_not_match "(function() {", template.render
       end
 
       test "overridden by :no_wrap" do
-        template = Tilt::CoffeeScriptTemplate.new(:no_wrap => false) { "puts 'Hello, World!'\n" }
-        assert_not_equal "puts('Hello, World!');", template.render
+        template = Tilt::CoffeeScriptTemplate.new(:no_wrap => true) { |t| 'name = "Josh"; puts "Hello, #{name}"' }
+        assert_match "puts(\"Hello, \" + name);", template.render
+        assert_not_match "(function() {", template.render
+      end
+    end
+
+    context "wrapper globally disabled" do
+      setup do
+        @bare = Tilt::CoffeeScriptTemplate.default_bare
+        Tilt::CoffeeScriptTemplate.default_bare = true
+      end
+
+      teardown do
+        Tilt::CoffeeScriptTemplate.default_bare = @bare
+      end
+
+      test "no options" do
+        template = Tilt::CoffeeScriptTemplate.new { |t| 'name = "Josh"; puts "Hello, #{name}"' }
+        assert_match "puts(\"Hello, \" + name);", template.render
+        assert_not_match "(function() {", template.render
+      end
+
+      test "overridden by :bare" do
+        template = Tilt::CoffeeScriptTemplate.new(:bare => false) { |t| 'name = "Josh"; puts "Hello, #{name}"' }
+        assert_match "puts(\"Hello, \" + name);", template.render
+        assert_match "(function() {", template.render
+      end
+
+      test "overridden by :no_wrap" do
+        template = Tilt::CoffeeScriptTemplate.new(:no_wrap => false) { |t| 'name = "Josh"; puts "Hello, #{name}"' }
+        assert_match "puts(\"Hello, \" + name);", template.render
+        assert_match "(function() {", template.render
       end
     end
   end
 
 rescue LoadError => boom
-  warn "Tilt::CoffeeScriptTemplate (disabled)\n"
+  warn "Tilt::CoffeeScriptTemplate (disabled)"
 end

data/test/tilt_creoletemplate_test.rb

@@ -24,5 +24,5 @@ begin
     end
   end
 rescue LoadError => boom
-  warn "Tilt::CreoleTemplate (disabled)\n"
+  warn "Tilt::CreoleTemplate (disabled)"
 end

data/test/tilt_csv_test.rb

@@ -0,0 +1,73 @@
+require 'contest'
+require 'tilt'
+
+begin
+  if RUBY_VERSION >= '1.9.0'
+    require 'csv'
+  else
+    require 'fastercsv'
+  end
+
+  class CSVTemplateTest < Test::Unit::TestCase
+
+    test "is registered for '.csv' files" do
+      assert_equal Tilt::CSVTemplate, Tilt['test.csv']
+    end
+
+    test "registered for '.csv' files" do
+      assert Tilt.mappings['csv'].include?(Tilt::CSVTemplate)
+    end
+
+    test "compiles and evaluates the template on #render" do
+      template = Tilt::CSVTemplate.new { "csv << ['hello', 'world']" }
+      assert_equal "hello,world\n", template.render
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::CSVTemplate.new { "csv << [1,2,3]" }
+      3.times { assert_equal "1,2,3\n", template.render }
+    end
+
+    test "can pass locals" do
+      template = Tilt::CSVTemplate.new { 'csv << [1, name]' }
+      assert_equal "1,Joe\n", template.render(Object.new, :name => 'Joe')
+    end
+
+    test "evaluating in an object scope" do
+      template = Tilt::CSVTemplate.new { 'csv << [1, @name]' }
+      scope = Object.new
+      scope.instance_variable_set :@name, 'Joe'
+      assert_equal "1,Joe\n", template.render(scope)
+    end
+
+    test "backtrace file and line reporting" do
+      data = File.read(__FILE__).split("\n__END__\n").last
+      template = Tilt::CSVTemplate.new('test.csv') { data }
+      begin
+        template.render
+        fail 'should have raised an exception'
+      rescue => boom
+        assert_kind_of NameError, boom
+        line = boom.backtrace.grep(/^test\.csv:/).first
+        assert line, "Backtrace didn't contain test.csv"
+        file, line, meth = line.split(":")
+        assert_equal '4', line
+      end
+    end
+
+  end
+
+rescue LoadError => boom
+  warn "Tilt::CSVTemplate (disabled) please install 'fastercsv' if using ruby 1.8.x"
+end
+
+
+__END__
+# header
+csv << ['Type', 'Age']
+
+raise NameError
+
+# rows
+csv << ['Frog', 2]
+csv << ['Cat', 5]

data/test/tilt_erbtemplate_test.rb

@@ -89,6 +89,11 @@ class ERBTemplateTest < Test::Unit::TestCase
     end
   end
 
+  test "explicit disabling of trim mode" do
+    template = Tilt::ERBTemplate.new('test.erb', 1, :trim => false) { "\n<%= 1 + 1 %>\n" }
+    assert_equal "\n2\n", template.render
+  end
+
   test "default stripping trim mode" do
     template = Tilt::ERBTemplate.new('test.erb', 1) { "\n<%= 1 + 1 %>\n" }
     assert_equal "\n2", template.render

data/test/tilt_erubistemplate_test.rb

@@ -137,7 +137,7 @@ begin
     end
   end
 rescue LoadError => boom
-  warn "Tilt::ErubisTemplate (disabled)\n"
+  warn "Tilt::ErubisTemplate (disabled)"
 end
 
 __END__