tilt 1.4.1 → 2.0.11

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/radius.rb

@@ -1,13 +1,10 @@
 require 'tilt/template'
+require 'radius'
 
 module Tilt
   # Radius Template
   # http://github.com/jlong/radius/
   class RadiusTemplate < Template
-    def self.engine_initialized?
-      defined? ::Radius
-    end
-
     def self.context_class
       @context_class ||= Class.new(Radius::Context) do
         attr_accessor :tilt_scope
@@ -24,10 +21,6 @@ module Tilt
       end
     end
 
-    def initialize_engine
-      require_template_library 'radius'
-    end
-
     def prepare
     end
 

data/lib/tilt/rdiscount.rb

@@ -0,0 +1,39 @@
+require 'tilt/template'
+require 'rdiscount'
+
+module Tilt
+  # Discount Markdown implementation. See:
+  # http://github.com/rtomayko/rdiscount
+  #
+  # RDiscount is a simple text filter. It does not support +scope+ or
+  # +locals+. The +:smart+ and +:filter_html+ options may be set true
+  # to enable those flags on the underlying RDiscount object.
+  class RDiscountTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    ALIAS = {
+      :escape_html => :filter_html,
+      :smartypants => :smart
+    }
+
+    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
+
+    def flags
+      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
+    end
+
+    def prepare
+      @engine = RDiscount.new(data, *flags)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+

data/lib/tilt/rdoc.rb

@@ -1,4 +1,7 @@
 require 'tilt/template'
+require 'rdoc'
+require 'rdoc/markup'
+require 'rdoc/markup/to_html'
 
 module Tilt
   # RDoc template. See:
@@ -10,16 +13,6 @@ module Tilt
   class RDocTemplate < Template
     self.default_mime_type = 'text/html'
 
-    def self.engine_initialized?
-      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

data/lib/tilt/redcarpet.rb

@@ -0,0 +1,86 @@
+require 'tilt/template'
+require 'redcarpet'
+
+module Tilt
+  # Compatibility mode for Redcarpet 1.x
+  class Redcarpet1Template < Template
+    self.default_mime_type = 'text/html'
+
+    ALIAS = {
+      :escape_html => :filter_html,
+      :smartypants => :smart
+    }
+
+    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
+
+    def flags
+      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
+    end
+
+    def prepare
+      @engine = RedcarpetCompat.new(data, *flags)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # Future proof mode for Redcarpet 2.x (not yet released)
+  class Redcarpet2Template < Template
+    self.default_mime_type = 'text/html'
+
+    def generate_renderer
+      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
+
+      if renderer == ::Redcarpet::Render::XHTML
+        ::Redcarpet::Render::SmartyHTML.new(:xhtml => true)
+      elsif renderer == ::Redcarpet::Render::HTML
+        ::Redcarpet::Render::SmartyHTML
+      elsif renderer.is_a? Class
+        Class.new(renderer) { include ::Redcarpet::Render::SmartyPants }
+      else
+        renderer.extend ::Redcarpet::Render::SmartyPants
+      end
+    end
+
+    def prepare
+      # try to support the same aliases
+      Redcarpet1Template::ALIAS.each do |opt, aka|
+        next if options.key? opt or not options.key? aka
+        options[opt] = options.delete(aka)
+      end
+
+      # only raise an exception if someone is trying to enable :escape_html
+      options.delete(:escape_html) unless options[:escape_html]
+
+      @engine = ::Redcarpet::Markdown.new(generate_renderer, options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.render(data)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  if defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
+    superclass = Redcarpet2Template
+  else
+    superclass = Redcarpet1Template
+  end
+
+  class RedcarpetTemplate < superclass
+  end
+end
+

data/lib/tilt/{textile.rb → redcloth.rb}

@@ -1,17 +1,10 @@
 require 'tilt/template'
+require 'redcloth'
 
 module Tilt
   # RedCloth implementation. See:
   # http://redcloth.org/
   class RedClothTemplate < Template
-    def self.engine_initialized?
-      defined? ::RedCloth
-    end
-
-    def initialize_engine
-      require_template_library 'redcloth'
-    end
-
     def prepare
       @engine = RedCloth.new(data)
       options.each {|k, v| @engine.send("#{k}=", v) if @engine.respond_to? "#{k}="}

data/lib/tilt/rst-pandoc.rb

@@ -0,0 +1,23 @@
+require 'tilt/template'
+require 'pandoc'
+
+module Tilt
+  # Pandoc reStructuredText implementation. See:
+  # http://pandoc.org/
+  class RstPandocTemplate < PandocTemplate
+    self.default_mime_type = 'text/html'
+
+    def prepare
+      @engine = PandocRuby.new(data, :f => "rst")
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html.strip
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/lib/tilt/sass.rb

@@ -0,0 +1,78 @@
+require 'tilt/template'
+
+module Tilt
+  # Sass template implementation. See:
+  # http://haml.hamptoncatlin.com/
+  #
+  # Sass templates do not support object scopes, locals, or yield.
+  class SassTemplate < Template
+    self.default_mime_type = 'text/css'
+
+    begin
+      require 'sass-embedded'
+      require 'uri'
+      Engine = nil
+    rescue LoadError => err
+      begin
+        require 'sassc'
+        Engine = ::SassC::Engine
+      rescue LoadError
+        begin
+          require 'sass'
+          Engine = ::Sass::Engine
+        rescue LoadError
+          raise err
+        end
+      end
+    end
+
+    def prepare
+      @engine = unless Engine.nil?
+                  Engine.new(data, sass_options)
+                end
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= if @engine.nil?
+                    ::Sass.compile_string(data, **sass_embedded_options).css
+                  else
+                    @engine.render
+                  end
+    end
+
+    def allows_script?
+      false
+    end
+
+  private
+    def eval_file_url
+      path = File.absolute_path(eval_file)
+      path = '/' + path unless path.start_with?('/')
+      ::URI::File.build([nil, ::URI::DEFAULT_PARSER.escape(path)]).to_s
+    end
+
+    def sass_embedded_options
+      options.merge(:url => eval_file_url, :syntax => :indented)
+    end
+
+    def sass_options
+      options.merge(:filename => eval_file, :line => line, :syntax => :sass)
+    end
+  end
+
+  # Sass's new .scss type template implementation.
+  class ScssTemplate < SassTemplate
+    self.default_mime_type = 'text/css'
+
+  private
+    def sass_embedded_options
+      options.merge(:url => eval_file_url, :syntax => :scss)
+    end
+
+    def sass_options
+      options.merge(:filename => eval_file, :line => line, :syntax => :scss)
+    end
+  end
+
+end
+

data/lib/tilt/sigil.rb

@@ -0,0 +1,34 @@
+require 'open3'
+require 'shellwords'
+
+module Tilt
+  # Standalone string interpolator and template processor implementation in Go.
+  # see: https://github.com/gliderlabs/sigil
+  class SigilTemplate < Template
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      variables = locals.map {|k, v| "#{k}=#{v}" }
+
+      cmd = ['sigil']
+
+      unless variables.empty?
+        cmd << '-p'
+        cmd.concat(variables)
+      end
+
+      out, err, status = Open3.capture3(*cmd, :stdin_data => data)
+
+      if status.success?
+        out.chomp
+      else
+        raise err.chomp.gsub('<stdin>', file)
+      end
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/lib/tilt/string.rb

@@ -6,7 +6,7 @@ module Tilt
   class StringTemplate < Template
     def prepare
       hash = "TILT#{data.hash.abs}"
-      @code = "<<#{hash}.chomp\n#{data}\n#{hash}"
+      @code = String.new("<<#{hash}.chomp\n#{data}\n#{hash}")
     end
 
     def precompiled_template(locals)