tilt 1.3.3 → 1.4.0

data/lib/tilt/plain.rb

@@ -0,0 +1,20 @@
+require 'tilt/template'
+
+
+module Tilt
+  # Raw text (no template functionality).
+  class PlainTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      true
+    end
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= data
+    end
+  end
+end

data/lib/tilt/radius.rb

@@ -47,5 +47,9 @@ module Tilt
       parser = Radius::Parser.new(context, options)
       parser.parse(data)
     end
+
+    def allows_script?
+      false
+    end
   end
 end

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

@@ -1,5 +1,5 @@
 module Tilt
-  TOPOBJECT = defined?(BasicObject) ? BasicObject : Object
+  TOPOBJECT = Object.superclass || Object
 
   # Base class for template implementations. Subclasses must implement
   # the #prepare method and one of the #evaluate or #precompiled_template
@@ -43,6 +43,7 @@ module Tilt
         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.dup
+        when arg.respond_to?(:path)    ; @file = arg.path
         else raise TypeError
         end
       end
@@ -64,11 +65,37 @@ module Tilt
       @default_encoding = @options.delete :default_encoding
 
       # load template data and prepare (uses binread to avoid encoding issues)
-      @reader = block || lambda { |t| File.respond_to?(:binread) ? File.binread(@file) : File.read(@file) }
+      @reader = block || lambda { |t| read_template_file }
       @data = @reader.call(self)
+
+      if @data.respond_to?(:force_encoding)
+        @data.force_encoding(default_encoding) if default_encoding
+
+        if !@data.valid_encoding?
+          raise Encoding::InvalidByteSequenceError, "#{eval_file} is not valid #{@data.encoding}"
+        end
+      end
+
       prepare
     end
 
+    # The encoding of the source data. Defaults to the
+    # default_encoding-option if present. You may override this method
+    # in your template class if you have a better hint of the data's
+    # encoding.
+    def default_encoding
+      @default_encoding
+    end
+
+    def read_template_file
+      data = File.open(file, 'rb') { |io| io.read }
+      if data.respond_to?(:force_encoding)
+        # Set it to the default external (without verifying)
+        data.force_encoding(Encoding.default_external) if Encoding.default_external
+      end
+      data
+    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+.
@@ -91,6 +118,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 +134,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 +159,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
@@ -156,26 +182,29 @@ module Tilt
     def precompiled(locals)
       preamble = precompiled_preamble(locals)
       template = precompiled_template(locals)
-      magic_comment = extract_magic_comment(template)
-      if magic_comment
-        # Magic comment e.g. "# coding: utf-8" has to be in the first line.
-        # So we copy the magic comment to the first line.
-        preamble = magic_comment + "\n" + preamble
+      postamble = precompiled_postamble(locals)
+      source = ''
+
+      # Ensure that our generated source code has the same encoding as the
+      # the source code generated by the template engine.
+      if source.respond_to?(:force_encoding)
+        template_encoding = extract_encoding(template)
+
+        source.force_encoding(template_encoding)
+        template.force_encoding(template_encoding)
       end
-      parts = [
-        preamble,
-        template,
-        precompiled_postamble(locals)
-      ]
-      [parts.join("\n"), preamble.count("\n") + 1]
+
+      source << preamble << "\n" << template << "\n" << postamble
+
+      [source, preamble.count("\n")+1]
     end
 
     # A string containing the (Ruby) source code for the template. The
-    # default Template#evaluate implementation requires either this method
-    # or the #precompiled method be overridden. When defined, the base
-    # Template guarantees correct file/line handling, locals support, custom
-    # scopes, and support for template compilation when the scope object
-    # allows it.
+    # default Template#evaluate implementation requires either this
+    # method or the #precompiled method be overridden. When defined,
+    # the base Template guarantees correct file/line handling, locals
+    # support, custom scopes, proper encoding, and support for template
+    # compilation.
     def precompiled_template(locals)
       raise NotImplementedError
     end
@@ -186,7 +215,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,47 +238,27 @@ module Tilt
     end
 
   private
-    # Evaluate the template source in the context of the scope object.
-    def evaluate_source(scope, locals, &block)
+    def compile_template_method(locals)
       source, offset = precompiled(locals)
-      scope.instance_eval(source, eval_file, line - offset)
-    end
+      method_name = "__tilt_#{Thread.current.object_id.abs}"
+      method_source = ""
 
-    # 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) }
+      if method_source.respond_to?(:force_encoding)
+        method_source.force_encoding(source.encoding) 
       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
-        #{extract_magic_comment source}
+      method_source << <<-RUBY
         TOPOBJECT.class_eval do
           def #{method_name}(locals)
             Thread.current[:tilt_vars] = [self, locals]
             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
 
@@ -253,33 +268,22 @@ module Tilt
       method
     end
 
-    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
+    def extract_encoding(script)
+      extract_magic_comment(script) || script.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)
+    def extract_magic_comment(script)
+      binary script do
+        script[/\A[ \t]*\#.*coding\s*[=:]\s*([[:alnum:]\-_]+).*$/n, 1]
       end
     end
+
+    def binary(string)
+      original_encoding = string.encoding
+      string.force_encoding(Encoding::BINARY)
+      yield
+    ensure
+      string.force_encoding(original_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.4.0'
 
   @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, 'rcsv'
+
   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