tilt 1.4.1 → 2.0.0

data/lib/tilt/css.rb

@@ -1,80 +0,0 @@
-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'
-
-    def self.engine_initialized?
-      defined? ::Sass::Engine
-    end
-
-    def initialize_engine
-      require_template_library 'sass'
-    end
-
-    def prepare
-      @engine = ::Sass::Engine.new(data, sass_options)
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.render
-    end
-
-    def allows_script?
-      false
-    end
-
-  private
-    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_options
-      options.merge(:filename => eval_file, :line => line, :syntax => :scss)
-    end
-  end
-
-   # Lessscss template implementation. See:
-  # http://lesscss.org/
-  #
-  # Less templates do not support object scopes, locals, or yield.
-  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)
-      else
-        parser  = ::Less::Parser.new(options.merge :filename => eval_file, :line => line)
-        @engine = parser.parse(data)
-      end
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_css(options)
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end
-

data/lib/tilt/markdown.rb

@@ -1,214 +0,0 @@
-require 'tilt/template'
-
-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 self.engine_initialized?
-      defined? ::RDiscount
-    end
-
-    def initialize_engine
-      require_template_library 'rdiscount'
-    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
-
-  # Upskirt Markdown implementation. See:
-  # https://github.com/tanoku/redcarpet
-  #
-  # Supports both Redcarpet 1.x and 2.x
-  class RedcarpetTemplate < Template
-    def self.engine_initialized?
-      defined? ::Redcarpet
-    end
-
-    def initialize_engine
-      require_template_library 'redcarpet'
-    end
-
-    def prepare
-      klass = [Redcarpet2, Redcarpet1].detect { |e| e.engine_initialized? }
-      @engine = klass.new(file, line, options) { data }
-    end
-
-    def evaluate(scope, locals, &block)
-      @engine.evaluate(scope, locals, &block)
-    end
-
-    def allows_script?
-      false
-    end
-
-    # Compatibility mode for Redcarpet 1.x
-    class Redcarpet1 < RDiscountTemplate
-      self.default_mime_type = 'text/html'
-
-      def self.engine_initialized?
-        defined? ::RedcarpetCompat
-      end
-
-      def prepare
-        @engine = RedcarpetCompat.new(data, *flags)
-        @output = nil
-      end
-    end
-
-    # Future proof mode for Redcarpet 2.x (not yet released)
-    class Redcarpet2 < 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
-        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
-        RDiscountTemplate::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
-  end
-
-  # BlueCloth Markdown implementation. See:
-  # http://deveiate.org/projects/BlueCloth/
-  class BlueClothTemplate < Template
-    self.default_mime_type = 'text/html'
-
-    def self.engine_initialized?
-      defined? ::BlueCloth
-    end
-
-    def initialize_engine
-      require_template_library 'bluecloth'
-    end
-
-    def prepare
-      @engine = BlueCloth.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:
-  # http://maruku.rubyforge.org/
-  class MarukuTemplate < Template
-    def self.engine_initialized?
-      defined? ::Maruku
-    end
-
-    def initialize_engine
-      require_template_library 'maruku'
-    end
-
-    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
-
-  # Kramdown Markdown implementation. See:
-  # http://kramdown.rubyforge.org/
-  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)
-      @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

@@ -1,58 +0,0 @@
-require 'tilt/template'
-
-module Tilt
-  # Creole implementation. See:
-  # http://www.wikicreole.org/
-  class CreoleTemplate < Template
-    def self.engine_initialized?
-      defined? ::Creole
-    end
-
-    def initialize_engine
-      require_template_library 'creole'
-    end
-
-    def prepare
-      opts = {}
-      [:allowed_schemes, :extensions, :no_escape].each do |k|
-        opts[k] = options[k] if options[k]
-      end
-      @engine = Creole::Parser.new(data, opts)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
-
-  # WikiCloth implementation. See:
-  # http://redcloth.org/
-  class WikiClothTemplate < Template
-    def self.engine_initialized?
-      defined? ::WikiCloth::Parser
-    end
-
-    def initialize_engine
-      require_template_library 'wikicloth'
-    end
-
-    def prepare
-      @parser = options.delete(:parser) || WikiCloth::Parser
-      @engine = @parser.new options.merge(:data => data)
-      @output = nil
-    end
-
-    def evaluate(scope, locals, &block)
-      @output ||= @engine.to_html
-    end
-
-    def allows_script?
-      false
-    end
-  end
-end

data/test/tilt_fallback_test.rb

@@ -1,122 +0,0 @@
-require 'contest'
-require 'tilt'
-
-class TiltFallbackTest < Test::Unit::TestCase
-  class FailTemplate  < Tilt::Template
-    def self.engine_initialized?; false end
-    def prepare;                        end
-
-    def initialize_engine
-      raise LoadError, "can't load #{self.class}"
-    end
-  end
-
-  class WinTemplate < Tilt::Template
-    def self.engine_initialized?; true end
-    def prepare;                       end
-  end
-
-  FailTemplate2 = Class.new(FailTemplate)
-  WinTemplate2  = Class.new(WinTemplate)
-
-  def set_ivar(obj, name, value)
-    obj.instance_variable_set("@#{name}", value)
-  end
-
-  def clear_ivar(obj, name)
-    ivar = "@#{name}"
-    value = obj.instance_variable_get(ivar)
-  ensure
-    obj.instance_variable_set(ivar, value.dup.clear)
-  end
-
-  setup do
-    # Make sure every test have no mappings.
-    @p = clear_ivar(Tilt, :preferred_mappings)
-    @t = clear_ivar(Tilt, :template_mappings)
-  end
-
-  teardown do
-    set_ivar(Tilt, :preferred_mappings, @p)
-    set_ivar(Tilt, :template_mappings, @t)
-  end
-
-  test "returns nil on unregistered extensions" do
-    template = Tilt["md"]
-    assert_equal nil, template
-  end
-
-  test "returns the last registered template" do
-    Tilt.register("md", WinTemplate)
-    Tilt.register("md", WinTemplate2)
-
-    template = Tilt["md"]
-    assert_equal WinTemplate2, template
-  end
-
-  test "returns the last registered working template" do
-    Tilt.register("md", WinTemplate)
-    Tilt.register("md", FailTemplate)
-
-    template = Tilt["md"]
-    assert_equal WinTemplate, template
-  end
-
-  test "if every template fails, raise the exception from the first template" do
-    Tilt.register("md", FailTemplate)
-    Tilt.register("md", FailTemplate2)
-
-    exc = assert_raise(LoadError) { Tilt["md"] }
-    assert_match /FailTemplate2/, exc.message
-  end
-
-  test ".prefer should also register the template" do
-    Tilt.prefer(WinTemplate, "md")
-    assert Tilt.registered?("md")
-  end
-
-  test ".prefer always win" do
-    Tilt.register("md", FailTemplate)
-    Tilt.register("md", WinTemplate)
-    Tilt.prefer(FailTemplate, "md")
-
-    template = Tilt["md"]
-    assert_equal FailTemplate, template
-  end
-
-  test ".prefer accepts multiple extensions" do
-    extensions = %w[md mkd markdown]
-    Tilt.prefer(FailTemplate, *extensions)
-
-    extensions.each do |ext|
-      template = Tilt[ext]
-      assert_equal FailTemplate, template
-    end
-  end
-
-  test ".prefer with no extension should use already registered extensions" do
-    extensions = %w[md mkd markdown]
-
-    extensions.each do |ext|
-      Tilt.register(ext, FailTemplate)
-      Tilt.register(ext, WinTemplate)
-    end
-
-    Tilt.prefer(FailTemplate)
-
-    extensions.each do |ext|
-      template = Tilt[ext]
-      assert_equal FailTemplate, template
-    end
-  end
-
-  test ".prefer should only override extensions the preferred library is registered for"  do
-    Tilt.register("md", WinTemplate)
-    Tilt.register("mkd", FailTemplate)
-    Tilt.register("mkd", WinTemplate)
-    Tilt.prefer(FailTemplate)
-    assert_equal FailTemplate, Tilt["mkd"]
-    assert_equal WinTemplate, Tilt["md"]
-  end
-end
-