nanoc 4.7.4 → 4.7.5

data/lib/nanoc/base/services/compiler.rb

@@ -1,77 +1,5 @@
 module Nanoc::Int
-  # Responsible for compiling a site’s item representations.
-  #
-  # The compilation process makes use of notifications (see
-  # {Nanoc::Int::NotificationCenter}) to track dependencies between items,
-  # layouts, etc. The following notifications are used:
-  #
-  # * `compilation_started` — indicates that the compiler has started
-  #   compiling this item representation. Has one argument: the item
-  #   representation itself. Only one item can be compiled at a given moment;
-  #   therefore, it is not possible to get two consecutive
-  #   `compilation_started` notifications without also getting a
-  #   `compilation_ended` notification in between them.
-  #
-  # * `compilation_ended` — indicates that the compiler has finished compiling
-  #   this item representation (either successfully or with failure). Has one
-  #   argument: the item representation itself.
-  #
-  # @api private
   class Compiler
-    # Provides common functionality for accesing “context” of an item that is being compiled.
-    class CompilationContext
-      attr_reader :site
-      attr_reader :compiled_content_cache
-      attr_reader :snapshot_repo
-
-      def initialize(action_provider:, reps:, site:, compiled_content_cache:, snapshot_repo:)
-        @action_provider = action_provider
-        @reps = reps
-        @site = site
-        @compiled_content_cache = compiled_content_cache
-        @snapshot_repo = snapshot_repo
-      end
-
-      def filter_name_and_args_for_layout(layout)
-        mem = @action_provider.action_sequence_for(layout)
-        if mem.nil? || mem.size != 1 || !mem[0].is_a?(Nanoc::Int::ProcessingActions::Filter)
-          raise Nanoc::Int::Errors::UndefinedFilterForLayout.new(layout)
-        end
-        [mem[0].filter_name, mem[0].params]
-      end
-
-      def create_view_context(dependency_tracker)
-        Nanoc::ViewContext.new(
-          reps: @reps,
-          items: @site.items,
-          dependency_tracker: dependency_tracker,
-          compilation_context: self,
-          snapshot_repo: @snapshot_repo,
-        )
-      end
-
-      def assigns_for(rep, dependency_tracker)
-        last_content = @snapshot_repo.get(rep, :last)
-        content_or_filename_assigns =
-          if last_content.binary?
-            { filename: last_content.filename }
-          else
-            { content: last_content.string }
-          end
-
-        view_context = create_view_context(dependency_tracker)
-
-        content_or_filename_assigns.merge(
-          item: Nanoc::ItemWithRepsView.new(rep.item, view_context),
-          rep: Nanoc::ItemRepView.new(rep, view_context),
-          item_rep: Nanoc::ItemRepView.new(rep, view_context),
-          items: Nanoc::ItemCollectionWithRepsView.new(@site.items, view_context),
-          layouts: Nanoc::LayoutCollectionView.new(@site.layouts, view_context),
-          config: Nanoc::ConfigView.new(@site.config, view_context),
-        )
-      end
-    end
-
     include Nanoc::Int::ContractsSupport
 
     # @api private
@@ -92,9 +20,6 @@ module Nanoc::Int
     # @api private
     attr_reader :dependency_store
 
-    # @api private
-    attr_reader :outdatedness_checker
-
     # @api private
     attr_reader :reps
 
@@ -104,14 +29,13 @@ module Nanoc::Int
     # @api private
     attr_reader :snapshot_repo
 
-    def initialize(site, compiled_content_cache:, checksum_store:, action_sequence_store:, action_provider:, dependency_store:, outdatedness_checker:, reps:, outdatedness_store:)
+    def initialize(site, compiled_content_cache:, checksum_store:, action_sequence_store:, action_provider:, dependency_store:, reps:, outdatedness_store:)
       @site = site
 
       @compiled_content_cache = compiled_content_cache
       @checksum_store         = checksum_store
       @action_sequence_store  = action_sequence_store
       @dependency_store       = dependency_store
-      @outdatedness_checker   = outdatedness_checker
       @reps                   = reps
       @action_provider        = action_provider
       @outdatedness_store     = outdatedness_store
@@ -120,55 +44,34 @@ module Nanoc::Int
       @snapshot_repo = Nanoc::Int::SnapshotRepo.new
     end
 
-    def run_all
-      time_stage(:preprocess) { preprocess_stage.run }
-      time_stage(:build_reps) { build_reps }
-      time_stage(:prune) { prune_stage.run }
-      time_stage(:load_stores) { load_stores }
-      time_stage(:determine_outdatedness) { determine_outdatedness }
-      time_stage(:forget_dependencies_if_needed) { forget_dependencies_if_needed }
-      time_stage(:store) { store }
-      time_stage(:compile_reps) { compile_reps_stage.run }
-      time_stage(:store_output_state) { store_output_state }
-      time_stage(:postprocess) { @action_provider.postprocess(@site, @reps) }
-    ensure
-      time_stage(:cleanup) { cleanup_stage.run }
-    end
-
-    def load_stores
-      stores.each(&:load)
-    end
-
-    # TODO: rename to store_preprocessed_state
-    def store
-      # Calculate action sequence
-      (@reps.to_a + @site.layouts.to_a).each do |obj|
-        action_sequence_store[obj] = action_provider.action_sequence_for(obj).serialize
-      end
-
-      # Calculate checksums
-      objects_to_checksum =
-        site.items.to_a + site.layouts.to_a + site.code_snippets + [site.config]
-      objects_to_checksum.each { |obj| checksum_store.add(obj) }
-
-      # Store
-      checksum_store.store
-      action_sequence_store.store
-    end
-
-    def store_output_state
-      @dependency_store.store
+    def create_outdatedness_checker
+      Nanoc::Int::OutdatednessChecker.new(
+        site: @site,
+        checksum_store: @checksum_store,
+        dependency_store: @dependency_store,
+        action_sequence_store: @action_sequence_store,
+        action_sequences: @action_sequences,
+        reps: reps,
+      )
     end
 
-    def build_reps
-      builder = Nanoc::Int::ItemRepBuilder.new(
-        site, action_provider, @reps
-      )
-      @action_sequences = builder.run
+    def run_all
+      run_stage(preprocess_stage)
+      @action_sequences = run_stage(build_reps_stage)
+      run_stage(prune_stage)
+      run_stage(load_stores_stage)
+      outdated_items = run_stage(determine_outdatedness_stage)
+      run_stage(forget_outdated_dependencies_stage, outdated_items)
+      run_stage(store_pre_compilation_state_stage)
+      run_stage(compile_reps_stage)
+      run_stage(store_post_compilation_state_stage)
+      run_stage(postprocess_stage)
+    ensure
+      run_stage(cleanup_stage)
     end
 
     def compilation_context
-      @_compilation_context ||= CompilationContext.new(
+      @_compilation_context ||= Nanoc::Int::CompilationContext.new(
         action_provider: action_provider,
         reps: @reps,
         site: @site,
@@ -177,11 +80,22 @@ module Nanoc::Int
       )
     end
 
+    # TODO: remove
+    def load_stores
+      load_stores_stage.run
+    end
+
+    # TODO: remove
+    def build_reps
+      @action_sequences = build_reps_stage.run
+    end
+
     private
 
-    def time_stage(name)
+    def run_stage(stage, *args)
+      name = stage.class.to_s
       Nanoc::Int::NotificationCenter.post(:stage_started, name)
-      yield
+      stage.run(*args)
     ensure
       Nanoc::Int::NotificationCenter.post(:stage_ended, name)
     end
@@ -195,6 +109,14 @@ module Nanoc::Int
       )
     end
 
+    def build_reps_stage
+      @_build_reps_stage ||= Stages::BuildReps.new(
+        site: site,
+        action_provider: action_provider,
+        reps: @reps,
+      )
+    end
+
     def prune_stage
       @_prune_stage ||= Stages::Prune.new(
         config: site.config,
@@ -202,14 +124,37 @@ module Nanoc::Int
       )
     end
 
+    def load_stores_stage
+      @_load_stores_stage ||= Stages::LoadStores.new(
+        checksum_store: checksum_store,
+        compiled_content_cache: compiled_content_cache,
+        dependency_store: @dependency_store,
+        action_sequence_store: action_sequence_store,
+        outdatedness_store: @outdatedness_store,
+      )
+    end
+
     def determine_outdatedness_stage
       @_determine_outdatedness_stage ||= Stages::DetermineOutdatedness.new(
         reps: reps,
-        outdatedness_checker: outdatedness_checker,
+        outdatedness_checker: create_outdatedness_checker,
         outdatedness_store: outdatedness_store,
       )
     end
 
+    def store_pre_compilation_state_stage
+      @_store_pre_compilation_state_stage ||= Stages::StorePreCompilationState.new(
+        reps: @reps,
+        layouts: site.layouts,
+        items: site.items,
+        code_snippets: site.code_snippets,
+        config: site.config,
+        checksum_store: checksum_store,
+        action_sequence_store: action_sequence_store,
+        action_sequences: @action_sequences,
+      )
+    end
+
     def compile_reps_stage
       @_compile_reps_stage ||= Stages::CompileReps.new(
         outdatedness_store: @outdatedness_store,
@@ -220,30 +165,28 @@ module Nanoc::Int
       )
     end
 
-    def cleanup_stage
-      @_cleanup_stage ||= Stages::Cleanup.new(site.config)
+    def store_post_compilation_state_stage
+      @_store_post_compilation_state_stage ||= Stages::StorePostCompilationState.new(
+        dependency_store: dependency_store,
+      )
     end
 
-    def determine_outdatedness
-      determine_outdatedness_stage.run(@action_sequences) do |outdated_items|
-        @outdated_items = outdated_items
-      end
+    def postprocess_stage
+      @_postprocess_stage ||= Stages::Postprocess.new(
+        action_provider: @action_provider,
+        site: @site,
+        reps: @reps,
+      )
     end
 
-    def forget_dependencies_if_needed
-      @outdated_items.each { |i| @dependency_store.forget_dependencies_for(i) }
+    def cleanup_stage
+      @_cleanup_stage ||= Stages::Cleanup.new(site.config)
     end
 
-    # Returns all stores that can load/store data that can be used for
-    # compilation.
-    def stores
-      [
-        checksum_store,
-        compiled_content_cache,
-        @dependency_store,
-        action_sequence_store,
-        @outdatedness_store,
-      ]
+    def forget_outdated_dependencies_stage
+      @_forget_outdated_dependencies_stage ||= Stages::ForgetOutdatedDependencies.new(
+        dependency_store: @dependency_store,
+      )
     end
   end
 end

data/lib/nanoc/base/services/compiler_loader.rb

@@ -19,16 +19,6 @@ module Nanoc::Int
       outdatedness_store =
         Nanoc::Int::OutdatednessStore.new(site: site, reps: item_rep_repo)
 
-      outdatedness_checker =
-        Nanoc::Int::OutdatednessChecker.new(
-          site: site,
-          checksum_store: checksum_store,
-          dependency_store: dependency_store,
-          action_sequence_store: action_sequence_store,
-          action_provider: action_provider,
-          reps: item_rep_repo,
-        )
-
       compiled_content_cache =
         Nanoc::Int::CompiledContentCache.new(
           site: site,
@@ -40,7 +30,6 @@ module Nanoc::Int
         checksum_store: checksum_store,
         action_sequence_store: action_sequence_store,
         dependency_store: dependency_store,
-        outdatedness_checker: outdatedness_checker,
         reps: item_rep_repo,
         action_provider: action_provider,
         outdatedness_store: outdatedness_store,

data/lib/nanoc/base/services/outdatedness_checker.rb

@@ -82,61 +82,46 @@ module Nanoc::Int
     attr_reader :checksum_store
     attr_reader :dependency_store
     attr_reader :action_sequence_store
-    attr_reader :action_provider
+    attr_reader :action_sequences
     attr_reader :site
 
     Reasons = Nanoc::Int::OutdatednessReasons
 
     C_OBJ = C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout]
+    C_ACTION_SEQUENCES = C::HashOf[C_OBJ => Nanoc::Int::ActionSequence]
 
-    # FIXME: Replace C::Any with proper types
-    contract C::KeywordArgs[site: Nanoc::Int::Site, checksum_store: Nanoc::Int::ChecksumStore, dependency_store: Nanoc::Int::DependencyStore, action_sequence_store: Nanoc::Int::ActionSequenceStore, action_provider: C::Any, reps: Nanoc::Int::ItemRepRepo] => C::Any
-    def initialize(site:, checksum_store:, dependency_store:, action_sequence_store:, action_provider:, reps:)
+    contract C::KeywordArgs[site: Nanoc::Int::Site, checksum_store: Nanoc::Int::ChecksumStore, dependency_store: Nanoc::Int::DependencyStore, action_sequence_store: Nanoc::Int::ActionSequenceStore, action_sequences: C_ACTION_SEQUENCES, reps: Nanoc::Int::ItemRepRepo] => C::Any
+    def initialize(site:, checksum_store:, dependency_store:, action_sequence_store:, action_sequences:, reps:)
       @site = site
       @checksum_store = checksum_store
       @dependency_store = dependency_store
       @action_sequence_store = action_sequence_store
-      @action_provider = action_provider
+      @action_sequences = action_sequences
       @reps = reps
 
       @objects_outdated_due_to_dependencies = {}
     end
 
     def action_sequence_for(rep)
-      # TODO: Pass in action_sequences instead
-      @action_provider.action_sequence_for(rep)
+      @action_sequences.fetch(rep)
     end
-    memoize :action_sequence_for
-
-    contract C_OBJ, C::Maybe[C::HashOf[C_OBJ => Nanoc::Int::ActionSequence]] => C::Bool
-    # Checks whether the given object is outdated and therefore needs to be
-    # recompiled.
-    #
-    # @param [Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The object
-    #   whose outdatedness should be checked.
-    #
-    # @return [Boolean] true if the object is outdated, false otherwise
-    def outdated?(obj, _action_sequences = nil)
-      # TODO: use action_sequences
-      !outdatedness_reason_for(obj).nil?
+
+    contract C_OBJ => C::Bool
+    def outdated?(obj)
+      outdatedness_reasons_for(obj).any?
     end
 
-    contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::Maybe[Reasons::Generic]
-    # Calculates the reason why the given object is outdated.
-    #
-    # @param [Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The object
-    #   whose outdatedness reason should be calculated.
-    #
-    # @return [Reasons::Generic, nil] The reason why the
-    #   given object is outdated, or nil if the object is not outdated.
-    def outdatedness_reason_for(obj)
-      reason = basic_outdatedness_reason_for(obj)
-      if reason.nil? && outdated_due_to_dependencies?(obj)
-        reason = Reasons::DependenciesOutdated
+    contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::IterOf[Reasons::Generic]
+    def outdatedness_reasons_for(obj)
+      reasons = basic.outdatedness_status_for(obj).reasons
+      if reasons.any?
+        reasons
+      elsif outdated_due_to_dependencies?(obj)
+        [Reasons::DependenciesOutdated]
+      else
+        []
       end
-      reason
     end
-    memoize :outdatedness_reason_for
 
     private
 
@@ -145,12 +130,6 @@ module Nanoc::Int
       @_basic ||= Basic.new(outdatedness_checker: self, reps: @reps)
     end
 
-    contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::Maybe[Reasons::Generic]
-    def basic_outdatedness_reason_for(obj)
-      # FIXME: Stop using this; it is no longer accurate, as there can be >1 reasons
-      basic.outdatedness_status_for(obj).reasons.first
-    end
-
     contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout], Hamster::Set => C::Bool
     def outdated_due_to_dependencies?(obj, processed = Hamster::Set.new)
       # Convert from rep to item if necessary

data/lib/nanoc/base/services.rb

@@ -1,5 +1,6 @@
 require_relative 'services/action_provider'
 require_relative 'services/checksummer'
+require_relative 'services/compilation_context'
 require_relative 'services/compiler'
 require_relative 'services/compiler_loader'
 require_relative 'services/dependency_tracker'

data/lib/nanoc/base/views/identifiable_collection_view.rb

@@ -43,8 +43,7 @@ module Nanoc
     #
     # @return [Enumerable]
     def find_all(arg)
-      pat = Nanoc::Int::Pattern.from(arg)
-      select { |i| pat.match?(i.identifier) }
+      @objects.find_all(arg).map { |i| view_class.new(i, @context) }
     end
 
     # @overload [](string)

data/lib/nanoc/cli/commands/compile_listeners/timing_recorder.rb

@@ -3,8 +3,8 @@ module Nanoc::CLI::Commands::CompileListeners
     attr_reader :telemetry
 
     # @see Listener#enable_for?
-    def self.enable_for?(command_runner)
-      command_runner.options.fetch(:verbose, false)
+    def self.enable_for?(_command_runner)
+      Nanoc::CLI.verbosity >= 1
     end
 
     # @param [Enumerable<Nanoc::Int::ItemRep>] reps

data/lib/nanoc/cli/commands/show-data.rb

@@ -129,12 +129,7 @@ module Nanoc::CLI::Commands
       sorted_reps_with_prev(items) do |rep, prev|
         puts if prev
         puts "item #{rep.item.identifier}, rep #{rep.name}:"
-        outdatedness_reason = compiler.outdatedness_checker.outdatedness_reason_for(rep)
-        if outdatedness_reason
-          puts "  is outdated: #{outdatedness_reason.message}"
-        else
-          puts '  is not outdated'
-        end
+        print_outdatedness_reasons_for(rep, compiler)
       end
     end
 
@@ -144,13 +139,20 @@ module Nanoc::CLI::Commands
       sorted_with_prev(layouts) do |layout, prev|
         puts if prev
         puts "layout #{layout.identifier}:"
-        outdatedness_reason = compiler.outdatedness_checker.outdatedness_reason_for(layout)
-        if outdatedness_reason
-          puts "  is outdated: #{outdatedness_reason.message}"
-        else
-          puts '  is not outdated'
+        print_outdatedness_reasons_for(layout, compiler)
+      end
+    end
+
+    def print_outdatedness_reasons_for(obj, compiler)
+      outdatedness_checker = compiler.create_outdatedness_checker
+      reasons = outdatedness_checker.outdatedness_reasons_for(obj)
+      if reasons.any?
+        puts '  is outdated:'
+        reasons.each do |reason|
+          puts "    - #{reason.message}"
         end
-        puts
+      else
+        puts '  is not outdated'
       end
     end
   end

data/lib/nanoc/version.rb

@@ -1,4 +1,4 @@
 module Nanoc
   # The current Nanoc version.
-  VERSION = '4.7.4'.freeze
+  VERSION = '4.7.5'.freeze
 end

data/spec/nanoc/base/compiler_spec.rb

@@ -7,7 +7,6 @@ describe Nanoc::Int::Compiler do
       action_sequence_store: action_sequence_store,
       action_provider: action_provider,
       dependency_store: dependency_store,
-      outdatedness_checker: outdatedness_checker,
       reps: reps,
       outdatedness_store: outdatedness_store,
     )
@@ -19,7 +18,6 @@ describe Nanoc::Int::Compiler do
   let(:dependency_store) { Nanoc::Int::DependencyStore.new(items.to_a) }
   let(:reps) { Nanoc::Int::ItemRepRepo.new }
 
-  let(:outdatedness_checker) { double(:outdatedness_checker) }
   let(:outdatedness_store) { Nanoc::Int::OutdatednessStore.new(site: site, reps: reps) }
   let(:action_provider) { double(:action_provider) }
 
@@ -65,9 +63,6 @@ describe Nanoc::Int::Compiler do
       rep.snapshot_defs << Nanoc::Int::SnapshotDef.new(:last, binary: false)
     end
 
-    allow(outdatedness_checker).to receive(:outdated?).with(rep).and_return(true)
-    allow(outdatedness_checker).to receive(:outdated?).with(other_rep).and_return(true)
-
     # FIXME: eww
     action_sequences = { rep => memory, other_rep => memory }
     compiler.instance_variable_set(:@action_sequences, action_sequences)

data/spec/nanoc/base/entities/identifiable_collection_spec.rb

@@ -9,4 +9,38 @@ describe Nanoc::Int::IdentifiableCollection do
 
     it { is_expected.to be_a(described_class) }
   end
+
+  describe '#find_all' do
+    let(:objects) do
+      [
+        double(:identifiable, identifier: Nanoc::Identifier.new('/about.css')),
+        double(:identifiable, identifier: Nanoc::Identifier.new('/about.md')),
+        double(:identifiable, identifier: Nanoc::Identifier.new('/style.css')),
+      ]
+    end
+
+    let(:arg) { raise 'override me' }
+
+    subject { identifiable_collection.find_all(arg) }
+
+    context 'with string' do
+      let(:arg) { '/*.css' }
+
+      it 'contains objects' do
+        expect(subject.size).to eql(2)
+        expect(subject.find { |iv| iv.identifier == '/about.css' }).to eq(objects[0])
+        expect(subject.find { |iv| iv.identifier == '/style.css' }).to eq(objects[2])
+      end
+    end
+
+    context 'with regex' do
+      let(:arg) { %r{\.css\z} }
+
+      it 'contains objects' do
+        expect(subject.size).to eql(2)
+        expect(subject.find { |iv| iv.identifier == '/about.css' }).to eq(objects[0])
+        expect(subject.find { |iv| iv.identifier == '/style.css' }).to eq(objects[2])
+      end
+    end
+  end
 end

data/spec/nanoc/base/services/compiler/stages/compile_reps_spec.rb

@@ -10,7 +10,7 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
   end
 
   let(:compilation_context) do
-    Nanoc::Int::Compiler::CompilationContext.new(
+    Nanoc::Int::CompilationContext.new(
       action_provider: action_provider,
       reps: reps,
       site: site,

data/spec/nanoc/base/services/executor_spec.rb

@@ -2,7 +2,7 @@ describe Nanoc::Int::Executor do
   let(:executor) { described_class.new(rep, compilation_context, dependency_tracker) }
 
   let(:compilation_context) do
-    Nanoc::Int::Compiler::CompilationContext.new(
+    Nanoc::Int::CompilationContext.new(
       action_provider: action_provider,
       reps: reps,
       site: site,

data/spec/nanoc/base/services/outdatedness_checker_spec.rb

@@ -5,7 +5,7 @@ describe Nanoc::Int::OutdatednessChecker do
       checksum_store: checksum_store,
       dependency_store: dependency_store,
       action_sequence_store: action_sequence_store,
-      action_provider: action_provider,
+      action_sequences: action_sequences,
       reps: reps,
     )
   end
@@ -38,7 +38,9 @@ describe Nanoc::Int::OutdatednessChecker do
 
   let(:new_action_sequence_for_item_rep) { old_action_sequence_for_item_rep }
 
-  let(:action_provider) { double(:action_provider) }
+  let(:action_sequences) do
+    { item_rep => new_action_sequence_for_item_rep }
+  end
 
   let(:reps) do
     Nanoc::Int::ItemRepRepo.new
@@ -52,12 +54,10 @@ describe Nanoc::Int::OutdatednessChecker do
   before do
     reps << item_rep
     action_sequence_store[item_rep] = old_action_sequence_for_item_rep.serialize
-
-    allow(action_provider).to receive(:action_sequence_for).with(item_rep).and_return(new_action_sequence_for_item_rep)
   end
 
-  describe '#basic_outdatedness_reason_for' do
-    subject { outdatedness_checker.send(:basic_outdatedness_reason_for, obj) }
+  describe 'basic outdatedness reasons' do
+    subject { outdatedness_checker.send(:basic).outdatedness_status_for(obj).reasons.first }
 
     let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: objects) }
 
@@ -131,6 +131,13 @@ describe Nanoc::Int::OutdatednessChecker do
 
     let(:new_action_sequence_for_other_item_rep) { old_action_sequence_for_other_item_rep }
 
+    let(:action_sequences) do
+      {
+        item_rep => new_action_sequence_for_item_rep,
+        other_item_rep => new_action_sequence_for_other_item_rep,
+      }
+    end
+
     before do
       reps << other_item_rep
       action_sequence_store[other_item_rep] = old_action_sequence_for_other_item_rep.serialize
@@ -138,7 +145,6 @@ describe Nanoc::Int::OutdatednessChecker do
       checksum_store.add(other_item)
       checksum_store.add(config)
 
-      allow(action_provider).to receive(:action_sequence_for).with(other_item_rep).and_return(new_action_sequence_for_other_item_rep)
       allow(site).to receive(:code_snippets).and_return([])
       allow(site).to receive(:config).and_return(config)
     end
@@ -147,11 +153,18 @@ describe Nanoc::Int::OutdatednessChecker do
       let(:distant_item) { Nanoc::Int::Item.new('distant stuff', {}, '/distant.md') }
       let(:distant_item_rep) { Nanoc::Int::ItemRep.new(distant_item, :default) }
 
+      let(:action_sequences) do
+        {
+          item_rep => new_action_sequence_for_item_rep,
+          other_item_rep => new_action_sequence_for_other_item_rep,
+          distant_item_rep => new_action_sequence_for_other_item_rep,
+        }
+      end
+
       before do
         reps << distant_item_rep
         checksum_store.add(distant_item)
         action_sequence_store[distant_item_rep] = old_action_sequence_for_other_item_rep.serialize
-        allow(action_provider).to receive(:action_sequence_for).with(distant_item_rep).and_return(new_action_sequence_for_other_item_rep)
       end
 
       context 'on attribute + attribute' do