nanoc 3.2.4 → 3.3.0

data/test/base/test_directed_graph.rb

@@ -0,0 +1,288 @@
+# encoding: utf-8
+
+class Nanoc::DirectedGraphTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_direct_predecessors
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+
+    assert_equal [],    graph.direct_predecessors_of(1)
+    assert_equal [ 1 ], graph.direct_predecessors_of(2)
+    assert_equal [ 2 ], graph.direct_predecessors_of(3)
+  end
+
+  def test_predecessors
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+
+    assert_equal [],       graph.predecessors_of(1).sort
+    assert_equal [ 1 ],    graph.predecessors_of(2).sort
+    assert_equal [ 1, 2 ], graph.predecessors_of(3).sort
+  end
+
+  def test_direct_successors
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+
+    assert_equal [ 2 ], graph.direct_successors_of(1)
+    assert_equal [ 3 ], graph.direct_successors_of(2)
+    assert_equal [],    graph.direct_successors_of(3)
+  end
+
+  def test_successors
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+
+    assert_equal [ 2, 3 ], graph.successors_of(1).sort
+    assert_equal [ 3 ],    graph.successors_of(2).sort
+    assert_equal [],       graph.successors_of(3).sort
+  end
+
+  def test_edges
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+
+    assert_equal [ [ 0, 1 ], [ 1, 2 ] ], graph.edges.sort
+  end
+
+  def test_edges_with_new_vertices
+    graph = Nanoc::DirectedGraph.new([ 1 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(3, 2)
+
+    assert_equal [ [ 0, 1 ], [ 2, 1 ] ], graph.edges.sort
+  end
+
+  def test_add_edge
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    
+    assert_equal [], graph.successors_of(1)
+    assert_equal [], graph.predecessors_of(2)
+
+    graph.add_edge(1, 2)
+
+    assert_equal [ 2 ], graph.successors_of(1)
+    assert_equal [ 1 ], graph.predecessors_of(2)
+  end
+
+  def test_add_edge_with_new_vertices
+    graph = Nanoc::DirectedGraph.new([ 1 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(3, 2)
+
+    assert graph.vertices.include?(2)
+    assert graph.vertices.include?(3)
+  end
+
+  def test_delete_edge
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1,2)
+
+    assert_equal [ 2 ], graph.successors_of(1)
+    assert_equal [ 1 ], graph.predecessors_of(2)
+
+    graph.delete_edge(1, 2)
+
+    assert_equal [], graph.successors_of(1)
+    assert_equal [], graph.predecessors_of(2)
+  end
+
+  def test_delete_edges_from
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 1)
+    graph.add_edge(2, 3)
+    graph.add_edge(3, 2)
+    graph.add_edge(1, 3)
+    graph.add_edge(3, 1)
+
+    assert_equal [ 2, 3 ], graph.direct_predecessors_of(1).sort
+    assert_equal [ 2, 3 ], graph.direct_successors_of(1).sort
+    assert_equal [ 1, 3 ], graph.direct_predecessors_of(2).sort
+    assert_equal [ 1, 3 ], graph.direct_successors_of(2).sort
+    assert_equal [ 1, 2 ], graph.direct_predecessors_of(3).sort
+    assert_equal [ 1, 2 ], graph.direct_successors_of(3).sort
+    assert_equal Set.new([]), graph.roots
+
+    graph.delete_edges_from(1)
+
+    assert_equal [ 2, 3 ], graph.direct_predecessors_of(1).sort
+    assert_equal [      ], graph.direct_successors_of(1).sort
+    assert_equal [ 3    ], graph.direct_predecessors_of(2).sort
+    assert_equal [ 1, 3 ], graph.direct_successors_of(2).sort
+    assert_equal [ 2    ], graph.direct_predecessors_of(3).sort
+    assert_equal [ 1, 2 ], graph.direct_successors_of(3).sort
+    assert_equal Set.new([]), graph.roots
+
+    graph.delete_edges_from(2)
+
+    assert_equal [ 3    ], graph.direct_predecessors_of(1).sort
+    assert_equal [      ], graph.direct_successors_of(1).sort
+    assert_equal [ 3    ], graph.direct_predecessors_of(2).sort
+    assert_equal [      ], graph.direct_successors_of(2).sort
+    assert_equal [      ], graph.direct_predecessors_of(3).sort
+    assert_equal [ 1, 2 ], graph.direct_successors_of(3).sort
+    assert_equal Set.new([ 3 ]), graph.roots
+  end
+
+  def test_delete_edges_to
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 1)
+    graph.add_edge(2, 3)
+    graph.add_edge(3, 2)
+    graph.add_edge(1, 3)
+    graph.add_edge(3, 1)
+
+    assert_equal [ 2, 3 ], graph.direct_predecessors_of(1).sort
+    assert_equal [ 2, 3 ], graph.direct_successors_of(1).sort
+    assert_equal [ 1, 3 ], graph.direct_predecessors_of(2).sort
+    assert_equal [ 1, 3 ], graph.direct_successors_of(2).sort
+    assert_equal [ 1, 2 ], graph.direct_predecessors_of(3).sort
+    assert_equal [ 1, 2 ], graph.direct_successors_of(3).sort
+    assert_equal Set.new([]), graph.roots
+
+    graph.delete_edges_to(1)
+
+    assert_equal [      ], graph.direct_predecessors_of(1).sort
+    assert_equal [ 2, 3 ], graph.direct_successors_of(1).sort
+    assert_equal [ 1, 3 ], graph.direct_predecessors_of(2).sort
+    assert_equal [ 3    ], graph.direct_successors_of(2).sort
+    assert_equal [ 1, 2 ], graph.direct_predecessors_of(3).sort
+    assert_equal [ 2    ], graph.direct_successors_of(3).sort
+    assert_equal Set.new([ 1 ]), graph.roots
+
+    graph.delete_edges_to(2)
+
+    assert_equal [      ], graph.direct_predecessors_of(1).sort
+    assert_equal [ 3    ], graph.direct_successors_of(1).sort
+    assert_equal [      ], graph.direct_predecessors_of(2).sort
+    assert_equal [ 3    ], graph.direct_successors_of(2).sort
+    assert_equal [ 1, 2 ], graph.direct_predecessors_of(3).sort
+    assert_equal [      ], graph.direct_successors_of(3).sort
+    assert_equal Set.new([ 1, 2 ]), graph.roots
+  end
+
+  def test_delete_vertex
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 1)
+    graph.add_edge(2, 3)
+    graph.add_edge(3, 2)
+    graph.add_edge(1, 3)
+    graph.add_edge(3, 1)
+
+    graph.delete_vertex(2)
+
+    assert_equal [ 3 ], graph.direct_predecessors_of(1).sort
+    assert_equal [ 3 ], graph.direct_successors_of(1).sort
+    assert_equal [ 1 ], graph.direct_predecessors_of(3).sort
+    assert_equal [ 1 ], graph.direct_successors_of(3).sort
+    assert_equal Set.new([]), graph.roots
+  end
+
+  def test_delete_vertex_resulting_roots
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    assert_equal Set.new([ 1, 2, 3 ]), graph.roots
+
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+    assert_equal Set.new([ 1 ]), graph.roots
+
+    graph.delete_vertex(2)
+    assert_equal Set.new([ 1, 3 ]), graph.roots
+  end
+
+  def test_should_return_empty_array_for_nonexistant_vertices
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+
+    assert_equal [], graph.direct_predecessors_of(4)
+    assert_equal [], graph.predecessors_of(4)
+    assert_equal [], graph.direct_successors_of(4)
+    assert_equal [], graph.successors_of(4)
+  end
+
+  def test_roots_after_init
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+
+    assert_equal Set.new([ 1, 2, 3 ]), graph.roots
+  end
+
+  def test_roots_after_adding_edge
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    assert_equal Set.new([ 1, 3 ]), graph.roots
+
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 3)
+    assert_equal Set.new([ 1, 2 ]), graph.roots
+
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(2, 1)
+    assert_equal Set.new([ 2, 3 ]), graph.roots
+
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+    assert_equal Set.new([ 1 ]), graph.roots
+
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+    graph.add_edge(3, 1)
+    assert_equal Set.new([]), graph.roots
+  end
+
+  def test_roots_after_removing_edge
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.delete_edge(1, 2)
+    assert_equal Set.new([ 1, 2, 3 ]), graph.roots
+
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 3)
+    assert_equal Set.new([ 1, 2 ]), graph.roots
+    graph.delete_edge(1, 2) # no such edge
+    assert_equal Set.new([ 1, 2 ]), graph.roots
+
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(2, 1)
+    graph.delete_edge(2, 1)
+    assert_equal Set.new([ 1, 2, 3 ]), graph.roots
+
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+    graph.delete_edge(1, 2)
+    assert_equal Set.new([ 1, 2 ]), graph.roots
+    graph.delete_edge(2, 3)
+    assert_equal Set.new([ 1, 2, 3 ]), graph.roots
+
+    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph.add_edge(1, 2)
+    graph.add_edge(2, 3)
+    graph.add_edge(3, 1)
+    graph.delete_edge(1, 2)
+    assert_equal Set.new([ 2 ]), graph.roots
+    graph.delete_edge(2, 3)
+    assert_equal Set.new([ 2, 3 ]), graph.roots
+    graph.delete_edge(3, 1)
+    assert_equal Set.new([ 1, 2, 3 ]), graph.roots
+  end
+
+  def test_example
+    YARD.parse('../lib/nanoc/base/directed_graph.rb')
+    assert_examples_correct 'Nanoc::DirectedGraph'
+  end
+
+end

data/test/base/test_filter.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+class Nanoc::FilterTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_initialize
+    # Create filter
+    filter = Nanoc::Filter.new
+
+    # Test assigns
+    assert_equal({}, filter.instance_eval { @assigns })
+  end
+
+  def test_assigns
+    # Create filter
+    filter = Nanoc::Filter.new({ :foo => 'bar' })
+
+    # Check assigns
+    assert_equal('bar', filter.assigns[:foo])
+  end
+
+  def test_assigns_with_instance_variables
+    # Create filter
+    filter = Nanoc::Filter.new({ :foo => 'bar' })
+
+    # Check assigns
+    assert_equal('bar', filter.instance_eval { @foo })
+  end
+
+  def test_assigns_with_instance_methods
+    # Create filter
+    filter = Nanoc::Filter.new({ :foo => 'bar' })
+
+    # Check assigns
+    assert_equal('bar', filter.instance_eval { foo })
+  end
+
+  def test_run
+    # Create filter
+    filter = Nanoc::Filter.new
+
+    # Make sure an error is raised
+    assert_raises(NotImplementedError) do
+      filter.run(nil)
+    end
+  end
+
+  def test_filename_item
+    # Mock items
+    item = mock
+    item.expects(:identifier).returns('/foo/bar/baz/')
+    item_rep = mock
+    item_rep.expects(:name).returns(:quux)
+
+    # Create filter
+    filter = Nanoc::Filter.new({ :item => item, :item_rep => item_rep })
+
+    # Check filename
+    assert_equal('item /foo/bar/baz/ (rep quux)', filter.filename)
+  end
+
+  def test_filename_layout
+    # Mock items
+    layout = mock
+    layout.expects(:identifier).returns('/wohba/')
+
+    # Create filter
+    filter = Nanoc::Filter.new({ :item => mock, :item_rep => mock, :layout => layout })
+
+    # Check filename
+    assert_equal('layout /wohba/', filter.filename)
+  end
+
+  def test_filename_unknown
+    # Create filter
+    filter = Nanoc::Filter.new({})
+
+    # Check filename
+    assert_equal('?', filter.filename)
+  end
+
+end

data/test/base/test_item.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+
+class Nanoc::ItemTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_initialize_with_attributes_with_string_keys
+    item = Nanoc::Item.new("foo", { 'abc' => 'xyz' }, '/foo/')
+
+    assert_equal nil,   item.attributes['abc']
+    assert_equal 'xyz', item.attributes[:abc]
+  end
+
+  def test_initialize_with_unclean_identifier
+    item = Nanoc::Item.new("foo", {}, '/foo')
+
+    assert_equal '/foo/', item.identifier
+  end
+
+  def test_frozen_identifier
+    item = Nanoc::Item.new("foo", {}, '/foo')
+
+    raised = false
+    begin
+      item.identifier.chop!
+    rescue => error
+      raised = true
+      assert_match /^can't modify frozen [Ss]tring$/, error.message
+    end
+    assert raised, 'Should have raised when trying to modify a frozen string'
+  end
+
+  def test_lookup
+    # Create item
+    item = Nanoc::Item.new(
+      "content",
+      { :one => 'one in item' },
+      '/path/'
+    )
+
+    # Test finding one
+    assert_equal('one in item', item[:one])
+
+    # Test finding two
+    assert_equal(nil, item[:two])
+  end
+
+  def test_set_attribute
+    item = Nanoc::Item.new("foo", {}, '/foo')
+    assert_equal nil, item[:motto]
+
+    item[:motto] = 'More human than human'
+    assert_equal 'More human than human', item[:motto]
+  end
+
+  def test_compiled_content_with_default_rep_and_default_snapshot
+    # Mock rep
+    rep = Object.new
+    def rep.name ; :default ; end
+    def rep.compiled_content(params)
+      "content at #{params[:snapshot].inspect}"
+    end
+
+    # Mock item
+    item = Nanoc::Item.new("foo", {}, '/foo')
+    item.expects(:reps).returns([ rep ])
+
+    # Check
+    assert_equal 'content at nil', item.compiled_content
+  end
+
+  def test_compiled_content_with_custom_rep_and_default_snapshot
+    # Mock reps
+    rep = Object.new
+    def rep.name ; :foo ; end
+    def rep.compiled_content(params)
+      "content at #{params[:snapshot].inspect}"
+    end
+
+    # Mock item
+    item = Nanoc::Item.new("foo", {}, '/foo')
+    item.expects(:reps).returns([ rep ])
+
+    # Check
+    assert_equal 'content at nil', item.compiled_content(:rep => :foo)
+  end
+
+  def test_compiled_content_with_default_rep_and_custom_snapshot
+    # Mock reps
+    rep = Object.new
+    def rep.name ; :default ; end
+    def rep.compiled_content(params)
+      "content at #{params[:snapshot].inspect}"
+    end
+
+    # Mock item
+    item = Nanoc::Item.new("foo", {}, '/foo')
+    item.expects(:reps).returns([ rep ])
+
+    # Check
+    assert_equal 'content at :blah', item.compiled_content(:snapshot => :blah)
+  end
+
+  def test_compiled_content_with_custom_nonexistant_rep
+    # Mock item
+    item = Nanoc::Item.new("foo", {}, '/foo')
+    item.expects(:reps).returns([])
+
+    # Check
+    assert_raises(Nanoc::Errors::Generic) do
+      item.compiled_content(:rep => :lkasdhflahgwfe)
+    end
+  end
+
+  def test_path_with_default_rep
+    # Mock reps
+    rep = mock
+    rep.expects(:name).returns(:default)
+    rep.expects(:path).returns('the correct path')
+
+    # Mock item
+    item = Nanoc::Item.new("foo", {}, '/foo')
+    item.expects(:reps).returns([ rep ])
+
+    # Check
+    assert_equal 'the correct path', item.path
+  end
+
+  def test_path_with_custom_rep
+    # Mock reps
+    rep = mock
+    rep.expects(:name).returns(:moo)
+    rep.expects(:path).returns('the correct path')
+
+    # Mock item
+    item = Nanoc::Item.new("foo", {}, '/foo')
+    item.expects(:reps).returns([ rep ])
+
+    # Check
+    assert_equal 'the correct path', item.path(:rep => :moo)
+  end
+
+  def test_freeze_should_disallow_changes
+    item = Nanoc::Item.new("foo", { :a => { :b => 123 }}, '/foo/')
+    item.freeze
+
+    raised = false
+    begin
+      item[:abc] = '123'
+    rescue => e
+      raised = true
+      assert_match /^can't modify frozen /, e.message
+    end
+    assert raised
+
+    raised = false
+    begin
+      item[:a][:b] = '456'
+    rescue => e
+      raised = true
+      assert_match /^can't modify frozen /, e.message
+    end
+    assert raised
+  end
+
+  def test_dump_and_load
+    item = Nanoc::Item.new(
+      "foobar",
+      { :a => { :b => 123 }},
+      '/foo/')
+
+    item = Marshal.load(Marshal.dump(item))
+
+    assert_equal '/foo/', item.identifier
+    assert_equal 'foobar', item.raw_content
+    assert_equal({ :a => { :b => 123 }}, item.attributes)
+  end
+
+end