nanoc 4.0.2 → 4.1.0a1

data/test/base/test_compiler.rb

@@ -1,28 +1,44 @@
 class Nanoc::Int::CompilerTest < Nanoc::TestCase
-  def test_compilation_rule_for
-    # Mock rules
-    rules = [mock, mock, mock]
-    rules[0].expects(:applicable_to?).returns(false)
-    rules[1].expects(:applicable_to?).returns(true)
-    rules[1].expects(:rep_name).returns('wrong')
-    rules[2].expects(:applicable_to?).returns(true)
-    rules[2].expects(:rep_name).returns('right')
-
-    # Create compiler
-    compiler = Nanoc::Int::Compiler.new(nil)
-    compiler.rules_collection.instance_eval { @item_compilation_rules = rules }
-
-    # Mock rep
-    rep = mock
-    rep.stubs(:name).returns('right')
-    item = mock
-    rep.stubs(:item).returns(item)
+  def new_compiler(site = nil)
+    site ||= Nanoc::Int::Site.new(
+      config: nil,
+      code_snippets: [],
+      items: [],
+      layouts: [],
+    )
+
+    rules_collection = Nanoc::Int::RulesCollection.new
+
+    reps = Nanoc::Int::ItemRepRepo.new
+
+    params = {
+      compiled_content_cache: Nanoc::Int::CompiledContentCache.new,
+      checksum_store: Nanoc::Int::ChecksumStore.new(site: site),
+      rule_memory_store: Nanoc::Int::RuleMemoryStore.new,
+      rule_memory_calculator: Nanoc::Int::RuleMemoryCalculator.new(
+        rules_collection: rules_collection,
+        site: site,
+      ),
+      dependency_store: Nanoc::Int::DependencyStore.new(
+        site.items.to_a + site.layouts.to_a),
+      reps: reps,
+    }
 
-    # Test
-    assert_equal rules[2], compiler.rules_collection.compilation_rule_for(rep)
+    params[:outdatedness_checker] =
+      Nanoc::Int::OutdatednessChecker.new(
+        site: site,
+        checksum_store: params[:checksum_store],
+        dependency_store: params[:dependency_store],
+        rules_collection: params[:rules_collection],
+        rule_memory_store: params[:rule_memory_store],
+        rule_memory_calculator: params[:rule_memory_calculator],
+        reps: reps,
+      )
+
+    Nanoc::Int::Compiler.new(site, rules_collection, params)
   end
 
-  def test_routing_rule_for
+  def test_compilation_rule_for
     # Mock rules
     rules = [mock, mock, mock]
     rules[0].expects(:applicable_to?).returns(false)
@@ -32,8 +48,8 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
     rules[2].expects(:rep_name).returns('right')
 
     # Create compiler
-    compiler = Nanoc::Int::Compiler.new(nil)
-    compiler.rules_collection.instance_eval { @item_routing_rules = rules }
+    compiler = new_compiler
+    compiler.rules_collection.instance_eval { @item_compilation_rules = rules }
 
     # Mock rep
     rep = mock
@@ -42,15 +58,12 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
     rep.stubs(:item).returns(item)
 
     # Test
-    assert_equal rules[2], compiler.rules_collection.routing_rule_for(rep)
+    assert_equal rules[2], compiler.rules_collection.compilation_rule_for(rep)
   end
 
   def test_filter_for_layout_with_existant_layout
-    # Mock site
-    site = mock
-
     # Create compiler
-    compiler = Nanoc::Int::Compiler.new(site)
+    compiler = new_compiler
     compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(/.*/)] = [:erb, { foo: 'bar' }]
 
     # Mock layout
@@ -62,11 +75,8 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
   end
 
   def test_filter_for_layout_with_existant_layout_and_unknown_filter
-    # Mock site
-    site = mock
-
     # Create compiler
-    compiler = Nanoc::Int::Compiler.new(site)
+    compiler = new_compiler
     compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(/.*/)] = [:some_unknown_filter, { foo: 'bar' }]
 
     # Mock layout
@@ -78,11 +88,8 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
   end
 
   def test_filter_for_layout_with_nonexistant_layout
-    # Mock site
-    site = mock
-
     # Create compiler
-    compiler = Nanoc::Int::Compiler.new(site)
+    compiler = new_compiler
     compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/foo/$})] = [:erb, { foo: 'bar' }]
 
     # Mock layout
@@ -94,11 +101,8 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
   end
 
   def test_filter_for_layout_with_many_layouts
-    # Mock site
-    site = mock
-
     # Create compiler
-    compiler = Nanoc::Int::Compiler.new(site)
+    compiler = new_compiler
     compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/a/b/c/.*/$})] = [:erb, { char: 'd' }]
     compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/a/.*/$})]     = [:erb, { char: 'b' }]
     compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/a/b/.*/$})]   = [:erb, { char: 'c' }] # never used!
@@ -159,7 +163,7 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
     site.stubs(:layouts).returns([layout])
 
     # Create compiler
-    compiler = Nanoc::Int::Compiler.new(site)
+    compiler = new_compiler(site)
     compiler.rules_collection.expects(:compilation_rule_for).times(2).with(rep).returns(rule)
     compiler.rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/blah/$})] = [:erb, {}]
     site.stubs(:compiler).returns(compiler)
@@ -271,7 +275,7 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
 
       # Create site
       site = Nanoc::Int::SiteLoader.new.new_from_cwd
-      error = assert_raises(RuntimeError) do
+      error = assert_raises(Nanoc::Error) do
         site.compile
       end
       assert_match(/^The path returned for the.*does not start with a slash. Please ensure that all routing rules return a path that starts with a slash./, error.message)
@@ -299,31 +303,12 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
 
       # Create site
       site = Nanoc::Int::SiteLoader.new.new_from_cwd
-      assert_raises(Nanoc::Int::Compiler::IdenticalRoutesError) do
+      assert_raises(Nanoc::Int::ItemRepRouter::IdenticalRoutesError) do
         site.compile
       end
     end
   end
 
-  def test_load_should_be_idempotent
-    # Create site
-    Nanoc::CLI.run %w( create_site bar)
-
-    FileUtils.cd('bar') do
-      site = Nanoc::Int::SiteLoader.new.new_from_cwd
-
-      compiler = Nanoc::Int::Compiler.new(site)
-      def compiler.route_reps
-        raise 'oh my gosh it is borken'
-      end
-
-      assert site.instance_eval { !@loaded }
-      assert_raises(RuntimeError) { compiler.load }
-      assert site.instance_eval { !@loaded }
-      assert_raises(RuntimeError) { compiler.load }
-    end
-  end
-
   def test_compile_should_recompile_all_reps
     Nanoc::CLI.run %w( create_site bar )
 
@@ -335,7 +320,7 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
 
       # At this point, even the already compiled items in the previous pass
       # should have their compiled content assigned, so this should work:
-      site.items['/index.*'].reps[0].compiled_content
+      site.compiler.reps[site.items['/index.*']][0].compiled_content
     end
   end
 
@@ -584,41 +569,6 @@ class Nanoc::Int::CompilerTest < Nanoc::TestCase
     end
   end
 
-  def test_compiler_dependency_on_unmet_dependency
-    with_site do
-      File.open('content/a.html', 'w') do |io|
-        io.write('<% @items["/b/"].compiled_content %>')
-      end
-      File.open('content/b.html', 'w') do |io|
-        io.write('I am feeling so dependent!')
-      end
-      File.open('Rules', 'w') do |io|
-        io.write "compile '*' do\n"
-        io.write "  filter :erb\n"
-        io.write "end\n"
-        io.write "\n"
-        io.write "route '*' do\n"
-        io.write "  item.identifier.chop + '.' + item[:extension]\n"
-        io.write "end\n"
-        io.write "\n"
-        io.write "layout '*', :erb\n"
-      end
-
-      site = Nanoc::Int::SiteLoader.new.new_from_cwd
-      site.compiler.load
-      rep = site.items['/a/'].reps[0]
-      dt = site.compiler.dependency_tracker
-      dt.start
-      assert_raises Nanoc::Int::Errors::UnmetDependency do
-        site.compiler.send :compile_rep, rep
-      end
-      dt.stop
-
-      stack = dt.instance_eval { @stack }
-      assert_empty stack
-    end
-  end
-
   def test_find_layouts_by_glob
     Nanoc::CLI.run %w( create_site bar )
     FileUtils.cd('bar') do

data/test/base/test_compiler_dsl.rb

@@ -12,7 +12,7 @@ class Nanoc::Int::CompilerDSLTest < Nanoc::TestCase
   end
 
   def test_preprocess_twice
-    rules_collection = Nanoc::Int::RulesCollection.new(nil)
+    rules_collection = Nanoc::Int::RulesCollection.new
     compiler_dsl = Nanoc::Int::CompilerDSL.new(rules_collection, {})
 
     # first time
@@ -30,61 +30,135 @@ class Nanoc::Int::CompilerDSLTest < Nanoc::TestCase
     assert_match(/WARNING: A preprocess block is already defined./, io[:stderr])
   end
 
+  def test_postprocess_twice
+    rules_collection = Nanoc::Int::RulesCollection.new
+    compiler_dsl = Nanoc::Int::CompilerDSL.new(rules_collection, {})
+
+    # first time
+    io = capturing_stdio do
+      compiler_dsl.postprocess {}
+    end
+    assert_empty io[:stdout]
+    assert_empty io[:stderr]
+
+    # second time
+    io = capturing_stdio do
+      compiler_dsl.postprocess {}
+    end
+    assert_empty io[:stdout]
+    assert_match(/WARNING: A postprocess block is already defined./, io[:stderr])
+  end
+
   def test_per_rules_file_preprocessor
     # Create site
-    Nanoc::CLI.run %w( create_site per-rules-file-preprocessor )
-    FileUtils.cd('per-rules-file-preprocessor') do
-      # Create rep
-      item = Nanoc::Int::Item.new('foo', { extension: 'bar' }, '/foo/')
-
+    Nanoc::CLI.run %w( create_site foo )
+    FileUtils.cd('foo') do
       # Create a bonus rules file
-      File.open('more_rules.rb', 'w') { |io| io.write "preprocess { @items['/foo/'][:preprocessed] = true }" }
+      File.write(
+        'more_rules.rb',
+        "preprocess { @items['/index.*'][:preprocessed] = true }")
 
-      # Create other necessary stuff
-      site = Nanoc::Int::SiteLoader.new.new_from_cwd
-      site.items << item
-      dsl = site.compiler.rules_collection.dsl
-      io = capturing_stdio do
-        dsl.preprocess {}
-      end
-      assert_empty io[:stdout]
-      assert_empty io[:stderr]
+      # Adjust normal rules file
+      File.write(
+        'Rules',
+        "include_rules 'more_rules'\n\npreprocess {}\n\n" + File.read('Rules'))
 
-      # Include rules
-      dsl.include_rules 'more_rules'
+      # Create site and compiler
+      site = Nanoc::Int::SiteLoader.new.new_from_cwd
+      compiler = Nanoc::Int::CompilerLoader.new.load(site)
 
       # Check that the two preprocess blocks have been added
-      assert_equal 2, site.compiler.rules_collection.preprocessors.size
-      refute_nil site.compiler.rules_collection.preprocessors.first
-      refute_nil site.compiler.rules_collection.preprocessors.to_a.last
+      assert_equal 2, compiler.rules_collection.preprocessors.size
+      refute_nil compiler.rules_collection.preprocessors.first
+      refute_nil compiler.rules_collection.preprocessors.to_a.last
 
       # Apply preprocess blocks
-      site.compiler.preprocess
-      assert item.attributes[:preprocessed]
+      Nanoc::Int::Preprocessor
+        .new(site: site, rules_collection: compiler.rules_collection)
+        .run
+      assert site.items['/index.*'].attributes[:preprocessed]
     end
   end
 
-  def test_include_rules
+  def test_per_rules_file_postprocessor
     # Create site
-    Nanoc::CLI.run %w( create_site with_bonus_rules )
-    FileUtils.cd('with_bonus_rules') do
-      # Create rep
-      item = Nanoc::Int::Item.new('foo', { extension: 'bar' }, '/foo/')
-      rep  = Nanoc::Int::ItemRep.new(item, :default)
-
+    Nanoc::CLI.run %w( create_site foo )
+    FileUtils.cd('foo') do
       # Create a bonus rules file
-      File.open('more_rules.rb', 'w') { |io| io.write "passthrough '/foo/'" }
+      File.write(
+        'more_rules.rb',
+        'postprocess {}')
 
-      # Create other necessary stuff
+      # Adjust normal rules file
+      File.write(
+        'Rules',
+        "include_rules 'more_rules'\n\npostprocess {}\n\n" + File.read('Rules'))
+
+      # Create site and compiler
       site = Nanoc::Int::SiteLoader.new.new_from_cwd
-      site.items << item
-      dsl = site.compiler.rules_collection.dsl
+      compiler = Nanoc::Int::CompilerLoader.new.load(site)
 
-      # Include rules
-      dsl.include_rules 'more_rules'
+      # Check that the two postprocess blocks have been added
+      assert_equal 2, compiler.rules_collection.postprocessors.size
+      refute_nil compiler.rules_collection.postprocessors.first
+      refute_nil compiler.rules_collection.postprocessors.to_a.last
+    end
+  end
 
-      # Check that the rule made it into the collection
-      refute_nil site.compiler.rules_collection.routing_rule_for(rep)
+  def test_postprocessor_modified_method
+    with_site do |site|
+      # Create rules
+      File.open('Rules', 'w') do |io|
+        io.write <<EOS
+compile '*' do
+end
+route '*' do
+end
+postprocess do
+  puts @items.select(&:modified).length
+end
+EOS
+      end
+
+      File.open('content/index.html', 'w') { |io| io.write('o hello') }
+
+      io = capturing_stdio do
+        site = Nanoc::Int::SiteLoader.new.new_from_cwd
+        site.compile
+      end
+
+      assert_match(/1/, io[:stdout])
+    end
+  end
+
+  def test_include_rules
+    # Create site
+    Nanoc::CLI.run %w( create_site foo )
+    FileUtils.cd('foo') do
+      # Create a bonus rules file
+      File.write(
+        'more_rules.rb',
+        "passthrough '/index.*'")
+
+      # Adjust normal rules file
+      File.write(
+        'Rules',
+        "include_rules 'more_rules'\n\n" \
+          "route '/**/*' do ; nil ; end\n\n" \
+          "compile '/**/*' do ; end\n")
+
+      # Create site and compiler
+      site = Nanoc::Int::SiteLoader.new.new_from_cwd
+      compiler = Nanoc::Int::CompilerLoader.new.load(site)
+      compiler.build_reps
+
+      # Check
+      rep = compiler.reps[site.items['/index.*']][0]
+      routing_rules = site.compiler.rules_collection.routing_rules_for(rep)
+      routing_rule = routing_rules[:last]
+      refute_nil routing_rule
+      assert_equal Nanoc::Int::StringPattern, routing_rule.pattern.class
+      assert_equal '/index.*', routing_rule.pattern.to_s
     end
   end
 
@@ -92,7 +166,7 @@ class Nanoc::Int::CompilerDSLTest < Nanoc::TestCase
     with_site do
       # Create rules
       File.open('Rules', 'w') do |io|
-        io.write <<EOS
+        io.write <<-EOS
 passthrough "/robots/"
 
 compile '*' do ; end

data/test/base/test_dependency_tracker.rb

@@ -4,11 +4,11 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items = [mock, mock]
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Verify no dependencies yet
-    assert_empty tracker.objects_causing_outdatedness_of(items[0])
-    assert_empty tracker.objects_causing_outdatedness_of(items[1])
+    assert_empty store.objects_causing_outdatedness_of(items[0])
+    assert_empty store.objects_causing_outdatedness_of(items[1])
   end
 
   def test_record_dependency
@@ -16,13 +16,13 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items = [mock, mock]
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
+    store.record_dependency(items[0], items[1])
 
     # Verify dependencies
-    assert_contains_exactly [items[1]], tracker.objects_causing_outdatedness_of(items[0])
+    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
   end
 
   def test_record_dependency_no_self
@@ -30,14 +30,14 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items = [mock, mock]
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Record some dependencies
-    tracker.record_dependency(items[0], items[0])
-    tracker.record_dependency(items[0], items[1])
+    store.record_dependency(items[0], items[0])
+    store.record_dependency(items[0], items[1])
 
     # Verify dependencies
-    assert_contains_exactly [items[1]], tracker.objects_causing_outdatedness_of(items[0])
+    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
   end
 
   def test_record_dependency_no_doubles
@@ -45,15 +45,15 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items = [mock, mock]
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[0], items[1])
+    store.record_dependency(items[0], items[1])
+    store.record_dependency(items[0], items[1])
+    store.record_dependency(items[0], items[1])
 
     # Verify dependencies
-    assert_contains_exactly [items[1]], tracker.objects_causing_outdatedness_of(items[0])
+    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
   end
 
   def test_objects_causing_outdatedness_of
@@ -61,14 +61,14 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items = [mock, mock, mock]
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], items[2])
+    store.record_dependency(items[0], items[1])
+    store.record_dependency(items[1], items[2])
 
     # Verify dependencies
-    assert_contains_exactly [items[1]], tracker.objects_causing_outdatedness_of(items[0])
+    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
   end
 
   def test_objects_outdated_due_to
@@ -76,14 +76,14 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items = [mock, mock, mock]
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], items[2])
+    store.record_dependency(items[0], items[1])
+    store.record_dependency(items[1], items[2])
 
     # Verify dependencies
-    assert_contains_exactly [items[0]], tracker.objects_outdated_due_to(items[1])
+    assert_contains_exactly [items[0]], store.objects_outdated_due_to(items[1])
   end
 
   def test_start_and_stop
@@ -91,19 +91,20 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items = [mock, mock]
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
+    tracker = Nanoc::Int::DependencyTracker.new(store)
 
     # Start, do something and stop
-    tracker.start
-    Nanoc::Int::NotificationCenter.post(:visit_started, items[0])
-    Nanoc::Int::NotificationCenter.post(:visit_started, items[1])
-    Nanoc::Int::NotificationCenter.post(:visit_ended,   items[1])
-    Nanoc::Int::NotificationCenter.post(:visit_ended,   items[0])
-    tracker.stop
+    tracker.run do
+      Nanoc::Int::NotificationCenter.post(:visit_started, items[0])
+      Nanoc::Int::NotificationCenter.post(:visit_started, items[1])
+      Nanoc::Int::NotificationCenter.post(:visit_ended,   items[1])
+      Nanoc::Int::NotificationCenter.post(:visit_ended,   items[0])
+    end
 
     # Verify dependencies
-    assert_contains_exactly [items[1]], tracker.objects_causing_outdatedness_of(items[0])
-    assert_empty tracker.objects_causing_outdatedness_of(items[1])
+    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
+    assert_empty store.objects_causing_outdatedness_of(items[1])
   end
 
   def test_store_graph_and_load_graph_simple
@@ -116,28 +117,28 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items[3].stubs(:reference).returns([:item, '/ddd/'])
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], items[2])
-    tracker.record_dependency(items[1], items[3])
+    store.record_dependency(items[0], items[1])
+    store.record_dependency(items[1], items[2])
+    store.record_dependency(items[1], items[3])
 
     # Store
-    tracker.store
-    assert File.file?(tracker.filename)
+    store.store
+    assert File.file?(store.filename)
 
     # Re-create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Load
-    tracker.load
+    store.load
 
     # Check loaded graph
-    assert_contains_exactly [items[1]],           tracker.objects_causing_outdatedness_of(items[0])
-    assert_contains_exactly [items[2], items[3]], tracker.objects_causing_outdatedness_of(items[1])
-    assert_empty tracker.objects_causing_outdatedness_of(items[2])
-    assert_empty tracker.objects_causing_outdatedness_of(items[3])
+    assert_contains_exactly [items[1]],           store.objects_causing_outdatedness_of(items[0])
+    assert_contains_exactly [items[2], items[3]], store.objects_causing_outdatedness_of(items[1])
+    assert_empty store.objects_causing_outdatedness_of(items[2])
+    assert_empty store.objects_causing_outdatedness_of(items[3])
   end
 
   def test_store_graph_and_load_graph_with_removed_items
@@ -154,27 +155,27 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     new_items = [items[0], items[1], items[2]]
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(old_items)
+    store = Nanoc::Int::DependencyStore.new(old_items)
 
     # Record some dependencies
-    tracker.record_dependency(old_items[0], old_items[1])
-    tracker.record_dependency(old_items[1], old_items[2])
-    tracker.record_dependency(old_items[1], old_items[3])
+    store.record_dependency(old_items[0], old_items[1])
+    store.record_dependency(old_items[1], old_items[2])
+    store.record_dependency(old_items[1], old_items[3])
 
     # Store
-    tracker.store
-    assert File.file?(tracker.filename)
+    store.store
+    assert File.file?(store.filename)
 
     # Re-create
-    tracker = Nanoc::Int::DependencyTracker.new(new_items)
+    store = Nanoc::Int::DependencyStore.new(new_items)
 
     # Load
-    tracker.load
+    store.load
 
     # Check loaded graph
-    assert_contains_exactly [items[1]],       tracker.objects_causing_outdatedness_of(items[0])
-    assert_contains_exactly [items[2], nil],  tracker.objects_causing_outdatedness_of(items[1])
-    assert_empty tracker.objects_causing_outdatedness_of(items[2])
+    assert_contains_exactly [items[1]],       store.objects_causing_outdatedness_of(items[0])
+    assert_contains_exactly [items[2], nil],  store.objects_causing_outdatedness_of(items[1])
+    assert_empty store.objects_causing_outdatedness_of(items[2])
   end
 
   def test_store_graph_with_nils_in_dst
@@ -186,25 +187,25 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items[2].stubs(:reference).returns([:item, '/ccc/'])
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], nil)
+    store.record_dependency(items[0], items[1])
+    store.record_dependency(items[1], nil)
 
     # Store
-    tracker.store
-    assert File.file?(tracker.filename)
+    store.store
+    assert File.file?(store.filename)
 
     # Re-create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Load
-    tracker.load
+    store.load
 
     # Check loaded graph
-    assert_contains_exactly [items[1]], tracker.objects_causing_outdatedness_of(items[0])
-    assert_contains_exactly [nil],      tracker.objects_causing_outdatedness_of(items[1])
+    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
+    assert_contains_exactly [nil],      store.objects_causing_outdatedness_of(items[1])
   end
 
   def test_store_graph_with_nils_in_src
@@ -216,25 +217,25 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items[2].stubs(:reference).returns([:item, '/ccc/'])
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(nil,      items[2])
+    store.record_dependency(items[0], items[1])
+    store.record_dependency(nil,      items[2])
 
     # Store
-    tracker.store
-    assert File.file?(tracker.filename)
+    store.store
+    assert File.file?(store.filename)
 
     # Re-create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Load
-    tracker.load
+    store.load
 
     # Check loaded graph
-    assert_contains_exactly [items[1]], tracker.objects_causing_outdatedness_of(items[0])
-    assert_empty tracker.objects_causing_outdatedness_of(items[1])
+    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
+    assert_empty store.objects_causing_outdatedness_of(items[1])
   end
 
   def test_forget_dependencies_for
@@ -242,15 +243,15 @@ class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
     items = [mock, mock, mock]
 
     # Create
-    tracker = Nanoc::Int::DependencyTracker.new(items)
+    store = Nanoc::Int::DependencyStore.new(items)
 
     # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], items[2])
-    assert_contains_exactly [items[1]], tracker.objects_causing_outdatedness_of(items[0])
+    store.record_dependency(items[0], items[1])
+    store.record_dependency(items[1], items[2])
+    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
 
     # Forget dependencies
-    tracker.forget_dependencies_for(items[0])
-    assert_empty tracker.objects_causing_outdatedness_of(items[0])
+    store.forget_dependencies_for(items[0])
+    assert_empty store.objects_causing_outdatedness_of(items[0])
   end
 end