tilt 2.0.1 → 2.0.2

data/lib/tilt/kramdown.rb

@@ -7,14 +7,6 @@ module Tilt
   class KramdownTemplate < Template
     DUMB_QUOTES = [39, 39, 34, 34]
 
-    def self.engine_initialized?
-      defined? ::Kramdown
-    end
-
-    def initialize_engine
-      require_template_library 'kramdown'
-    end
-
     def prepare
       options[:smart_quotes] = DUMB_QUOTES unless options[:smartypants]
       @engine = Kramdown::Document.new(data, options)

data/lib/tilt/less.rb

@@ -9,14 +9,6 @@ module Tilt
   class LessTemplate < Template
     self.default_mime_type = 'text/css'
 
-    def self.engine_initialized?
-      defined? ::Less
-    end
-
-    def initialize_engine
-      require_template_library 'less'
-    end
-
     def prepare
       if ::Less.const_defined? :Engine
         @engine = ::Less::Engine.new(data)

data/lib/tilt/liquid.rb

@@ -3,7 +3,7 @@ require 'liquid'
 
 module Tilt
   # Liquid template implementation. See:
-  # http://liquid.rubyforge.org/
+  # http://liquidmarkup.org/
   #
   # Liquid is designed to be a *safe* template system and threfore
   # does not provide direct access to execuatable scopes. In order to

data/lib/tilt/plain.rb

@@ -6,10 +6,6 @@ module Tilt
   class PlainTemplate < Template
     self.default_mime_type = 'text/html'
 
-    def self.engine_initialized?
-      true
-    end
-
     def prepare
     end
 

data/lib/tilt/prawn.rb

@@ -0,0 +1,43 @@
+require 'tilt/template'
+require 'prawn'
+
+module Tilt
+  # Prawn template implementation. See: http://prawnpdf.org
+  #
+  class PrawnTemplate < Template
+    self.default_mime_type = 'application/pdf'
+    
+    def prepare
+      @engine = ::Prawn::Document.new(prawn_options)
+    end
+    
+    def evaluate(scope, locals, &block)
+      pdf = @engine
+      if data.respond_to?(:to_str)
+        locals[:pdf] = pdf
+        super(scope, locals, &block)
+      elsif data.kind_of?(Proc)
+        data.call(pdf)
+      end
+      @output ||= pdf.render
+    end
+    
+    def allows_script?
+      false
+    end
+    
+    def precompiled_template(locals)
+      data.to_str
+    end
+    
+    
+    private
+      
+      def prawn_options
+        # defaults to A4 instead of crazy US Letter format. 
+        { :page_size => "A4", :page_layout => :portrait }.merge(options)
+      end
+      
+  end
+  
+end

data/lib/tilt/redcarpet.rb

@@ -35,12 +35,8 @@ module Tilt
   class Redcarpet2Template < Template
     self.default_mime_type = 'text/html'
 
-    def self.engine_initialized?
-      defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
-    end
-
     def generate_renderer
-      renderer = options.delete(:renderer) || ::Redcarpet::Render::HTML
+      renderer = options.delete(:renderer) || ::Redcarpet::Render::HTML.new(options)
       return renderer unless options.delete(:smartypants)
       return renderer if renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants
 
@@ -78,27 +74,10 @@ module Tilt
     end
   end
 
-  # Upskirt Markdown implementation. See:
-  # https://github.com/tanoku/redcarpet
-  #
-  # Supports both Redcarpet 1.x and 2.x
-  class RedcarpetTemplate < Template
-    Redcarpet1 = Redcarpet1Template
-    Redcarpet2 = Redcarpet2Template
-
-    def prepare
-      klass = Redcarpet2.engine_initialized? ? Redcarpet2 : Redcarpet1
-      @engine = klass.new(file, line, options) { data }
-    end
-
-    def evaluate(scope, locals, &block)
-      @engine.evaluate(scope, locals, &block)
-    end
-
-    def allows_script?
-      false
-    end
+  if defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
+    RedcarpetTemplate = Redcarpet2Template
+  else
+    RedcarpetTemplate = Redcarpet1Template
   end
-
 end
 

data/lib/tilt/template.rb

@@ -5,6 +5,8 @@ module Tilt
   TOPOBJECT = Object.superclass || Object
   # @private
   LOCK = Mutex.new
+  # @private
+  SYMBOL_ARRAY_SORTABLE = RUBY_VERSION >= '1.9'
 
   # Base class for template implementations. Subclasses must implement
   # the #prepare method and one of the #evaluate or #precompiled_template
@@ -90,7 +92,8 @@ module Tilt
     # 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)
+    def render(scope=nil, locals={}, &block)
+      scope ||= Object.new
       current_template = Thread.current[:tilt_current_template]
       Thread.current[:tilt_current_template] = self
       evaluate(scope, locals || {}, &block)
@@ -151,7 +154,13 @@ module Tilt
     # This method is only used by source generating templates. Subclasses that
     # override render() may not support all features.
     def evaluate(scope, locals, &block)
-      method = compiled_method(locals.keys)
+      locals_keys = locals.keys
+      if SYMBOL_ARRAY_SORTABLE
+        locals_keys.sort!
+      else
+        locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
+      end
+      method = compiled_method(locals_keys)
       method.bind(scope).call(locals, &block)
     end
 

data/man/index.txt

@@ -0,0 +1,2 @@
+m4(1)        http://man.cx/m4(1)
+mustache(1)  https://mustache.github.io/mustache.1.html

data/man/tilt.1.ronn

@@ -0,0 +1,59 @@
+tilt(1) -- process templates
+============================
+
+## SYNOPSIS
+
+`tilt` `-l`<br>
+`tilt` [`-t` <pattern>] [`-y` <file>] [`-D` <name>=<value>] [`-d` <file>]
+  [`--vars=`<ruby>] <file>
+
+## DESCRIPTION
+
+Process template <file> and write output to stdout. 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 template engines + file patterns and exit
+* `-t`, `--type`=<pattern>:
+  Use this template engine; required if no <file>
+* `-y`, `--layout`=<file>:
+  Use <file> as a layout template
+* `-D`<name>=<value>:
+  Define variable <name> as <value>
+* `-d`, `--define-file`=<file>:
+  Load YAML or JSON from <file> and use for variables
+* `--vars`=<ruby>:
+  Evaluate <ruby> to Hash and use for variables
+* `-h`, `--help`:
+  Show this help message
+
+## EXAMPLES
+
+Convert markdown to HTML:
+
+    $ tilt foo.markdown > foo.html
+
+Process ERB template:
+
+    $ echo "Answer: <%= 2 + 2 %>" | tilt -t erb
+    Answer: 4
+
+Define variables:
+
+    $ echo '{"n":40}' > data.json
+    $ echo "Answer: <%= 2 + n %>" | tilt -t erb -d data.json
+    Answer: 42
+
+    $ echo "Answer: <%= 2 + n %>" | tilt -t erb --vars="{:n=>40}"
+    Answer: 42
+    $ echo "Answer: <%= 2 + n.to_i %>" | tilt -t erb -Dn=40
+    Answer: 42
+
+## SEE ALSO
+
+m4(1), mustache(1)
+
+

data/test/tilt_asciidoctor_test.rb

@@ -6,7 +6,8 @@ begin
 
   class AsciidoctorTemplateTest < Minitest::Test
     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>"
+    DOCBOOK45_OUTPUT = "<section id=\"_hello_world\"><title>Hello World!</title></section>"
+    DOCBOOK5_OUTPUT = "<section xml:id=\"_hello_world\"><title>Hello World!</title></section>"
 
     def strip_space(str)
       str.gsub(/>\s+</, '><').strip
@@ -29,9 +30,14 @@ begin
       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)
+    test "preparing and evaluating docbook 4.5 templates on #render" do
+      template = Tilt::AsciidoctorTemplate.new(:attributes => {"backend" => 'docbook45'}) { |t| "== Hello World!" }
+      assert_equal DOCBOOK45_OUTPUT, strip_space(template.render)
+    end
+
+    test "preparing and evaluating docbook 5 templates on #render" do
+      template = Tilt::AsciidoctorTemplate.new(:attributes => {"backend" => 'docbook5'}) { |t| "== Hello World!" }
+      assert_equal DOCBOOK5_OUTPUT, strip_space(template.render)
     end
 
     test "can be rendered more than once" do

data/test/tilt_babeltemplate.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+require 'tilt'
+
+begin
+  require 'tilt/babel'
+
+  class BabelTemplateTest < Minitest::Test
+    test "registered for '.es6' files" do
+      assert_equal Tilt::BabelTemplate, Tilt['es6']
+    end
+
+    test "registered for '.babel' files" do
+      assert_equal Tilt::BabelTemplate, Tilt['babel']
+    end
+
+    test "registered for '.jsx' files" do
+      assert_equal Tilt::BabelTemplate, Tilt['jsx']
+    end
+
+    test "basic ES6 features" do
+      template = Tilt::BabelTemplate.new { "square = (x) => x * x" }
+      assert_match "function", template.render
+    end
+
+    test "JSX support" do
+      template = Tilt::BabelTemplate.new { "<Awesome ness={true} />" }
+      assert_match "React.createElement", template.render
+    end
+  end
+rescue LoadError => boom
+  warn "Tilt::BabelTemplate (disabled)"
+end
+

data/test/tilt_cache_test.rb

@@ -20,6 +20,17 @@ class TiltCacheTest < Minitest::Test
     assert_same template, result
   end
 
+  test "caching nil" do
+    called = false
+    result = @cache.fetch("blah") {called = true; nil}
+    assert_equal true, called
+    assert_nil result
+    called = false
+    result = @cache.fetch("blah") {called = true; :blah}
+    assert_equal false, called
+    assert_nil result
+  end
+
   test "clearing the cache with #clear" do
     template, other = nil
     result = @cache.fetch('hello') { template = Tilt::StringTemplate.new {''} }

data/test/tilt_coffeescripttemplate_test.rb

@@ -4,98 +4,135 @@ require 'tilt'
 begin
   require 'tilt/coffee'
 
-  class CoffeeScriptTemplateTest < Minitest::Test
-
-    test "is registered for '.coffee' files" do
-      assert_equal Tilt::CoffeeScriptTemplate, Tilt['test.coffee']
+  module CoffeeScriptTests
+    def self.included(mod)
+      mod.class_eval do
+        test "bare is disabled by default" do
+          assert_equal false, @renderer.default_bare
+        end
+
+        test "compiles and evaluates the template on #render" do
+          template = @renderer.new { |t| @code_without_variables }
+          assert_match "puts('Hello, World!');", template.render
+        end
+
+        test "can be rendered more than once" do
+          template = @renderer.new { |t| @code_without_variables }
+          3.times { assert_match "puts('Hello, World!');", template.render }
+        end
+
+        test "disabling coffee-script wrapper" do
+          template = @renderer.new { @code_with_variables }
+          assert_match "(function() {", template.render
+          assert_match "puts(\"Hello, \" + name);\n", template.render
+
+          template = @renderer.new(:bare => true) { @code_with_variables }
+          refute_match "(function() {", template.render
+          assert_equal "var name;\n\nname = \"Josh\";\n\nputs(\"Hello, \" + name);\n", template.render
+
+          template2 = @renderer.new(:no_wrap => true) { @code_with_variables}
+          refute_match "(function() {", template.render
+          assert_equal "var name;\n\nname = \"Josh\";\n\nputs(\"Hello, \" + name);\n", template.render
+        end
+
+        context "wrapper globally enabled" do
+          setup do
+            @bare = @renderer.default_bare
+            @renderer.default_bare = false
+          end
+
+          teardown do
+            @renderer.default_bare = @bare
+          end
+
+          test "no options" do
+            template = @renderer.new { |t| @code_with_variables }
+            assert_match "puts(\"Hello, \" + name);", template.render
+            assert_match "(function() {", template.render
+          end
+
+          test "overridden by :bare" do
+            template = @renderer.new(:bare => true) { |t| @code_with_variables }
+            assert_match "puts(\"Hello, \" + name);", template.render
+            refute_match "(function() {", template.render
+          end
+
+          test "overridden by :no_wrap" do
+            template = @renderer.new(:no_wrap => true) { |t| @code_with_variables }
+            assert_match "puts(\"Hello, \" + name);", template.render
+            refute_match "(function() {", template.render
+          end
+        end
+
+        context "wrapper globally disabled" do
+          setup do
+            @bare = @renderer.default_bare
+            @renderer.default_bare = true
+          end
+
+          teardown do
+            @renderer.default_bare = @bare
+          end
+
+          test "no options" do
+            template = @renderer.new { |t| @code_with_variables }
+            assert_match "puts(\"Hello, \" + name);", template.render
+            refute_match "(function() {", template.render
+          end
+
+          test "overridden by :bare" do
+            template = @renderer.new(:bare => false) { |t| @code_with_variables }
+            assert_match "puts(\"Hello, \" + name);", template.render
+            assert_match "(function() {", template.render
+          end
+
+          test "overridden by :no_wrap" do
+            template = @renderer.new(:no_wrap => false) { |t| @code_with_variables }
+            assert_match "puts(\"Hello, \" + name);", template.render
+            assert_match "(function() {", template.render
+          end
+        end
+      end
     end
+  end
 
-    test "bare is disabled by default" do
-      assert_equal false, Tilt::CoffeeScriptTemplate.default_bare
+  class CoffeeScriptTemplateTest < Minitest::Test
+    setup do
+      @code_without_variables = "puts 'Hello, World!'\n"
+      @code_with_variables = 'name = "Josh"; puts "Hello, #{name}"'
+      @renderer = Tilt::CoffeeScriptTemplate
     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
-    end
+    include CoffeeScriptTests
 
-    test "can be rendered more than once" do
-      template = Tilt::CoffeeScriptTemplate.new { |t| "puts 'Hello, World!'\n" }
-      3.times { assert_match "puts('Hello, World!');", template.render }
+    test "is registered for '.coffee' files" do
+      assert_equal @renderer, Tilt['test.coffee']
     end
+  end
 
-    test "disabling coffee-script wrapper" do
-      str = 'name = "Josh"; puts "Hello #{name}"'
-
-      template = Tilt::CoffeeScriptTemplate.new { str }
-      assert_match "(function() {", template.render
-      assert_match "puts(\"Hello \" + name);\n", template.render
+  class LiterateCoffeeScriptTemplateTest < Minitest::Test
+    setup do
+      @code_without_variables = <<EOLIT
+This is some comment.
 
-      template = Tilt::CoffeeScriptTemplate.new(:bare => true) { str }
-      refute_match "(function() {", template.render
-      assert_equal "var name;\n\nname = \"Josh\";\n\nputs(\"Hello \" + name);\n", template.render
+    puts 'Hello, World!'
 
-      template2 = Tilt::CoffeeScriptTemplate.new(:no_wrap => true) { str}
-      refute_match "(function() {", template.render
-      assert_equal "var name;\n\nname = \"Josh\";\n\nputs(\"Hello \" + name);\n", template.render
-    end
+This is a comment too.
+EOLIT
+      @code_with_variables = <<EOLIT
+This is some comment.
 
-    context "wrapper globally enabled" do
-      setup do
-        @bare = Tilt::CoffeeScriptTemplate.default_bare
-        Tilt::CoffeeScriptTemplate.default_bare = false
-      end
-
-      teardown do
-        Tilt::CoffeeScriptTemplate.default_bare = @bare
-      end
+    name = "Josh"; puts "Hello, \#{name}"
 
-      test "no options" do
-        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 => true) { |t| 'name = "Josh"; puts "Hello, #{name}"' }
-        assert_match "puts(\"Hello, \" + name);", template.render
-        refute_match "(function() {", template.render
-      end
-
-      test "overridden by :no_wrap" do
-        template = Tilt::CoffeeScriptTemplate.new(:no_wrap => true) { |t| 'name = "Josh"; puts "Hello, #{name}"' }
-        assert_match "puts(\"Hello, \" + name);", template.render
-        refute_match "(function() {", template.render
-      end
+This is a comment too.
+EOLIT
+      @renderer = Tilt::CoffeeScriptLiterateTemplate
     end
 
-    context "wrapper globally disabled" do
-      setup do
-        @bare = Tilt::CoffeeScriptTemplate.default_bare
-        Tilt::CoffeeScriptTemplate.default_bare = true
-      end
+    include CoffeeScriptTests
 
-      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
-        refute_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
+    test "is registered for '.litcoffee' files" do
+      assert_equal @renderer, Tilt['test.litcoffee']
     end
   end