RubyGems - tilt - Versions diffs - 2.0.11 → 2.7.0 - Mend

tilt 2.0.11 → 2.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (50) hide show

data/lib/tilt/pipeline.rb ADDED Viewed

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require_relative 'template'
+module Tilt
+  # Superclass used for pipeline templates.  Should not be used directly.
+  class Pipeline < Template
+    def prepare
+      @pipeline = self.class::TEMPLATES.inject(proc{|*| data}) do |data, (klass, ext, options)|
+        proc do |s,l,&sb|
+          options = options
+          if ext_opts = @options[ext]
+            options = options.merge(ext_opts)
+          end
+          klass.new(file, line, options, &proc{|*| data.call(s, l, &sb)}).render(s, l, &sb)
+        end
+      end
+    end
+    def evaluate(scope, locals, &block)
+      @pipeline.call(scope, locals, &block)
+    end
+  end
+end

data/lib/tilt/plain.rb CHANGED Viewed

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

data/lib/tilt/prawn.rb CHANGED Viewed

@@ -1,43 +1,39 @@
-require 'tilt/template'
+# frozen_string_literal: true
+# = Prawn
+#
+# Prawn template implementation.
+#
+# === See also
+#
+# * http://prawnpdf.org
+#
+# === Related module
+#
+# * Tilt::PrawnTemplate
+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)
     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
+      pdf = ::Prawn::Document.new(@options)
+      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 CHANGED Viewed

@@ -1,44 +1,92 @@
-require 'tilt/template'
+# frozen_string_literal: true
+# = Radius (<tt>radius</tt>)
+#
+# {Radius}[http://radius.rubyforge.org] is the template language used by {Radiant CMS}[http://radiantcms.org]. It is
+# a tag language designed to be valid XML/HTML.
+#
+# === Example
+#
+#     <html>
+#     <body>
+#       <h1><r:title /></h1>
+#       <ul class="<r:type />">
+#       <r:repeat times="3">
+#         <li><r:hello />!</li>
+#       </r:repeat>
+#       </ul>
+#       <r:yield />
+#     </body>
+#     </html>
+#
+# === Usage
+#
+# To render a template such as the one above.
+#
+#     scope = OpenStruct.new
+#     scope.title = "Radius Example"
+#     scope.hello = "Hello, World!"
+#
+#     require 'radius'
+#     template = Tilt::RadiusTemplate.new('example.radius', :tag_prefix=>'r')
+#     template.render(scope, :type=>'hlist'){ "Jackpot!" }
+#
+# The result will be:
+#
+#     <html>
+#     <body>
+#       <h1>Radius Example</h1>
+#       <ul class="hlist">
+#         <li>Hello, World!</li>
+#         <li>Hello, World!</li>
+#         <li>Hello, World!</li>
+#       </ul>
+#       Jackpot!
+#     </body>
+#     </html>
+#
+# === See also
+#
+# * {Radius}[http://radius.rubyforge.org]
+# * {Radiant CMS}[http://radiantcms.org]
+#
+# === Related module
+#
+# * Tilt::RadiusTemplate
+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
-        def tag_missing(name, attributes)
-          tilt_scope.__send__(name)
-        end
+    class ContextClass < Radius::Context
+      attr_accessor :tilt_scope
-        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 CHANGED Viewed

@@ -1,39 +1,82 @@
-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'
+# frozen_string_literal: true
-    ALIAS = {
-      :escape_html => :filter_html,
-      :smartypants => :smart
-    }
+# = RDiscount (<tt>markdown</tt>, <tt>md</tt>, <tt>mkd</tt>)
+#
+# Markdown is a lightweight markup language, created by John Gruber
+# and Aaron Swartz. For any markup that is not covered by Markdown’s syntax, HTML
+# is used.  Marking up plain text with Markdown markup is easy and Markdown
+# formatted texts are readable.
+#
+# 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.
+#
+# === Example
+#
+#     Hello Markdown Templates
+#     ========================
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# To wrap a Markdown formatted document with a layout:
+#
+#     layout = Tilt['erb'].new do
+#       "<!doctype html><title></title><%= yield %>"
+#     end
+#     data = Tilt['md'].new { "# hello tilt" }
+#     layout.render { data.render }
+#     # => "<!doctype html><title></title><h1>hello tilt</h1>\n"
+#
+# === Options
+#
+# ==== <tt>:smartypants => true|false</tt>
+#
+# Set <tt>true</tt> to enable [Smarty Pants][smartypants] style punctuation replacement.
+#
+# ==== <tt>:escape_html => true|false</tt>
+#
+# Set <tt>true</tt> disallow raw HTML in Markdown contents. HTML is converted to
+# literal text by escaping <tt><</tt> characters.
+#
+# === See also
+#
+#  * {Markdown Syntax Documentation}[http://daringfireball.net/projects/markdown/syntax]
+#  * [Discount][discount]
+#  * {RDiscount}[http://github.com/rtomayko/rdiscount]
+#
+# -----------------------------------
+#
+# [Discount][discount] is an implementation of the Markdown markup language in C.
+# [RDiscount][rdiscount] is a Ruby wrapper around Discount.
+#
+# All the documentation of {Markdown}[#markdown] applies in addition to the following:
+#
+# === Usage
+#
+# The <tt>Tilt::RDiscountTemplate</tt> class is registered for all files ending in
+# <tt>.markdown</tt>, <tt>.md</tt> or <tt>.mkd</tt> by default with the highest priority. If you
+# specifically want to use RDiscount, it's recommended to use <tt>#prefer</tt>:
+#
+#     Tilt.prefer Tilt::RDiscountTemplate
+#
+# __NOTE:__ It's suggested that your program <tt>require 'rdiscount'</tt> at load time when
+# using this template engine within a threaded environment.
-    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
+require_relative 'template'
+require 'rdiscount'
-    def flags
-      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
-    end
+aliases = {
+  :escape_html => :filter_html,
+  :smartypants => :smart
+}.freeze
-    def prepare
-      @engine = RDiscount.new(data, *flags)
-      @output = nil
-    end
+_flags = [:smart, :filter_html, :smartypants, :escape_html].freeze
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
+Tilt::RDiscountTemplate = Tilt::StaticTemplate.subclass do
+  flags = _flags.select { |flag| @options[flag] }.
+    map! { |flag| aliases[flag] || flag }
-    def allows_script?
-      false
-    end
-  end
+  RDiscount.new(@data, *flags).to_html
 end

data/lib/tilt/rdoc.rb CHANGED Viewed

@@ -1,40 +1,33 @@
-require 'tilt/template'
+# frozen_string_literal: true
+# = RDoc (<tt>rdoc</tt>)
+#
+# {RDoc}[http://rdoc.rubyforge.org] is the simple text markup system that comes with Ruby's standard
+# library.
+#
+# === Example
+#
+#     = Hello RDoc Templates
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# __NOTE:__ It's suggested that your program <tt>require 'rdoc'</tt>,
+# <tt>require 'rdoc/markup'</tt>, and <tt>require 'rdoc/markup/to_html'</tt> at load time
+# when using this template engine in a threaded environment.
+#
+# === See also
+#
+# * {RDoc}[http://rdoc.rubyforge.org]
+# * {RDoc Github}[https://github.com/ruby/rdoc]
+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
+Tilt::RDocTemplate = Tilt::StaticTemplate.subclass do
+  RDoc::Markup::ToHtml.new(RDoc::Options.new, nil).convert(@data).to_s
 end

data/lib/tilt/redcarpet.rb CHANGED Viewed

@@ -1,86 +1,73 @@
-require 'tilt/template'
+# frozen_string_literal: true
+# = Markdown (<tt>markdown</tt>, <tt>md</tt>, <tt>mkd</tt>)
+#
+# {Markdown}[http://daringfireball.net/projects/markdown/syntax] is a
+# lightweight markup language, created by John Gruber and Aaron Swartz.
+# For any markup that is not covered by Markdown’s syntax, HTML is used.
+# Marking up plain text with Markdown markup is easy and Markdown
+# formatted texts are readable.
+#
+# === Example
+#
+#     Hello Markdown Templates
+#     ========================
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# To wrap a Markdown formatted document with a layout:
+#
+#     layout = Tilt['erb'].new do
+#       "<!doctype html><title></title><%= yield %>"
+#     end
+#     data = Tilt['md'].new { "# hello tilt" }
+#     layout.render { data.render }
+#     # => "<!doctype html><title></title><h1>hello tilt</h1>\n"
+#
+# === Options
+#
+# ==== <tt>:smartypants => true|false</tt>
+#
+# Set <tt>true</tt> to enable [Smarty Pants][smartypants] style punctuation replacement.
+#
+# ==== <tt>:escape_html => true|false</tt>
+#
+# Set <tt>true</tt> disallow raw HTML in Markdown contents. HTML is converted to
+# literal text by escaping <tt><</tt> characters.
+#
+# === See also
+#
+# * {Markdown Syntax Documentation}[http://daringfireball.net/projects/markdown/syntax]
+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
-      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
+  # only raise an exception if someone is trying to enable :escape_html
+  @options.delete(:escape_html) unless @options[:escape_html]
+  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 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 CHANGED Viewed

@@ -1,23 +1,40 @@
-require 'tilt/template'
-require 'redcloth'
+# frozen_string_literal: true
-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
+# = Textile (<tt>textile</tt>)
+#
+# Textile is a lightweight markup language originally developed by Dean Allen and
+# billed as a "humane Web text generator". Textile converts its marked-up text
+# input to valid, well-formed XHTML and also inserts character entity references
+# for apostrophes, opening and closing single and double quotation marks,
+# ellipses and em dashes.
+#
+# Textile formatted texts are converted to HTML with the {RedCloth}[http://redcloth.org]
+# engine, which is a Ruby extension written in C.
+#
+# === Example
+#
+#     h1. Hello Textile Templates
+#
+#     Hello World. This is a paragraph.
+#
+# === Usage
+#
+# __NOTE:__ It's suggested that your program <tt>require 'redcloth'</tt> at load time
+# when using this template engine in a threaded environment.
+#
+# === See Also
+#
+# * {RedCloth}[http://redcloth.org]
+# * https://github.com/jgarber/redcloth
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
+require_relative 'template'
+require 'redcloth'
-    def allows_script?
-      false
-    end
+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 CHANGED Viewed

@@ -1,23 +1,33 @@
-require 'tilt/template'
-require 'pandoc'
+# frozen_string_literal: true
-module Tilt
-  # Pandoc reStructuredText implementation. See:
-  # http://pandoc.org/
-  class RstPandocTemplate < PandocTemplate
-    self.default_mime_type = 'text/html'
+# = reStructuredText (<tt>rst</tt>)
+#
+# reStructuredText is a lightweight markup language originally developed by David Goodger,
+# based on StructuredText and Setext. reStructuredText is primarily used for technical
+# documentation in the Python programming language community, e.g. by the
+# {Sphinx}[http://www.sphinx-doc.org/en/stable/rest.html] Python documentation generator.
+#
+# reStructuredText formatted texts are converted to HTML with {Pandoc}[http://pandoc.org/], which
+# is an application written in Haskell, with a Ruby wrapper provided by the
+# {pandoc-ruby}[https://github.com/alphabetum/pandoc-ruby] gem.
+#
+# === Example
+#
+#     Hello Rst Templates
+#     ===================
+#
+#     Hello World. This is a paragraph.
+#
+# === See Also
+#
+# * {Pandoc}[http://pandoc.org/]
+# * {pandoc-ruby}[https://github.com/alphabetum/pandoc-ruby]
-    def prepare
-      @engine = PandocRuby.new(data, :f => "rst")
-      @output = nil
-    end
+require_relative 'template'
+require_relative 'pandoc'
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html.strip
-    end
+rst = {:f => "rst"}.freeze
-    def allows_script?
-      false
-    end
-  end
+Tilt::RstPandocTemplate = Tilt::StaticTemplate.subclass do
+  PandocRuby.new(@data, rst).to_html.strip
 end