nanoc 3.2.4 → 3.3.0

data/test/filters/test_mustache.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+class Nanoc::Filters::MustacheTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_filter
+    if_have 'mustache' do
+      # Create item
+      item = Nanoc::Item.new(
+        'content',
+        { :title => 'Max Payne', :protagonist => 'Max Payne' },
+        '/games/max-payne/'
+      )
+
+      # Create filter
+      filter = ::Nanoc::Filters::Mustache.new({ :item => item })
+
+      # Run filter
+      result = filter.run('The protagonist of {{title}} is {{protagonist}}.')
+      assert_equal('The protagonist of Max Payne is Max Payne.', result)
+    end
+  end
+
+end

data/test/filters/test_rainpress.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+class Nanoc::Filters::RainpressTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_filter
+    if_have 'rainpress' do
+      # Create filter
+      filter = ::Nanoc::Filters::Rainpress.new
+
+      # Run filter
+      result = filter.run("body { color: black; }")
+      assert_equal("body{color:#000}", result)
+    end
+  end
+
+  def test_filter_with_options
+    if_have 'rainpress' do
+      # Create filter
+      filter = ::Nanoc::Filters::Rainpress.new
+
+      # Run filter
+      result = filter.run("body { color: #aabbcc; }", :colors => false)
+      assert_equal("body{color:#aabbcc}", result)
+    end
+  end
+
+end

data/test/filters/test_rdiscount.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+class Nanoc::Filters::RDiscountTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_filter
+    if_have 'rdiscount' do
+      # Create filter
+      filter = ::Nanoc::Filters::RDiscount.new
+
+      # Run filter
+      result = filter.run("> Quote")
+      assert_match(/<blockquote>\s*<p>Quote<\/p>\s*<\/blockquote>/, result)
+    end
+  end
+
+  def test_with_extensions
+    if_have 'rdiscount' do
+      # Create filter
+      filter = ::Nanoc::Filters::RDiscount.new
+
+      # Run filter
+      input           = "The quotation 'marks' sure make this look sarcastic!"
+      output_expected = /The quotation &lsquo;marks&rsquo; sure make this look sarcastic!/
+      output_actual   = filter.run(input, :extensions => [ :smart ])
+      assert_match(output_expected, output_actual)
+    end
+  end
+
+end

data/test/filters/test_rdoc.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+class Nanoc::Filters::RDocTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_filter
+    if_have 'rdoc' do
+      # Get filter
+      filter = ::Nanoc::Filters::RDoc.new
+
+      # Run filter
+      result = filter.run("= Foo")
+      assert_match(%r{<h1( id="label-Foo")?>Foo</h1>\Z}, result)
+    end
+  end
+
+end

data/test/filters/test_redcarpet.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+class Nanoc::Filters::RedcarpetTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_find
+    if_have 'redcarpet' do
+      refute Nanoc::Filter.named(:redcarpet).nil?
+    end
+  end
+
+  def test_filter
+    if_have 'redcarpet' do
+      # Create filter
+      filter = ::Nanoc::Filters::Redcarpet.new
+
+      # Run filter
+      result = filter.run("> Quote")
+      assert_match(/<blockquote>\s*<p>Quote<\/p>\s*<\/blockquote>/, result)
+    end
+  end
+
+  def test_with_extensions
+    if_have 'redcarpet' do
+      # Create filter
+      filter = ::Nanoc::Filters::Redcarpet.new
+
+      # Run filter
+      if ::Redcarpet::VERSION > '2'
+        input           = "this is ~~good~~ bad"
+        output_expected = /this is <del>good<\/del> bad/
+        output_actual   = filter.run(input, :options => { :strikethrough => true })
+      else
+        input           = "The quotation 'marks' sure make this look sarcastic!"
+        output_expected = /The quotation &lsquo;marks&rsquo; sure make this look sarcastic!/
+        output_actual   = filter.run(input, :options => [ :smart ])
+      end
+      assert_match(output_expected, output_actual)
+    end
+  end
+
+  def test_html_by_default
+    if_have 'redcarpet' do
+      # Create filter
+      filter = ::Nanoc::Filters::Redcarpet.new
+
+      # Run filter
+      input           = "![Alt](/path/to/img 'Title')"
+      output_expected = %r{<img src="/path/to/img" alt="Alt" title="Title">}
+      output_actual   = filter.run(input)
+      assert_match(output_expected, output_actual)
+    end
+  end
+
+  def test_xhtml_if_requested
+    if_have 'redcarpet' do
+      # Create filter
+      filter = ::Nanoc::Filters::Redcarpet.new
+
+      # Run filter
+      input           = "![Alt](/path/to/img 'Title')"
+      output_expected = %r{<img src="/path/to/img" alt="Alt" title="Title"/>}
+      if ::Redcarpet::VERSION > '2'
+        output_actual   = filter.run(input, :renderer_options => { :xhtml => true })
+      else
+        output_actual   = filter.run(input, :options => [ :xhtml ])
+      end
+      assert_match(output_expected, output_actual)
+    end
+  end
+
+end

data/test/filters/test_redcloth.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+class Nanoc::Filters::RedClothTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_filter
+    if_have 'redcloth' do
+      # Get filter
+      filter = ::Nanoc::Filters::RedCloth.new
+
+      # Run filter
+      result = filter.run("h1. Foo")
+      assert_equal("<h1>Foo</h1>", result)
+    end
+  end
+
+  def test_filter_with_options
+    if_have 'redcloth' do
+      # Get filter
+      filter = ::Nanoc::Filters::RedCloth.new
+
+      # Run filter without options
+      result = filter.run("I am a member of SPECTRE.")
+      assert_equal("<p>I am a member of <span class=\"caps\">SPECTRE</span>.</p>", result)
+
+      # Run filter with options
+      result = filter.run("I am a member of SPECTRE.", :no_span_caps => true)
+      assert_equal("<p>I am a member of SPECTRE.</p>", result)
+    end
+  end
+
+end

data/test/filters/test_relativize_paths.rb

@@ -0,0 +1,533 @@
+# encoding: utf-8
+
+class Nanoc::Filters::RelativizePathsTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+
+  def test_filter_html_with_double_quotes
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/foo/bar/baz/'
+    end
+
+    # Set content
+    raw_content      = %[<a href="/foo">foo</a>]
+    expected_content = %[<a href="../..">foo</a>]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :html)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_html_with_single_quotes
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/foo/bar/baz/'
+    end
+
+    # Set content
+    raw_content      = %[<a href='/foo'>foo</a>]
+    expected_content = %[<a href='../..'>foo</a>]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :html)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_html_without_quotes
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/foo/bar/baz/'
+    end
+
+    # Set content
+    raw_content      = %[<a href=/foo>foo</a>]
+    expected_content = %[<a href=../..>foo</a>]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :html)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_html_multiple
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/foo/bar/baz/'
+    end
+
+    # Set content
+    raw_content      = %[<a href="/foo">foo</a> <a href="/bar">bar</a>]
+    expected_content = %[<a href="../..">foo</a> <a href="../../../bar">bar</a>]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :html)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_html_outside_tag
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/foo/bar/baz/'
+    end
+
+    # Set content
+    raw_content      = %[stuff href="/foo" more stuff]
+    expected_content = %[stuff href="/foo" more stuff]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :html)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_html_root
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/woof/meow/'
+    end
+
+    # Set content
+    raw_content      = %[<a href="/">foo</a>]
+    expected_content = %[<a href="../../">foo</a>]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :html)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_html_network_path
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/woof/meow/'
+    end
+
+    # Set content
+    raw_content      = %[<a href="//example.com/">example.com</a>]
+    expected_content = %[<a href="//example.com/">example.com</a>]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :html)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_implicit
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Test
+    assert_raises(RuntimeError) do
+      filter.run("moo")
+    end
+  end
+
+  def test_filter_css_with_double_quotes
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/foo/bar/baz/'
+    end
+
+    # Set content
+    raw_content      = %[background: url("/foo/bar/background.png");]
+    expected_content = %[background: url("../background.png");]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :css)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_css_with_single_quotes
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/foo/bar/baz/'
+    end
+
+    # Set content
+    raw_content      = %[background: url('/foo/bar/background.png');]
+    expected_content = %[background: url('../background.png');]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :css)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_css_without_quotes
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/foo/bar/baz/'
+    end
+
+    # Set content
+    raw_content      = %[background: url(/foo/bar/background.png);]
+    expected_content = %[background: url(../background.png);]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :css)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_css_multiple
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/foo/bar/baz/'
+    end
+
+    # Set content
+    raw_content      = %[background: url(/foo/bar/a.png) url(/foo/bar/b.png);]
+    expected_content = %[background: url(../a.png) url(../b.png);]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :css)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_css_root
+    # It is probably a bit weird to have “url(/)” in CSS, but I’ve made a
+    # test case for this situation anyway. Can’t hurt…
+
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/woof/meow/'
+    end
+
+    # Set content
+    raw_content      = %[background: url(/);]
+    expected_content = %[background: url(../../);]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :css)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_css_network_path
+    # Create filter with mock item
+    filter = Nanoc::Filters::RelativizePaths.new
+
+    # Mock item
+    filter.instance_eval do
+      @item_rep = Nanoc::ItemRep.new(
+        Nanoc::Item.new(
+          'content',
+          {},
+          '/foo/bar/baz/'),
+        :blah)
+      @item_rep.path = '/woof/meow/'
+    end
+
+    # Set content
+    raw_content      = %[background: url(//example.com);]
+    expected_content = %[background: url(//example.com);]
+
+    # Test
+    actual_content = filter.run(raw_content, :type => :css)
+    assert_equal(expected_content, actual_content)
+  end
+
+  def test_filter_xml
+    if_have 'nokogiri' do
+      # Create filter with mock item
+      filter = Nanoc::Filters::RelativizePaths.new
+
+      # Mock item
+      filter.instance_eval do
+        @item_rep = Nanoc::ItemRep.new(
+          Nanoc::Item.new(
+            'content',
+            {},
+            '/foo/bar/baz/'),
+          :blah)
+        @item_rep.path = '/foo/bar/baz/'
+      end
+
+      # Set content
+      raw_content = <<-XML
+<?xml version="1.0" encoding="utf-8"?>
+<foo>
+  <bar boo="/foo">baz</bar>
+</foo>
+XML
+
+      expected_content = <<-XML
+<?xml version="1.0" encoding="utf-8"?>
+<foo>
+  <bar boo="../..">baz</bar>
+</foo>
+XML
+
+      # Test
+      actual_content = filter.run(raw_content, :type => :xml, :select => ['*/@boo'])
+      assert_equal(expected_content, actual_content)
+    end
+  end
+
+  def test_filter_fragment_xml
+    if_have 'nokogiri' do
+      # Create filter with mock item
+      filter = Nanoc::Filters::RelativizePaths.new
+
+      # Mock item
+      filter.instance_eval do
+        @item_rep = Nanoc::ItemRep.new(
+          Nanoc::Item.new(
+            'content',
+            {},
+            '/foo/bar/baz/'),
+          :blah)
+        @item_rep.path = '/foo/bar/baz/'
+      end
+
+      # Set content
+      raw_content = <<-XML
+<foo>
+  <bar><far href="/foo">baz</far></bar>
+</foo>
+XML
+
+      expected_content = <<-XML
+<foo>
+  <bar><far href="../..">baz</far></bar>
+</foo>
+XML
+
+      # Test
+      actual_content = filter.run(raw_content, :type => :xml, :select => ['far/@href'])
+      assert_equal(expected_content, actual_content)
+    end
+  end
+
+  def test_filter_xml_with_namespaces
+    if_have 'nokogiri' do
+      # Create filter with mock item
+      filter = Nanoc::Filters::RelativizePaths.new
+
+      # Mock item
+      filter.instance_eval do
+        @item_rep = Nanoc::ItemRep.new(
+          Nanoc::Item.new(
+            'content',
+            {},
+            '/foo/bar/baz/'),
+          :blah)
+        @item_rep.path = '/foo/bar/baz/'
+      end
+
+      # Set content
+      raw_content = <<-XML
+<foo xmlns="http://example.org">
+  <bar><a href="/foo">baz</a></bar>
+</foo>
+XML
+
+      expected_content = <<-XML
+<foo xmlns="http://example.org">
+  <bar><a href="../..">baz</a></bar>
+</foo>
+XML
+
+      # Test
+      actual_content = filter.run(raw_content, {
+        :type => :xml, 
+        :namespaces => {:ex => 'http://example.org'}, 
+        :select => ['ex:a/@href']
+      })
+      assert_equal(expected_content, actual_content)
+    end
+  end
+
+  def test_filter_xhtml
+    if_have 'nokogiri' do
+      # Create filter with mock item
+      filter = Nanoc::Filters::RelativizePaths.new
+
+      # Mock item
+      filter.instance_eval do
+        @item_rep = Nanoc::ItemRep.new(
+          Nanoc::Item.new(
+            'content',
+            {},
+            '/foo/bar/baz/'),
+          :blah)
+        @item_rep.path = '/foo/bar/baz/'
+      end
+
+      # Set content
+      raw_content = <<-XML
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <link rel="stylesheet" href="/css"/>
+    <script src="/js"></script>
+  </head>
+  <body>
+    <a href="/foo">bar</a>
+    <img src="/img"/>
+  </body>
+</html>
+XML
+
+      expected_content = <<-XML
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <link rel="stylesheet" href="../../../css" />
+    <script src="../../../js"></script>
+  </head>
+  <body>
+    <a href="../..">bar</a>
+    <img src="../../../img" />
+  </body>
+</html>
+XML
+
+      # Test
+      actual_content = filter.run(raw_content, :type => :xhtml)
+      assert_equal(expected_content, actual_content)
+    end
+  end
+
+  def test_filter_fragment_xhtml
+    if_have 'nokogiri' do
+      # Create filter with mock item
+      filter = Nanoc::Filters::RelativizePaths.new
+
+      # Mock item
+      filter.instance_eval do
+        @item_rep = Nanoc::ItemRep.new(
+          Nanoc::Item.new(
+            'content',
+            {},
+            '/foo/bar/baz/'),
+          :blah)
+        @item_rep.path = '/foo/bar/baz/'
+      end
+
+      # Set content
+      raw_content = <<-XML
+<a href="/foo">bar</a>
+<p>
+  <img src="/img"/>
+</p>
+XML
+
+      expected_content = <<-XML
+<a href="../..">bar</a>
+<p>
+  <img src="../../../img" />
+</p>
+XML
+
+      # Test
+      actual_content = filter.run(raw_content, :type => :xhtml)
+      assert_equal(expected_content, actual_content)
+    end
+  end
+
+
+end