nanoc3 3.1.7 → 3.1.8

data/test/helpers/test_breadcrumbs.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'test/helper'
+
+class Nanoc3::Helpers::BreadcrumbsTest < MiniTest::Unit::TestCase
+
+  include Nanoc3::TestHelpers
+
+  include Nanoc3::Helpers::Breadcrumbs
+
+  def test_breadcrumbs_trail_at_root
+    # Mock item
+    @item = mock
+    @item.stubs(:identifier).returns('/')
+    @items = [ @item ]
+
+    # Build trail
+    trail = breadcrumbs_trail
+
+    # Check
+    assert_equal(
+      [ @item ],
+      trail
+    )
+  end
+
+  def test_breadcrumbs_trail_with_1_parent
+    # Mock item
+    parent = mock
+    parent.stubs(:identifier).returns('/')
+    @item = mock
+    @item.stubs(:identifier).returns('/foo/')
+    @items = [ parent, @item ]
+
+    # Build trail
+    trail = breadcrumbs_trail
+
+    # Check
+    assert_equal(
+      [ parent, @item ],
+      trail
+    )
+  end
+
+  def test_breadcrumbs_trail_with_many_parents
+    # Mock item
+    grandparent = mock
+    grandparent.stubs(:identifier).returns('/')
+    parent = mock
+    parent.stubs(:identifier).returns('/foo/')
+    @item = mock
+    @item.stubs(:identifier).returns('/foo/bar/')
+    @items = [ grandparent, parent, @item ]
+
+    # Build trail
+    trail = breadcrumbs_trail
+
+    # Check
+    assert_equal(
+      [ grandparent, parent, @item ],
+      trail
+    )
+  end
+
+  def test_breadcrumbs_trail_with_nils
+    # Mock item
+    grandparent = mock
+    grandparent.stubs(:identifier).returns('/')
+    @item = mock
+    @item.stubs(:identifier).returns('/foo/bar/')
+    @items = [ grandparent, @item ]
+
+    # Build trail
+    trail = breadcrumbs_trail
+
+    # Check
+    assert_equal(
+      [ grandparent, nil, @item ],
+      trail
+    )
+  end
+
+end

data/test/helpers/test_capturing.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'test/helper'
+
+class Nanoc3::Helpers::CapturingTest < MiniTest::Unit::TestCase
+
+  include Nanoc3::TestHelpers
+
+  include Nanoc3::Helpers::Capturing
+
+  def test_content_for
+    require 'erb'
+
+    # Build content to be evaluated
+    content = "head <% content_for :sidebar do %>\n" +
+              "  <%= 1+2 %>\n" +
+              "<% end %> foot"
+
+    # Evaluate content
+    @item = {}
+    result = ::ERB.new(content).result(binding)
+
+    # Check
+    assert(@item[:content_for_sidebar].strip == '3')
+    assert_match(/^head\s+foot$/, result)
+  end
+
+  def test_capture
+    require 'erb'
+
+    # Capture
+    _erbout = 'foo'
+    captured_content = capture do
+      _erbout << 'bar'
+    end
+
+    # Check
+    assert_equal 'foo', _erbout
+    assert_equal 'bar', captured_content
+  end
+
+end

data/test/helpers/test_filtering.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+
+require 'test/helper'
+
+class Nanoc3::Helpers::FilteringTest < MiniTest::Unit::TestCase
+
+  include Nanoc3::TestHelpers
+
+  include Nanoc3::Helpers::Filtering
+
+  def test_filter_simple
+    if_have 'rubypants' do
+      # Build content to be evaluated
+      content = "<p>Foo...</p>\n" +
+                "<% filter :rubypants do %>\n" +
+                " <p>Bar...</p>\n" +
+                "<% end %>\n"
+
+      # Mock item and rep
+      @item_rep = mock
+      @item_rep.expects(:assigns).returns({})
+
+      # Evaluate content
+      result = ::ERB.new(content).result(binding)
+
+      # Check
+      assert_match('<p>Foo...</p>',     result)
+      assert_match('<p>Bar&#8230;</p>', result)
+    end
+  end
+
+  def test_filter_with_assigns
+    if_have 'rubypants' do
+      # Build content to be evaluated
+      content = "<p>Foo...</p>\n" +
+                "<% filter :erb do %>\n" +
+                " <p><%%= @item[:title] %></p>\n" +
+                "<% end %>\n"
+
+      # Mock item and rep
+      @item = mock
+      @item.expects(:[]).with(:title).returns('Bar...')
+      @item.expects(:identifier).returns('/blah/')
+      @item_rep = mock
+      @item_rep.expects(:name).returns('default')
+      @item_rep.expects(:assigns).returns({
+        :item     => @item,
+        :item_rep => @item_rep
+      })
+
+      # Evaluate content
+      result = ::ERB.new(content).result(binding)
+
+      # Check
+      assert_match('<p>Foo...</p>', result)
+      assert_match('<p>Bar...</p>', result)
+    end
+  end
+
+  def test_filter_with_unknown_filter_name
+    # Build content to be evaluated
+    content = "<p>Foo...</p>\n" +
+              "<% filter :askjdflkawgjlkwaheflnvz do %>\n" +
+              " <p>Blah blah blah.</p>\n" +
+              "<% end %>\n"
+
+    # Evaluate content
+    error = assert_raises(Nanoc3::Errors::UnknownFilter) do
+      ::ERB.new(content).result(binding)
+    end
+  end
+
+  def test_filter_with_arguments
+    if_have 'coderay' do
+      # Build content to be evaluated
+      content = "<% filter :coderay, :language => 'ruby' do %>\n" +
+                "   def some_function ; x = blah.foo ; x.bar 'xyzzy' ; end\n" +
+                "<% end %>\n"
+
+      # Mock item and rep
+      @item_rep = mock
+      @item_rep.expects(:assigns).returns({})
+
+      # Evaluate content
+      result = ::ERB.new(content).result(binding)
+      assert_match(%r{<span class="r">def</span> <span class="fu">some_function</span>}, result)
+    end
+  end
+
+  def test_with_haml
+    if_have 'haml' do
+      # Build content to be evaluated
+      content = "%p Foo.\n" +
+                "- filter(:erb) do\n" +
+                "  <%= 'abc' + 'xyz' %>\n" +
+                "%p Bar.\n"
+
+      # Mock item and rep
+      @item_rep = mock
+      @item_rep.expects(:assigns).returns({})
+
+      # Evaluate content
+      result = ::Haml::Engine.new(content).render(binding)
+      assert_match(%r{^<p>Foo.</p>\s*abcxyz\s*<p>Bar.</p>$}, result)
+    end
+  end
+
+end

data/test/helpers/test_html_escape.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'test/helper'
+
+class Nanoc3::Helpers::HTMLEscapeTest < MiniTest::Unit::TestCase
+
+  include Nanoc3::TestHelpers
+
+  include Nanoc3::Helpers::HTMLEscape
+
+  def test_html_escape
+    assert_equal('&lt;',    html_escape('<'))
+    assert_equal('&gt;',    html_escape('>'))
+    assert_equal('&amp;',   html_escape('&'))
+    assert_equal('&quot;',  html_escape('"'))
+  end
+
+end

data/test/helpers/test_link_to.rb

@@ -0,0 +1,251 @@
+# encoding: utf-8
+
+require 'test/helper'
+
+class Nanoc3::Helpers::LinkToTest < MiniTest::Unit::TestCase
+
+  include Nanoc3::TestHelpers
+
+  include Nanoc3::Helpers::LinkTo
+
+  def test_link_to_with_path
+    # Check
+    assert_equal(
+      '<a href="/foo/">Foo</a>',
+      link_to('Foo', '/foo/')
+    )
+  end
+
+  def test_link_to_with_rep
+    # Create rep
+    rep = mock
+    rep.stubs(:path).returns('/bar/')
+
+    # Check
+    assert_equal(
+      '<a href="/bar/">Bar</a>',
+      link_to('Bar', rep)
+    )
+  end
+
+  def test_link_to_with_item
+    # Create rep
+    item = mock
+    item.stubs(:path).returns('/bar/')
+
+    # Check
+    assert_equal(
+      '<a href="/bar/">Bar</a>',
+      link_to('Bar', item)
+    )
+  end
+
+  def test_link_to_with_attributes
+    # Check
+    assert_equal(
+      '<a title="Dis mai foo!" href="/foo/">Foo</a>',
+      link_to('Foo', '/foo/', :title => 'Dis mai foo!')
+    )
+  end
+
+  def test_link_to_escape
+    # Check
+    assert_equal(
+      '<a title="Foo &amp; Bar" href="/foo&amp;bar/">Foo &amp; Bar</a>',
+      link_to('Foo &amp; Bar', '/foo&bar/', :title => 'Foo & Bar')
+    )
+  end
+
+  def test_link_to_to_nil_item_or_item_rep
+    obj = Object.new
+    def obj.path ; nil ; end
+
+    assert_raises RuntimeError do
+      link_to("Some Text", obj)
+    end
+  end
+
+  def test_link_to_unless_current_current
+    # Create item
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/')
+
+    # Check
+    assert_equal(
+      '<span class="active" title="You\'re here.">Bar</span>',
+      link_to_unless_current('Bar', @item_rep)
+    )
+  ensure
+    @item = nil
+  end
+
+  def test_link_to_unless_current_not_current
+    # Create item
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/')
+
+    # Check
+    assert_equal(
+      '<a href="/abc/xyz/">Bar</a>',
+      link_to_unless_current('Bar', '/abc/xyz/')
+    )
+  end
+
+  def test_relative_path_to_with_self
+    # Mock item
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/bar/baz/')
+
+    # Test
+    assert_equal(
+      './',
+      relative_path_to('/foo/bar/baz/')
+    )
+  end
+
+  def test_relative_path_to_with_root
+    # Mock item
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/bar/baz/')
+
+    # Test
+    assert_equal(
+      '../../../',
+      relative_path_to('/')
+    )
+  end
+
+  def test_relative_path_to_file
+    # Mock item
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/bar/baz/')
+
+    # Test
+    assert_equal(
+      '../../quux',
+      relative_path_to('/foo/quux')
+    )
+  end
+
+  def test_relative_path_to_dir
+    # Mock item
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/bar/baz/')
+
+    # Test
+    assert_equal(
+      '../../quux/',
+      relative_path_to('/foo/quux/')
+    )
+  end
+
+  def test_relative_path_to_rep
+    # Mock self
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/bar/baz/')
+
+    # Mock other
+    other_item_rep = mock
+    other_item_rep.stubs(:path).returns('/foo/quux/')
+
+    # Test
+    assert_equal(
+      '../../quux/',
+      relative_path_to(other_item_rep)
+    )
+  end
+
+
+  def test_relative_path_to_item
+    # Mock self
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/bar/baz/')
+
+    # Mock other
+    other_item = mock
+    other_item.stubs(:path).returns('/foo/quux/')
+
+    # Test
+    assert_equal(
+      '../../quux/',
+      relative_path_to(other_item)
+    )
+  end
+
+  def test_relative_path_to_to_nil
+    # Mock self
+    @item_rep = mock
+    @item_rep.stubs(:path).returns(nil)
+
+    # Mock other
+    other_item_rep = mock
+    other_item_rep.stubs(:path).returns('/foo/quux/')
+
+    # Test
+    assert_raises RuntimeError do
+      relative_path_to(other_item_rep)
+    end
+  end
+
+  def test_relative_path_to_from_nil
+    # Mock self
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/quux/')
+
+    # Mock other
+    other_item_rep = mock
+    other_item_rep.stubs(:path).returns(nil)
+
+    # Test
+    assert_raises RuntimeError do
+      relative_path_to(other_item_rep)
+    end
+  end
+
+  def test_examples_link_to
+    # Parse
+    YARD.parse('../lib/nanoc3/helpers/link_to.rb')
+
+    # Mock
+    @items = [ mock, mock, mock ]
+    @items[0].stubs(:identifier).returns('/about/')
+    @items[0].stubs(:path).returns('/about.html')
+    @items[1].stubs(:identifier).returns('/software/')
+    @items[1].stubs(:path).returns('/software.html')
+    @items[2].stubs(:identifier).returns('/software/nanoc/')
+    @items[2].stubs(:path).returns('/software/nanoc.html')
+    about_rep_vcard = mock
+    about_rep_vcard.stubs(:path).returns('/about.vcf')
+    @items[0].stubs(:rep).with(:vcard).returns(about_rep_vcard)
+
+    # Run
+    assert_examples_correct 'Nanoc3::Helpers::LinkTo#link_to'
+  end
+
+  def test_examples_link_to_unless_current
+    # Parse
+    YARD.parse('../lib/nanoc3/helpers/link_to.rb')
+
+    # Mock
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/about/')
+    @item = mock
+    @item.stubs(:path).returns(@item_rep.path)
+
+    # Run
+    assert_examples_correct 'Nanoc3::Helpers::LinkTo#link_to_unless_current'
+  end
+
+  def test_examples_relative_path_to
+    # Parse
+    YARD.parse('../lib/nanoc3/helpers/link_to.rb')
+
+    # Mock
+    @item_rep = mock
+    @item_rep.stubs(:path).returns('/foo/bar/')
+
+    # Run
+    assert_examples_correct 'Nanoc3::Helpers::LinkTo#relative_path_to'
+  end
+
+end

data/test/helpers/test_rendering.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+require 'test/helper'
+
+class Nanoc3::Helpers::RenderingTest < MiniTest::Unit::TestCase
+
+  include Nanoc3::TestHelpers
+
+  include Nanoc3::Helpers::Rendering
+
+  def test_render
+    # Mock layouts
+    layout = MiniTest::Mock.new
+    layout.expect(:identifier,   '/foo/')
+    layout.expect(:raw_content,  'This is the <%= @layout.identifier %> layout.')
+
+    # Mock site, compiler and stack
+    stack    = []
+    compiler = MiniTest::Mock.new
+    compiler.expect(:stack, stack)
+    compiler.expects(:filter_for_layout).with(layout).returns([ :erb, {} ])
+    @site    = MiniTest::Mock.new
+    @site.expect(:compiler, compiler)
+    @site.expect(:layouts, [ layout ])
+
+    # Render
+    assert_equal('This is the /foo/ layout.', render('/foo/'))
+  end
+
+  def test_render_with_unknown_layout
+    # Mock site
+    @site = MiniTest::Mock.new.expect(:layouts, [])
+
+    # Render
+    assert_raises(Nanoc3::Errors::UnknownLayout) do
+      render('/fawgooafwagwfe/')
+    end
+  end
+
+  def test_render_without_filter
+    # Mock layouts
+    layout = MiniTest::Mock.new
+    layout.expect(:identifier,   '/foo/')
+    layout.expect(:raw_content,  'This is the <%= "foo" %> layout.')
+
+    # Mock compiler
+    compiler = mock
+    compiler.stubs(:filter_for_layout).with(layout).returns(nil)
+
+    # Mock site
+    @site = MiniTest::Mock.new
+    @site.expect(:layouts, [ layout ])
+    @site.expect(:compiler, compiler)
+
+    # Render
+    assert_raises(Nanoc3::Errors::CannotDetermineFilter) do
+      render '/foo/'
+    end
+  end
+
+  def test_render_with_unknown_filter
+    # Mock layouts
+    layout = MiniTest::Mock.new
+    layout.expect(:identifier,   '/foo/')
+    layout.expect(:raw_content,  'This is the <%= "foo" %> layout.')
+
+    # Mock compiler
+    compiler = mock
+    compiler.stubs(:filter_for_layout).with(layout).returns([ :kjsdalfjwagihlawfji, {} ])
+
+    # Mock site
+    @site = MiniTest::Mock.new
+    @site.expect(:layouts, [ layout ])
+    @site.expect(:compiler, compiler)
+
+    # Render
+    assert_raises(Nanoc3::Errors::UnknownFilter) do
+      render '/foo/'
+    end
+  end
+
+  def test_render_with_block
+    # Mock layouts
+    layout = MiniTest::Mock.new
+    layout.expect(:identifier,   '/foo/')
+    layout.expect(:raw_content,  '[partial-before]<%= yield %>[partial-after]')
+
+    # Mock compiler
+    stack    = []
+    compiler = mock
+    compiler.stubs(:stack).returns(stack)
+    compiler.expects(:filter_for_layout).with(layout).returns([ :erb, {} ])
+
+    # Mock site
+    @site    = MiniTest::Mock.new
+    @site.expect(:compiler, compiler)
+    @site.expect(:layouts, [ layout ])
+
+    # Mock erbout
+    _erbout = '[erbout-before]'
+
+    # Render
+    render '/foo/' do
+      _erbout << "This is some extra content"
+    end
+    assert_equal('[erbout-before][partial-before]This is some extra content[partial-after]', _erbout)
+  end
+
+end

data/test/helpers/test_tagging.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require 'test/helper'
+
+class Nanoc3::Helpers::TaggingTest < MiniTest::Unit::TestCase
+
+  include Nanoc3::TestHelpers
+
+  include Nanoc3::Helpers::Tagging
+
+  def test_tags_for_without_tags
+    # Create item
+    item = Nanoc3::Item.new('content', {}, '/path/')
+
+    # Check
+    assert_equal(
+      '(none)',
+      tags_for(item)
+    )
+  end
+
+  def test_tags_for_with_custom_base_url
+    # Create item
+    item = Nanoc3::Item.new('content', { :tags => [ 'foo', 'bar' ]}, '/path/')
+
+    # Check
+    assert_equal(
+      "#{link_for_tag('foo', 'http://stoneship.org/tag/')}, " +
+      "#{link_for_tag('bar', 'http://stoneship.org/tag/')}",
+      tags_for(item, :base_url => 'http://stoneship.org/tag/')
+    )
+  end
+
+  def test_tags_for_with_custom_none_text
+    # Create item
+    item = Nanoc3::Item.new('content', { :tags => [ ]}, '/path/')
+
+    # Check
+    assert_equal(
+      'no tags for you, fool',
+      tags_for(item, :none_text => 'no tags for you, fool')
+    )
+  end
+
+  def test_tags_for_with_custom_separator
+    # Create item
+    item = Nanoc3::Item.new('content', { :tags => [ 'foo', 'bar' ]}, '/path/')
+
+    # Check
+    assert_equal(
+      "#{link_for_tag('foo', 'http://technorati.com/tag/')} ++ " +
+      "#{link_for_tag('bar', 'http://technorati.com/tag/')}",
+      tags_for(item, :separator => ' ++ ')
+    )
+  end
+
+  def test_items_with_tag
+    # Create items
+    @items = [
+      Nanoc3::Item.new('item 1', { :tags => [ :foo ]       }, '/item1/'),
+      Nanoc3::Item.new('item 2', { :tags => [ :bar ]       }, '/item2/'),
+      Nanoc3::Item.new('item 3', { :tags => [ :foo, :bar ] }, '/item3/')
+    ]
+
+    # Find items
+    items_with_foo_tag = items_with_tag(:foo)
+
+    # Check
+    assert_equal(
+      [ @items[0], @items[2] ],
+      items_with_foo_tag
+    )
+  end
+
+  def test_link_for_tag
+    assert_equal(
+      %[<a href="http://stoneship.org/tags/foobar" rel="tag">foobar</a>],
+      link_for_tag('foobar', 'http://stoneship.org/tags/')
+    )
+  end
+
+  def test_link_for_tag_escape
+    assert_equal(
+      %[<a href="http://stoneship.org/tags&amp;stuff/foo&amp;bar" rel="tag">foo&amp;bar</a>],
+      link_for_tag('foo&bar', 'http://stoneship.org/tags&stuff/')
+    )
+  end
+
+end