tilt 2.0.9 → 2.0.10

data/test/tilt_markdown_test.rb

@@ -1,186 +0,0 @@
-# coding: UTF-8
-require 'tilt'
-require 'test_helper'
-
-begin
-require 'nokogiri'
-
-module MarkdownTests
-  def self.included(mod)
-    class << mod
-      def template(t = nil)
-        t.nil? ? @template : @template = t
-      end
-    end
-  end
-
-  def render(text, options = {})
-    self.class.template.new(options) { text }.render
-  end
-
-  def normalize(html)
-    Nokogiri::HTML.fragment(html).to_s.strip
-  end
-
-  def nrender(text, options = {})
-    html = render(text, options)
-    html.encode!("UTF-8") if html.respond_to?(:encode)
-    normalize(html)
-  end
-
-  def test_escape_html
-    html = nrender "Hello <b>World</b>"
-    assert_equal "<p>Hello <b>World</b></p>", html
-  end
-
-  def test_escape_html_false
-    html = nrender "Hello <b>World</b>", :escape_html => false
-    assert_equal "<p>Hello <b>World</b></p>", html
-  end
-
-  def test_escape_html_true
-    html = nrender "Hello <b>World</b>", :escape_html => true
-    assert_equal "<p>Hello &lt;b&gt;World&lt;/b&gt;</p>", html
-  end
-
-  def test_smart_quotes
-    html = nrender 'Hello "World"'
-    assert_equal '<p>Hello "World"</p>', html
-  end
-
-  def test_smart_quotes_false
-    html = nrender 'Hello "World"', :smartypants => false
-    assert_equal '<p>Hello "World"</p>', html
-  end
-
-  def test_smart_quotes_true
-    html = nrender 'Hello "World"', :smartypants => true
-    assert_equal '<p>Hello “World”</p>', html
-  end
-
-  def test_smarty_pants
-    html = nrender "Hello ``World'' -- This is --- a test ..."
-    assert_equal "<p>Hello ``World'' -- This is --- a test ...</p>", html
-  end
-
-  def test_smarty_pants_false
-    html = nrender "Hello ``World'' -- This is --- a test ...", :smartypants => false
-    assert_equal "<p>Hello ``World'' -- This is --- a test ...</p>", html
-  end
-end
-
-begin
-  require 'tilt/rdiscount'
-
-  class MarkdownRDiscountTest < Minitest::Test
-    include MarkdownTests
-    template Tilt::RDiscountTemplate
-
-    def test_smarty_pants_true
-      html = nrender "Hello ``World'' -- This is --- a test ...", :smartypants => true
-      assert_equal "<p>Hello “World” – This is — a test …</p>", html
-    end
-  end
-rescue LoadError => boom
-  # It should already be warned in the main tests
-end
-
-begin
-  require 'tilt/redcarpet'
-
-  class MarkdownRedcarpetTest < Minitest::Test
-    include MarkdownTests
-    template Tilt::RedcarpetTemplate
-
-    def test_smarty_pants_true
-      # Various versions of Redcarpet support various versions of Smart pants.
-      html = nrender "Hello ``World'' -- This is --- a test ...", :smartypants => true
-      assert_match %r!<p>Hello “World(''|”) – This is — a test …<\/p>!, html
-    end
-
-    def test_renderer_options
-      html = nrender "Hello [World](http://example.com)", :smartypants => true, :no_links => true
-      assert_equal "<p>Hello [World](http://example.com)</p>", html
-    end
-
-    def test_fenced_code_blocks_with_lang
-      code = <<-COD.gsub(/^\s+/,"")
-      ```ruby
-      puts "hello world"
-      ```
-      COD
-
-      html = nrender code, :fenced_code_blocks => true
-      assert_equal %Q{<pre><code class="ruby">puts "hello world"\n</code></pre>}, html
-    end
-  end
-rescue LoadError => boom
-  # It should already be warned in the main tests
-end
-
-begin
-  require 'tilt/bluecloth'
-
-  class MarkdownBlueClothTest < Minitest::Test
-    include MarkdownTests
-    template Tilt::BlueClothTemplate
-
-    def test_smarty_pants_true
-      html = nrender "Hello ``World'' -- This is --- a test ...", :smartypants => true
-      assert_equal "<p>Hello “World” — This is —– a test …</p>", html
-    end
-  end
-rescue LoadError => boom
-  # It should already be warned in the main tests
-end
-
-begin
-  require 'tilt/kramdown'
-
-  class MarkdownKramdownTest < Minitest::Test
-    include MarkdownTests
-    template Tilt::KramdownTemplate
-    # Doesn't support escaping
-    undef test_escape_html_true
-    # Smarty Pants is *always* on, but doesn't support it fully
-    undef test_smarty_pants
-    undef test_smarty_pants_false
-  end
-rescue LoadError => boom
-  # It should already be warned in the main tests
-end
-
-
-begin
-  require 'tilt/maruku'
-
-  class MarkdownMarukuTest < Minitest::Test
-    include MarkdownTests
-    template Tilt::MarukuTemplate
-    # Doesn't support escaping
-    undef test_escape_html_true
-    # Doesn't support Smarty Pants, and even fails on ``Foobar''
-    undef test_smarty_pants
-    undef test_smarty_pants_false
-    # Smart Quotes is always on
-    undef test_smart_quotes
-    undef test_smart_quotes_false
-  end
-rescue LoadError => boom
-  # It should already be warned in the main tests
-end
-
-rescue LoadError
-  warn "Markdown tests need Nokogiri"
-end
-
-begin
-  require 'tilt/pandoc'
-
-  class MarkdownPandocTest < Minitest::Test
-    include MarkdownTests
-    template Tilt::PandocTemplate
-  end
-rescue LoadError => boom
-  # It should already be warned in the main tests
-end

data/test/tilt_marukutemplate_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-require 'tilt'
-
-begin
-  require 'tilt/maruku'
-
-  class MarukuTemplateTest < Minitest::Test
-    test "registered below Kramdown" do
-      %w[md mkd markdown].each do |ext|
-        lazy = Tilt.lazy_map[ext]
-        kram_idx = lazy.index { |klass, file| klass == 'Tilt::KramdownTemplate' }
-        maru_idx = lazy.index { |klass, file| klass == 'Tilt::MarukuTemplate' }
-        assert maru_idx > kram_idx,
-          "#{maru_idx} should be higher than #{kram_idx}"
-      end
-    end
-
-    test "preparing and evaluating templates on #render" do
-      template = Tilt::MarukuTemplate.new { |t| "# Hello World!" }
-      assert_equal "<h1 id=\"hello_world\">Hello World!</h1>", template.render.strip
-    end
-
-    test "can be rendered more than once" do
-      template = Tilt::MarukuTemplate.new { |t| "# Hello World!" }
-      3.times { assert_equal "<h1 id=\"hello_world\">Hello World!</h1>", template.render.strip }
-    end
-
-    test "removes HTML when :filter_html is set" do
-      template = Tilt::MarukuTemplate.new(:filter_html => true) { |t|
-        "HELLO <blink>WORLD</blink>" }
-      assert_equal "<p>HELLO</p>", template.render.strip
-    end
-  end
-rescue LoadError
-  warn "Tilt::MarukuTemplate (disabled)"
-end

data/test/tilt_metadata_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-require 'tilt/template'
-
-module Tilt
-  class TemplateMetadataTest < Minitest::Test
-    class MyTemplate < Template
-      metadata[:global] = 1
-      self.default_mime_type = 'text/html'
-
-      def prepare
-      end
-
-      def allows_script?
-        true
-      end
-    end
-
-    test "global metadata" do
-      assert MyTemplate.metadata
-      assert_equal 1, MyTemplate.metadata[:global]
-    end
-
-    test "instance metadata" do
-      tmpl = MyTemplate.new { '' }
-      assert_equal 1, tmpl.metadata[:global]
-    end
-
-    test "gracefully handles default_mime_type" do
-      assert_equal 'text/html', MyTemplate.metadata[:mime_type]
-    end
-
-    test "still allows .default_mime_type" do
-      assert_equal 'text/html', MyTemplate.default_mime_type
-    end
-
-    test "gracefully handles allows_script?" do
-      tmpl = MyTemplate.new { '' }
-      assert_equal true, tmpl.metadata[:allows_script]
-    end
-  end
-end
-

data/test/tilt_nokogiritemplate_test.rb

@@ -1,87 +0,0 @@
-require 'test_helper'
-require 'tilt'
-
-begin
-  require 'tilt/nokogiri'
-  class NokogiriTemplateTest < Minitest::Test
-    test "registered for '.nokogiri' files" do
-      assert_equal Tilt::NokogiriTemplate, Tilt['test.nokogiri']
-      assert_equal Tilt::NokogiriTemplate, Tilt['test.xml.nokogiri']
-    end
-
-    test "preparing and evaluating the template on #render" do
-      template = Tilt::NokogiriTemplate.new { |t| "xml.em 'Hello World!'" }
-      doc = Nokogiri.XML template.render
-      assert_equal 'Hello World!', doc.root.text
-      assert_equal 'em', doc.root.name
-    end
-
-    test "can be rendered more than once" do
-      template = Tilt::NokogiriTemplate.new { |t| "xml.em 'Hello World!'" }
-      3.times do
-        doc = Nokogiri.XML template.render
-        assert_equal 'Hello World!', doc.root.text
-        assert_equal 'em', doc.root.name
-      end
-    end
-
-    test "passing locals" do
-      template = Tilt::NokogiriTemplate.new { "xml.em('Hey ' + name + '!')" }
-      doc = Nokogiri.XML template.render(Object.new, :name => 'Joe')
-      assert_equal 'Hey Joe!', doc.root.text
-      assert_equal 'em', doc.root.name
-    end
-
-    test "evaluating in an object scope" do
-      template = Tilt::NokogiriTemplate.new { "xml.em('Hey ' + @name + '!')" }
-      scope = Object.new
-      scope.instance_variable_set :@name, 'Joe'
-      doc = Nokogiri.XML template.render(scope)
-      assert_equal 'Hey Joe!', doc.root.text
-      assert_equal 'em', doc.root.name
-    end
-
-    test "passing a block for yield" do
-      template = Tilt::NokogiriTemplate.new { "xml.em('Hey ' + yield + '!')" }
-      3.times do
-        doc = Nokogiri.XML template.render { 'Joe' }
-        assert_equal 'Hey Joe!', doc.root.text
-        assert_equal 'em', doc.root.name
-      end
-    end
-
-    test "block style templates" do
-      template =
-        Tilt::NokogiriTemplate.new do |t|
-          lambda { |xml| xml.em('Hey Joe!') }
-        end
-      doc = Nokogiri.XML template.render
-      assert_equal 'Hey Joe!', doc.root.text
-      assert_equal 'em', doc.root.name
-    end
-
-    test "allows nesting raw XML, API-compatible to Builder" do
-      subtemplate = Tilt::NokogiriTemplate.new { "xml.em 'Hello World!'" }
-      template = Tilt::NokogiriTemplate.new { "xml.strong { xml << yield }" }
-      3.times do
-        options = { :xml => Nokogiri::XML::Builder.new }
-        doc = Nokogiri.XML(template.render(options) { subtemplate.render(options) })
-        assert_equal 'Hello World!', doc.root.text.strip
-        assert_equal 'strong', doc.root.name
-      end
-    end
-
-    test "doesn't modify self when template is a string" do
-      template = Tilt::NokogiriTemplate.new { "xml.root { xml.child @hello }" }
-      scope = Object.new
-      scope.instance_variable_set(:@hello, "Hello World!")
-
-      3.times do
-        doc = Nokogiri.XML(template.render(scope))
-        assert_equal "Hello World!", doc.text.strip
-      end
-    end
-  end
-rescue LoadError
-  warn "Tilt::NokogiriTemplate (disabled)"
-end

data/test/tilt_pandoctemplate_test.rb

@@ -1,67 +0,0 @@
-# encoding: utf-8
-
-require 'test_helper'
-require 'tilt'
-
-begin
-  require 'tilt/pandoc'
-
-  class PandocTemplateTest < Minitest::Test
-    test "preparing and evaluating templates on #render" do
-      template = Tilt::PandocTemplate.new { |t| "# Hello World!" }
-      assert_equal "<h1 id=\"hello-world\">Hello World!</h1>", template.render
-    end
-
-    test "can be rendered more than once" do
-      template = Tilt::PandocTemplate.new { |t| "# Hello World!" }
-      3.times { assert_equal "<h1 id=\"hello-world\">Hello World!</h1>", template.render }
-    end
-
-    test "smartypants when :smartypants is set" do
-      template = Tilt::PandocTemplate.new(:smartypants => true) { |t| "OKAY -- 'Smarty Pants'" }
-      assert_equal "<p>OKAY – ‘Smarty Pants’</p>", template.render
-    end
-
-    test "stripping HTML when :escape_html is set" do
-      template = Tilt::PandocTemplate.new(:escape_html => true) { |t| "HELLO <blink>WORLD</blink>" }
-      assert_equal "<p>HELLO &lt;blink&gt;WORLD&lt;/blink&gt;</p>", template.render
-    end
-
-    # Pandoc has tons of additional markdown features (see http://pandoc.org/README.html#pandocs-markdown).
-    # The test for footnotes should be seen as a general representation for all of them.
-    # use markdown_strict => true to disable additional markdown features
-    describe "passing in Pandoc options" do
-      test "generates footnotes" do
-        template = Tilt::PandocTemplate.new { |t| "Here is an inline note.^[Inlines notes are cool!]" }
-        assert_equal "<p>Here is an inline note.<a href=\"#fn1\" class=\"footnoteRef\" id=\"fnref1\"><sup>1</sup></a></p>\n<div class=\"footnotes\">\n<hr />\n<ol>\n<li id=\"fn1\"><p>Inlines notes are cool!<a href=\"#fnref1\">↩</a></p></li>\n</ol>\n</div>", template.render
-      end
-
-      test "doesn't generate footnotes with markdown_strict option" do
-        template = Tilt::PandocTemplate.new(:markdown_strict => true) { |t| "Here is an inline note.^[Inlines notes are cool!]" }
-        assert_equal "<p>Here is an inline note.^[Inlines notes are cool!]</p>", template.render
-      end
-
-      test "doesn't generate footnotes with commonmark option" do
-        template = Tilt::PandocTemplate.new(:commonmark => true) { |t| "Here is an inline note.^[Inlines notes are cool!]" }
-        assert_equal "<p>Here is an inline note.^[Inlines notes are cool!]</p>", template.render
-      end
-
-      test "accepts arguments with values (e.g. :id_prefix => 'xyz')" do
-        # Table of contents isn't on by default
-        template = Tilt::PandocTemplate.new { |t| "# This is a heading" }
-        assert_equal "<h1 id=\"this-is-a-heading\">This is a heading</h1>", template.render
-
-        # But it can be activated
-        template = Tilt::PandocTemplate.new(:id_prefix => 'test-') { |t| "# This is a heading" }
-        assert_equal "<h1 id=\"test-this-is-a-heading\">This is a heading</h1>", template.render
-      end
-
-      test "requires arguments without value (e.g. --standalone) to be passed as hash keys (:standalone => true)" do
-        template = Tilt::PandocTemplate.new(:standalone => true) { |t| "# This is a heading" }
-        assert_match(/^<!DOCTYPE html.*<h1 id="this-is-a-heading">This is a heading<\/h1>.*<\/html>$/m, template.render)
-      end
-    end
-  end
-rescue LoadError
-  warn "Tilt::PandocTemplate (disabled)"
-end

data/test/tilt_prawntemplate.prawn

@@ -1 +0,0 @@
-pdf.text "Hello Template!"

data/test/tilt_prawntemplate_test.rb

@@ -1,75 +0,0 @@
-require 'test_helper'
-require 'tilt'
-
-begin
-  require 'tilt/prawn'
-  require 'pdf-reader'
-
-  class PdfOutput
-    def initialize(pdf_raw)
-      @reader = PDF::Reader.new(StringIO.new(pdf_raw))
-    end
-    
-    def text
-      @reader.pages.map(&:text).join
-    end
-    
-    def page_attributes(page_num=1)
-      @reader.page(page_num).attributes
-    end
-  end
-
-  class PrawnTemplateTest < Minitest::Test
-    test "is registered for '.prawn' files" do
-      assert_equal Tilt::PrawnTemplate, Tilt['test.prawn']
-    end
-
-    test "compiles and evaluates the template on #render" do
-      template = Tilt::PrawnTemplate.new { |t| "pdf.text \"Hello PDF!\"" }
-      output   = PdfOutput.new(template.render)
-      assert_includes output.text, "Hello PDF!"
-    end
-    
-    test "can be rendered more than once" do
-      template = Tilt::PrawnTemplate.new { |t| "pdf.text \"Hello PDF!\"" }
-      3.times do
-        output   = PdfOutput.new(template.render)
-        assert_includes output.text, "Hello PDF!"
-      end
-    end
-    
-    test "loads the template from a file and renders it correctly" do
-      template = Tilt::PrawnTemplate.new("#{Dir.pwd}/test/tilt_prawntemplate.prawn")
-      output   = PdfOutput.new(template.render)
-      assert_includes output.text, "Hello Template!"
-    end
-    
-    test "loads the template from a file and can be rendered more than once" do
-      template = Tilt::PrawnTemplate.new("#{Dir.pwd}/test/tilt_prawntemplate.prawn")
-      3.times do
-        output   = PdfOutput.new(template.render)
-        assert_includes output.text, "Hello Template!"
-      end
-    end
-    
-    test "have the correct default page size & layout settings - (default: A4 portrait)" do
-      # NOTE! Dear North Americans, 
-      # Please follow the ISO 216 international standard format (A4) that dominates everywhere else in the world
-      template = Tilt::PrawnTemplate.new { |t| "pdf.text \"Hello A4 portrait!\"" }
-      output   = PdfOutput.new(template.render)
-      assert_includes output.text, "Hello A4 portrait!"
-      assert_equal [0, 0, 595.28, 841.89], output.page_attributes(1)[:MediaBox]
-    end
-    
-    test "allows page size & layout settings - A3 landscape" do
-      template = Tilt::PrawnTemplate.new( :page_size => 'A3', :page_layout => :landscape) { |t| "pdf.text \"Hello A3 landscape!\"" }
-      output   = PdfOutput.new(template.render)
-      assert_includes output.text, "Hello A3 landscape!"
-      assert_equal [0, 0, 1190.55, 841.89], output.page_attributes(1)[:MediaBox]
-    end
-    
-  end
-  
-rescue LoadError
-  warn "Tilt::PrawnTemplate (disabled)"
-end