tilt 2.1.0 → 2.3.0

data/lib/tilt/maruku.rb

@@ -1,22 +1,8 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'maruku'
 
-module Tilt
-  # Maruku markdown implementation. See:
-  # http://maruku.rubyforge.org/
-  class MarukuTemplate < Template
-    def prepare
-      @engine = Maruku.new(data, options)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
+# Maruku markdown implementation. See: https://github.com/bhollis/maruku
+Tilt::MarukuTemplate = Tilt::StaticTemplate.subclass do
+  Maruku.new(@data, @options).to_html
 end
-

data/lib/tilt/nokogiri.rb

@@ -1,21 +1,23 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'nokogiri'
 
 module Tilt
   # Nokogiri template implementation. See:
   # http://nokogiri.org/
   class NokogiriTemplate < Template
-    DOCUMENT_HEADER = /^<\?xml version=\"1\.0\"\?>\n?/
+    DOCUMENT_HEADER = /\A<\?xml version=\"1\.0\"\?>\n?/
     self.default_mime_type = 'text/xml'
 
-    def prepare; end
-
     def evaluate(scope, locals)
-      if data.respond_to?(:to_str)
-        wrapper = proc { yield.sub(DOCUMENT_HEADER, "") } if block_given?
-        super(scope, locals, &wrapper)
+      if @data.respond_to?(:to_str)
+        if block_given?
+          super(scope, locals){yield.sub(DOCUMENT_HEADER, "")}
+        else
+          super
+        end
       else
-        ::Nokogiri::XML::Builder.new.tap(&data).to_xml
+        ::Nokogiri::XML::Builder.new(&@data).to_xml
       end
     end
 
@@ -29,8 +31,7 @@ module Tilt
     end
 
     def precompiled_template(locals)
-      data.to_str
+      @data.to_str
     end
   end
 end
-

data/lib/tilt/pandoc.rb

@@ -1,57 +1,39 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'pandoc-ruby'
 
-module Tilt
-  # Pandoc markdown implementation. See:
-  # http://pandoc.org/
-  class PandocTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    # turn options hash into an array
-    # Map tilt options to pandoc options
-    # Replace hash keys with value true with symbol for key
-    # Remove hash keys with value false
-    # Leave other hash keys untouched
-    def pandoc_options
-      result = []
-      from = "markdown"
-      smart_extension = "-smart"
-      options.each do |k,v|
-        case k
-        when :smartypants
-          smart_extension = "+smart" if v
-        when :escape_html
-          from = "markdown-raw_html" if v
-        when :commonmark
-          from = "commonmark" if v
-        when :markdown_strict
-          from = "markdown_strict" if v
-        else
-          case v
-          when true
-            result << k
-          when false
-            # do nothing
-          else
-            result << { k => v }
-          end
-        end
+# Pandoc markdown implementation. See: http://pandoc.org/
+Tilt::PandocTemplate = Tilt::StaticTemplate.subclass do
+  # turn options hash into an array
+  # Map tilt options to pandoc options
+  # Replace hash keys with value true with symbol for key
+  # Remove hash keys with value false
+  # Leave other hash keys untouched
+  pandoc_options = []
+  from = "markdown"
+  smart_extension = "-smart"
+  @options.each do |k,v|
+    case k
+    when :smartypants
+      smart_extension = "+smart" if v
+    when :escape_html
+      from = "markdown-raw_html" if v
+    when :commonmark
+      from = "commonmark" if v
+    when :markdown_strict
+      from = "markdown_strict" if v
+    else
+      case v
+      when true
+        pandoc_options << k
+      when false
+        # do nothing
+      else
+        pandoc_options << { k => v }
       end
-      result << { :f => from + smart_extension }
-      result
-    end
-
-    def prepare
-      @engine = PandocRuby.new(data, *pandoc_options)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html.strip
-    end
-
-    def allows_script?
-      false
     end
   end
+  pandoc_options << { :f => from + smart_extension }
+
+  PandocRuby.new(@data, *pandoc_options).to_html.strip
 end

data/lib/tilt/pipeline.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'template'
 
 module Tilt

data/lib/tilt/plain.rb

@@ -1,16 +1,5 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 
-
-module Tilt
-  # Raw text (no template functionality).
-  class PlainTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    def prepare
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= data
-    end
-  end
-end
+# Raw text (no template functionality).
+Tilt::PlainTemplate = Tilt::StaticTemplate.subclass{@data}

data/lib/tilt/prawn.rb

@@ -1,43 +1,28 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative '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)
+      @options[:page_size] = 'A4' unless @options.has_key?(:page_size)
+      @options[:page_layout] = :portrait unless @options.has_key?(:page_layout)
+      @engine = ::Prawn::Document.new(@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
+      locals = locals.dup
+      locals[:pdf] = pdf
+      super
+      pdf.render
     end
     
     def precompiled_template(locals)
-      data.to_str
+      @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,44 +1,37 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'radius'
 
 module Tilt
   # Radius Template
   # http://github.com/jlong/radius/
   class RadiusTemplate < Template
-    def self.context_class
-      @context_class ||= Class.new(Radius::Context) do
-        attr_accessor :tilt_scope
+    class ContextClass < Radius::Context
+      attr_accessor :tilt_scope
 
-        def tag_missing(name, attributes)
-          tilt_scope.__send__(name)
-        end
-
-        def dup
-          i = super
-          i.tilt_scope = tilt_scope
-          i
-        end
+      def tag_missing(name, attributes)
+        tilt_scope.__send__(name)
       end
-    end
 
-    def prepare
+      def dup
+        i = super
+        i.tilt_scope = tilt_scope
+        i
+      end
     end
 
     def evaluate(scope, locals, &block)
-      context = self.class.context_class.new
+      context = ContextClass.new
       context.tilt_scope = scope
-      context.define_tag("yield") do
-        block.call
-      end
+      context.define_tag("yield", &block) if block
       locals.each do |tag, value|
         context.define_tag(tag) do
           value
         end
       end
 
-      options = {:tag_prefix => 'r'}.merge(@options)
-      parser = Radius::Parser.new(context, options)
-      parser.parse(data)
+      @options[:tag_prefix] = 'r' unless @options.has_key?(:tag_prefix)
+      Radius::Parser.new(context, @options).parse(@data)
     end
 
     def allows_script?

data/lib/tilt/rdiscount.rb

@@ -1,39 +1,23 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative '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'
+aliases = {
+  :escape_html => :filter_html,
+  :smartypants => :smart
+}.freeze
 
-    ALIAS = {
-      :escape_html => :filter_html,
-      :smartypants => :smart
-    }
+_flags = [:smart, :filter_html, :smartypants, :escape_html].freeze
 
-    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
+# 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.
+Tilt::RDiscountTemplate = Tilt::StaticTemplate.subclass do
+  flags = _flags.select { |flag| @options[flag] }.
+    map! { |flag| aliases[flag] || flag }
 
-    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
+  RDiscount.new(@data, *flags).to_html
 end
-

data/lib/tilt/rdoc.rb

@@ -1,40 +1,19 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'rdoc'
 require 'rdoc/markup'
 require 'rdoc/markup/to_html'
+require 'rdoc/options'
 
-module Tilt
-  # RDoc template. See:
-  # http://rdoc.rubyforge.org/
-  #
-  # 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 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
-      @engine = markup.convert(data)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_s
-    end
-
-    def allows_script?
-      false
-    end
-  end
+# RDoc template. See: https://github.com/ruby/rdoc
+#
+# It's suggested that your program run the following at load time when
+# using this templae engine in a threaded environment:
+#
+#   require 'rdoc'
+#   require 'rdoc/markup'
+#   require 'rdoc/markup/to_html'
+#   require 'rdoc/options'
+Tilt::RDocTemplate = Tilt::StaticTemplate.subclass do
+  RDoc::Markup::ToHtml.new(RDoc::Options.new, nil).convert(@data).to_s
 end

data/lib/tilt/redcarpet.rb

@@ -1,86 +1,31 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'redcarpet'
 
-module Tilt
-  # Compatibility mode for Redcarpet 1.x
-  class Redcarpet1Template < Template
-    self.default_mime_type = 'text/html'
+aliases = {:escape_html => :filter_html, :smartypants => :smart}.freeze
 
-    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
+Tilt::RedcarpetTemplate = Tilt::StaticTemplate.subclass do
+  aliases.each do |opt, aka|
+    if options.key?(aka) || !@options.key?(opt)
+      @options[opt] = @options.delete(aka)
     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
+  # only raise an exception if someone is trying to enable :escape_html
+  @options.delete(:escape_html) unless @options[:escape_html]
 
-      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
+  renderer = @options.delete(:renderer) || ::Redcarpet::Render::HTML.new(@options)
+  if options.delete(:smartypants) && !(renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants)
+    renderer = 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
-
-    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
+  Redcarpet::Markdown.new(renderer, @options).render(@data)
 end
-

data/lib/tilt/redcloth.rb

@@ -1,23 +1,13 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require 'redcloth'
 
-module Tilt
-  # RedCloth implementation. See:
-  # http://redcloth.org/
-  class RedClothTemplate < Template
-    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
+# RedCloth implementation. See: https://github.com/jgarber/redcloth
+Tilt::RedClothTemplate = Tilt::StaticTemplate.subclass do
+  engine = RedCloth.new(@data)
+  @options.each  do |k, v|
+    m = :"#{k}="
+    engine.send(m, v) if engine.respond_to? m
   end
+  engine.to_html
 end
-

data/lib/tilt/rst-pandoc.rb

@@ -1,23 +1,10 @@
-require 'tilt/template'
+# frozen_string_literal: true
+require_relative 'template'
 require_relative 'pandoc'
 
-module Tilt
-  # Pandoc reStructuredText implementation. See:
-  # http://pandoc.org/
-  class RstPandocTemplate < PandocTemplate
-    self.default_mime_type = 'text/html'
+rst = {:f => "rst"}.freeze
 
-    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
+# Pandoc reStructuredText implementation. See: # http://pandoc.org/
+Tilt::RstPandocTemplate = Tilt::StaticTemplate.subclass do
+  PandocRuby.new(@data, rst).to_html.strip
 end