nanoc3 3.1.9 → 3.2.0a1

data/test/helpers/test_breadcrumbs.rb

@@ -1,83 +0,0 @@
-# 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

@@ -1,42 +0,0 @@
-# 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

@@ -1,108 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,251 +0,0 @@
-# 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

@@ -1,109 +0,0 @@
-# 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

@@ -1,89 +0,0 @@
-# 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