nanoc 3.7.3 → 3.7.4

data/test/base/test_directed_graph.rb

@@ -3,78 +3,78 @@
 class Nanoc::DirectedGraphTest < Nanoc::TestCase
 
   def test_direct_predecessors
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    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)
+    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 = 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
+    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 = 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 [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 = 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 [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 = 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
+    assert_equal [[0, 1], [1, 2]], graph.edges.sort
   end
 
   def test_edges_with_new_vertices
-    graph = Nanoc::DirectedGraph.new([ 1 ])
-    assert_equal [ 1 ], graph.vertices
+    graph = Nanoc::DirectedGraph.new([1])
+    assert_equal [1], graph.vertices
     graph.add_edge(1, 2)
-    assert_equal [ 1, 2 ], graph.vertices
+    assert_equal [1, 2], graph.vertices
     graph.add_edge(3, 2)
-    assert_equal [ 1, 2, 3 ], graph.vertices
+    assert_equal [1, 2, 3], graph.vertices
 
-    assert_equal [ [ 0, 1 ], [ 2, 1 ] ], graph.edges.sort
+    assert_equal [[0, 1], [2, 1]], graph.edges.sort
   end
 
   def test_add_edge
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    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)
+    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 = Nanoc::DirectedGraph.new([1])
     graph.add_edge(1, 2)
     graph.add_edge(3, 2)
 
@@ -83,11 +83,11 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
   end
 
   def test_delete_edge
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    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)
+    assert_equal [2], graph.successors_of(1)
+    assert_equal [1], graph.predecessors_of(2)
 
     graph.delete_edge(1, 2)
 
@@ -96,7 +96,7 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
   end
 
   def test_delete_edges_from
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph = Nanoc::DirectedGraph.new([1, 2, 3])
 
     graph.add_edge(1, 2)
     graph.add_edge(2, 1)
@@ -105,37 +105,37 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
     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 [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 [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
+    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 = Nanoc::DirectedGraph.new([1, 2, 3])
 
     graph.add_edge(1, 2)
     graph.add_edge(2, 1)
@@ -144,37 +144,37 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
     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 [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
+    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
+    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 = Nanoc::DirectedGraph.new([1, 2, 3])
 
     graph.add_edge(1, 2)
     graph.add_edge(2, 1)
@@ -185,27 +185,27 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
 
     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 [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 = 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
+    assert_equal Set.new([1]), graph.roots
 
     graph.delete_vertex(2)
-    assert_equal Set.new([ 1, 3 ]), graph.roots
+    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 ])
+    graph = Nanoc::DirectedGraph.new([1, 2, 3])
 
     assert_equal [], graph.direct_predecessors_of(4)
     assert_equal [], graph.predecessors_of(4)
@@ -214,30 +214,30 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
   end
 
   def test_roots_after_init
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph = Nanoc::DirectedGraph.new([1, 2, 3])
 
-    assert_equal Set.new([ 1, 2, 3 ]), graph.roots
+    assert_equal Set.new([1, 2, 3]), graph.roots
   end
 
   def test_roots_after_adding_edge
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph = Nanoc::DirectedGraph.new([1, 2, 3])
     graph.add_edge(1, 2)
-    assert_equal Set.new([ 1, 3 ]), graph.roots
+    assert_equal Set.new([1, 3]), graph.roots
 
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph = Nanoc::DirectedGraph.new([1, 2, 3])
     graph.add_edge(1, 3)
-    assert_equal Set.new([ 1, 2 ]), graph.roots
+    assert_equal Set.new([1, 2]), graph.roots
 
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph = Nanoc::DirectedGraph.new([1, 2, 3])
     graph.add_edge(2, 1)
-    assert_equal Set.new([ 2, 3 ]), graph.roots
+    assert_equal Set.new([2, 3]), graph.roots
 
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph = Nanoc::DirectedGraph.new([1, 2, 3])
     graph.add_edge(1, 2)
     graph.add_edge(2, 3)
-    assert_equal Set.new([ 1 ]), graph.roots
+    assert_equal Set.new([1]), graph.roots
 
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph = Nanoc::DirectedGraph.new([1, 2, 3])
     graph.add_edge(1, 2)
     graph.add_edge(2, 3)
     graph.add_edge(3, 1)
@@ -245,40 +245,40 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
   end
 
   def test_roots_after_removing_edge
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    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
+    assert_equal Set.new([1, 2, 3]), graph.roots
 
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    graph = Nanoc::DirectedGraph.new([1, 2, 3])
     graph.add_edge(1, 3)
-    assert_equal Set.new([ 1, 2 ]), graph.roots
+    assert_equal Set.new([1, 2]), graph.roots
     graph.delete_edge(1, 2) # no such edge
-    assert_equal Set.new([ 1, 2 ]), graph.roots
+    assert_equal Set.new([1, 2]), graph.roots
 
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    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
+    assert_equal Set.new([1, 2, 3]), graph.roots
 
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    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
+    assert_equal Set.new([1, 2]), graph.roots
     graph.delete_edge(2, 3)
-    assert_equal Set.new([ 1, 2, 3 ]), graph.roots
+    assert_equal Set.new([1, 2, 3]), graph.roots
 
-    graph = Nanoc::DirectedGraph.new([ 1, 2, 3 ])
+    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
+    assert_equal Set.new([2]), graph.roots
     graph.delete_edge(2, 3)
-    assert_equal Set.new([ 2, 3 ]), graph.roots
+    assert_equal Set.new([2, 3]), graph.roots
     graph.delete_edge(3, 1)
-    assert_equal Set.new([ 1, 2, 3 ]), graph.roots
+    assert_equal Set.new([1, 2, 3]), graph.roots
   end
 
   def test_example

data/test/base/test_item.rb

@@ -3,20 +3,20 @@
 class Nanoc::ItemTest < Nanoc::TestCase
 
   def test_initialize_with_attributes_with_string_keys
-    item = Nanoc::Item.new("foo", { 'abc' => 'xyz' }, '/foo/')
+    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')
+    item = Nanoc::Item.new('foo', {}, '/foo')
 
     assert_equal '/foo/', item.identifier
   end
 
   def test_frozen_identifier
-    item = Nanoc::Item.new("foo", {}, '/foo')
+    item = Nanoc::Item.new('foo', {}, '/foo')
 
     assert_raises_frozen_error do
       item.identifier.chop!
@@ -26,7 +26,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
   def test_lookup
     # Create item
     item = Nanoc::Item.new(
-      "content",
+      'content',
       { :one => 'one in item' },
       '/path/'
     )
@@ -39,7 +39,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
   end
 
   def test_set_attribute
-    item = Nanoc::Item.new("foo", {}, '/foo')
+    item = Nanoc::Item.new('foo', {}, '/foo')
     assert_equal nil, item[:motto]
 
     item[:motto] = 'More human than human'
@@ -49,14 +49,14 @@ class Nanoc::ItemTest < Nanoc::TestCase
   def test_compiled_content_with_default_rep_and_default_snapshot
     # Mock rep
     rep = Object.new
-    def rep.name ; :default ; end
+    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 ])
+    item = Nanoc::Item.new('foo', {}, '/foo')
+    item.expects(:reps).returns([rep])
 
     # Check
     assert_equal 'content at nil', item.compiled_content
@@ -65,14 +65,14 @@ class Nanoc::ItemTest < Nanoc::TestCase
   def test_compiled_content_with_custom_rep_and_default_snapshot
     # Mock reps
     rep = Object.new
-    def rep.name ; :foo ; end
+    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 ])
+    item = Nanoc::Item.new('foo', {}, '/foo')
+    item.expects(:reps).returns([rep])
 
     # Check
     assert_equal 'content at nil', item.compiled_content(:rep => :foo)
@@ -81,14 +81,14 @@ class Nanoc::ItemTest < Nanoc::TestCase
   def test_compiled_content_with_default_rep_and_custom_snapshot
     # Mock reps
     rep = Object.new
-    def rep.name ; :default ; end
+    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 ])
+    item = Nanoc::Item.new('foo', {}, '/foo')
+    item.expects(:reps).returns([rep])
 
     # Check
     assert_equal 'content at :blah', item.compiled_content(:snapshot => :blah)
@@ -96,7 +96,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
 
   def test_compiled_content_with_custom_nonexistant_rep
     # Mock item
-    item = Nanoc::Item.new("foo", {}, '/foo')
+    item = Nanoc::Item.new('foo', {}, '/foo')
     item.expects(:reps).returns([])
 
     # Check
@@ -112,8 +112,8 @@ class Nanoc::ItemTest < Nanoc::TestCase
     rep.expects(:path).returns('the correct path')
 
     # Mock item
-    item = Nanoc::Item.new("foo", {}, '/foo')
-    item.expects(:reps).returns([ rep ])
+    item = Nanoc::Item.new('foo', {}, '/foo')
+    item.expects(:reps).returns([rep])
 
     # Check
     assert_equal 'the correct path', item.path
@@ -126,15 +126,15 @@ class Nanoc::ItemTest < Nanoc::TestCase
     rep.expects(:path).returns('the correct path')
 
     # Mock item
-    item = Nanoc::Item.new("foo", {}, '/foo')
-    item.expects(:reps).returns([ rep ])
+    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 = Nanoc::Item.new('foo', { :a => { :b => 123 }}, '/foo/')
     item.freeze
 
     assert_raises_frozen_error do
@@ -148,7 +148,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
 
   def test_dump_and_load
     item = Nanoc::Item.new(
-      "foobar",
+      'foobar',
       { :a => { :b => 123 }},
       '/foo/')