nanoc 4.7.3 → 4.7.4

data/spec/nanoc/base/repos/checksum_store_spec.rb

@@ -3,8 +3,11 @@ describe Nanoc::Int::ChecksumStore do
 
   let(:objects) { [item, code_snippet] }
 
-  let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
-  let(:other_item) { Nanoc::Int::Item.new('asdf', {}, '/sneaky.md') }
+  let(:item) { Nanoc::Int::Item.new('asdf', item_attributes, '/foo.md') }
+  let(:other_item) { Nanoc::Int::Item.new('asdf', other_item_attributes, '/sneaky.md') }
+
+  let(:item_attributes) { {} }
+  let(:other_item_attributes) { {} }
 
   let(:code_snippet) { Nanoc::Int::CodeSnippet.new('def hi ; end', 'lib/foo.rb') }
   let(:other_code_snippet) { Nanoc::Int::CodeSnippet.new('def ho ; end', 'lib/bar.rb') }
@@ -90,6 +93,15 @@ describe Nanoc::Int::ChecksumStore do
 
     it 'has attributes checksum' do
       expect(store.attributes_checksum_for(item)).not_to be_nil
+      expect(store.attributes_checksum_for(item)).to eq({})
+    end
+
+    context 'item has attributes' do
+      let(:item_attributes) { { animal: 'donkey' } }
+
+      it 'has attribute checksum for specified attribute' do
+        expect(store.attributes_checksum_for(item)).to have_key(:animal)
+      end
     end
 
     context 'after storing and loading' do
@@ -119,6 +131,14 @@ describe Nanoc::Int::ChecksumStore do
       expect(store.attributes_checksum_for(other_item)).not_to be_nil
     end
 
+    context 'item has attributes' do
+      let(:other_item_attributes) { { location: 'Bernauer Str.' } }
+
+      it 'has attribute checksum for specified attribute' do
+        expect(store.attributes_checksum_for(other_item)).to have_key(:location)
+      end
+    end
+
     context 'after storing and loading' do
       before do
         store.store

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

@@ -57,8 +57,8 @@ describe Nanoc::Int::Compiler::Stages::Cleanup do
       it_behaves_like 'an old store'
     end
 
-    context 'tmp/rule_memory' do
-      let(:store_name) { 'rule_memory' }
+    context 'tmp/action_sequence' do
+      let(:store_name) { 'action_sequence' }
       it_behaves_like 'an old store'
     end
 

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

@@ -3,7 +3,7 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
     described_class.new(
       outdatedness_store: outdatedness_store,
       dependency_store: dependency_store,
-      action_provider: action_provider,
+      action_sequences: action_sequences,
       compilation_context: compilation_context,
       compiled_content_cache: compiled_content_cache,
     )
@@ -20,6 +20,7 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
   end
 
   let(:action_provider) { double(:action_provider) }
+  let(:action_sequences) { double(:action_sequences) }
   let(:reps) { Nanoc::Int::ItemRepRepo.new }
   let(:compiled_content_cache) { Nanoc::Int::CompiledContentCache.new(items: items) }
   let(:snapshot_repo) { Nanoc::Int::SnapshotRepo.new }
@@ -59,7 +60,7 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
         Nanoc::Int::ProcessingActions::Snapshot.new([:last], []),
       ]
 
-    Nanoc::Int::RuleMemory.new(nil, actions: actions)
+    Nanoc::Int::ActionSequence.new(nil, actions: actions)
   end
 
   before do
@@ -70,18 +71,13 @@ describe Nanoc::Int::Compiler::Stages::CompileReps do
       rep.snapshot_defs << Nanoc::Int::SnapshotDef.new(:last, binary: false)
     end
 
-    allow(action_provider).to receive(:memory_for).with(rep).and_return(memory)
-    allow(action_provider).to receive(:memory_for).with(other_rep).and_return(memory)
+    allow(action_sequences).to receive(:[]).with(rep).and_return(memory)
+    allow(action_sequences).to receive(:[]).with(other_rep).and_return(memory)
   end
 
   describe '#compile_reps' do
     subject { stage.run }
 
-    before do
-      allow(action_provider).to receive(:snapshots_defs_for).with(rep).and_return(snapshot_defs_for_rep)
-      allow(action_provider).to receive(:snapshots_defs_for).with(other_rep).and_return(snapshot_defs_for_rep)
-    end
-
     let(:snapshot_defs_for_rep) do
       [Nanoc::Int::SnapshotDef.new(:last, binary: false)]
     end

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

@@ -407,8 +407,8 @@ describe Nanoc::Int::Executor do
       )
     end
 
-    let(:rule_memory) do
-      Nanoc::Int::RuleMemory.new(rep).tap do |mem|
+    let(:action_sequence) do
+      Nanoc::Int::ActionSequence.new(rep).tap do |mem|
         mem.add_filter(:erb, {})
       end
     end
@@ -422,7 +422,7 @@ describe Nanoc::Int::Executor do
       allow(compilation_context).to receive(:assigns_for).with(rep, dependency_tracker) { assigns }
       allow(compilation_context).to receive(:create_view_context).with(dependency_tracker).and_return(view_context)
 
-      allow(action_provider).to receive(:memory_for).with(layout).and_return(rule_memory)
+      allow(action_provider).to receive(:action_sequence_for).with(layout).and_return(action_sequence)
     end
 
     subject { executor.layout('/default.*') }
@@ -532,8 +532,8 @@ describe Nanoc::Int::Executor do
     end
 
     context 'no filter specified' do
-      let(:rule_memory) do
-        Nanoc::Int::RuleMemory.new(rep)
+      let(:action_sequence) do
+        Nanoc::Int::ActionSequence.new(rep)
       end
 
       it 'raises' do

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

@@ -18,44 +18,62 @@ describe(Nanoc::Int::ItemRepRouter) do
       ]
     end
 
-    let(:paths_0) do
-      [
-        [[:last], ['/foo/index.html']],
-      ]
+    let(:memory_without_paths) do
+      actions =
+        [
+          Nanoc::Int::ProcessingActions::Filter.new(:erb, {}),
+          Nanoc::Int::ProcessingActions::Snapshot.new([], []),
+        ]
+
+      Nanoc::Int::ActionSequence.new(nil, actions: actions)
     end
 
-    let(:paths_1) do
-      [
-        [[:last], ['/bar.html']],
-      ]
+    let(:action_sequence_for_default) do
+      actions =
+        [
+          Nanoc::Int::ProcessingActions::Filter.new(:erb, {}),
+          Nanoc::Int::ProcessingActions::Snapshot.new([:last], ['/foo/index.html']),
+        ]
+
+      Nanoc::Int::ActionSequence.new(nil, actions: actions)
+    end
+
+    let(:action_sequence_for_csv) do
+      actions =
+        [
+          Nanoc::Int::ProcessingActions::Filter.new(:erb, {}),
+          Nanoc::Int::ProcessingActions::Snapshot.new([:last], ['/foo.csv']),
+        ]
+
+      Nanoc::Int::ActionSequence.new(nil, actions: actions)
     end
 
     example do
-      allow(action_provider).to receive(:paths_for).with(reps[0]).and_return(paths_0)
-      allow(action_provider).to receive(:paths_for).with(reps[1]).and_return(paths_1)
+      allow(action_provider).to receive(:action_sequence_for).with(reps[0]).and_return(action_sequence_for_default)
+      allow(action_provider).to receive(:action_sequence_for).with(reps[1]).and_return(action_sequence_for_csv)
 
       subject
 
       expect(reps[0].raw_paths).to eql(last: ['output/foo/index.html'])
       expect(reps[0].paths).to eql(last: ['/foo/'])
 
-      expect(reps[1].raw_paths).to eql(last: ['output/bar.html'])
-      expect(reps[1].paths).to eql(last: ['/bar.html'])
+      expect(reps[1].raw_paths).to eql(last: ['output/foo.csv'])
+      expect(reps[1].paths).to eql(last: ['/foo.csv'])
     end
 
     it 'picks the paths last returned' do
-      expect(action_provider).to receive(:paths_for).with(reps[0]).and_return([[[:last], []]]).ordered
-      expect(action_provider).to receive(:paths_for).with(reps[0]).and_return(paths_0).ordered
-      expect(action_provider).to receive(:paths_for).with(reps[1]).and_return([[[:last], []]]).ordered
-      expect(action_provider).to receive(:paths_for).with(reps[1]).and_return(paths_1).ordered
+      allow(action_provider).to receive(:action_sequence_for).with(reps[0])
+        .and_return(memory_without_paths, action_sequence_for_default)
+      allow(action_provider).to receive(:action_sequence_for).with(reps[1])
+        .and_return(memory_without_paths, action_sequence_for_csv)
 
       subject
 
       expect(reps[0].raw_paths).to eql(last: ['output/foo/index.html'])
       expect(reps[0].paths).to eql(last: ['/foo/'])
 
-      expect(reps[1].raw_paths).to eql(last: ['output/bar.html'])
-      expect(reps[1].paths).to eql(last: ['/bar.html'])
+      expect(reps[1].raw_paths).to eql(last: ['output/foo.csv'])
+      expect(reps[1].paths).to eql(last: ['/foo.csv'])
     end
   end
 

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

@@ -4,7 +4,7 @@ describe Nanoc::Int::OutdatednessChecker do
       site: site,
       checksum_store: checksum_store,
       dependency_store: dependency_store,
-      rule_memory_store: rule_memory_store,
+      action_sequence_store: action_sequence_store,
       action_provider: action_provider,
       reps: reps,
     )
@@ -26,17 +26,17 @@ describe Nanoc::Int::OutdatednessChecker do
     )
   end
 
-  let(:rule_memory_store) do
-    Nanoc::Int::RuleMemoryStore.new
+  let(:action_sequence_store) do
+    Nanoc::Int::ActionSequenceStore.new
   end
 
-  let(:old_memory_for_item_rep) do
-    Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+  let(:old_action_sequence_for_item_rep) do
+    Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
       mem.add_filter(:erb, {})
     end
   end
 
-  let(:new_memory_for_item_rep) { old_memory_for_item_rep }
+  let(:new_action_sequence_for_item_rep) { old_action_sequence_for_item_rep }
 
   let(:action_provider) { double(:action_provider) }
 
@@ -51,9 +51,9 @@ describe Nanoc::Int::OutdatednessChecker do
 
   before do
     reps << item_rep
-    rule_memory_store[item_rep] = old_memory_for_item_rep.serialize
+    action_sequence_store[item_rep] = old_action_sequence_for_item_rep.serialize
 
-    allow(action_provider).to receive(:memory_for).with(item_rep).and_return(new_memory_for_item_rep)
+    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
@@ -73,9 +73,9 @@ describe Nanoc::Int::OutdatednessChecker do
     context 'with item' do
       let(:obj) { item }
 
-      context 'rule memory differs' do
-        let(:new_memory_for_item_rep) do
-          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+      context 'action sequence differs' do
+        let(:new_action_sequence_for_item_rep) do
+          Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
             mem.add_filter(:super_erb, {})
           end
         end
@@ -91,9 +91,9 @@ describe Nanoc::Int::OutdatednessChecker do
     context 'with item rep' do
       let(:obj) { item_rep }
 
-      context 'rule memory differs' do
-        let(:new_memory_for_item_rep) do
-          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+      context 'action sequence differs' do
+        let(:new_action_sequence_for_item_rep) do
+          Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
             mem.add_filter(:super_erb, {})
           end
         end
@@ -123,22 +123,22 @@ describe Nanoc::Int::OutdatednessChecker do
 
     let(:objects) { [item, other_item] }
 
-    let(:old_memory_for_other_item_rep) do
-      Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem|
+    let(:old_action_sequence_for_other_item_rep) do
+      Nanoc::Int::ActionSequence.new(other_item_rep).tap do |mem|
         mem.add_filter(:erb, {})
       end
     end
 
-    let(:new_memory_for_other_item_rep) { old_memory_for_other_item_rep }
+    let(:new_action_sequence_for_other_item_rep) { old_action_sequence_for_other_item_rep }
 
     before do
       reps << other_item_rep
-      rule_memory_store[other_item_rep] = old_memory_for_other_item_rep.serialize
+      action_sequence_store[other_item_rep] = old_action_sequence_for_other_item_rep.serialize
       checksum_store.add(item)
       checksum_store.add(other_item)
       checksum_store.add(config)
 
-      allow(action_provider).to receive(:memory_for).with(other_item_rep).and_return(new_memory_for_other_item_rep)
+      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
@@ -150,8 +150,8 @@ describe Nanoc::Int::OutdatednessChecker do
       before do
         reps << distant_item_rep
         checksum_store.add(distant_item)
-        rule_memory_store[distant_item_rep] = old_memory_for_other_item_rep.serialize
-        allow(action_provider).to receive(:memory_for).with(distant_item_rep).and_return(new_memory_for_other_item_rep)
+        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
@@ -217,7 +217,7 @@ describe Nanoc::Int::OutdatednessChecker do
       end
     end
 
-    context 'only attribute dependency' do
+    context 'only generic attribute dependency' do
       before do
         dependency_store.record_dependency(item, other_item, attributes: true)
       end
@@ -239,8 +239,52 @@ describe Nanoc::Int::OutdatednessChecker do
       end
 
       context 'path changed' do
-        let(:new_memory_for_other_item_rep) do
-          Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem|
+        let(:new_action_sequence_for_other_item_rep) do
+          Nanoc::Int::ActionSequence.new(other_item_rep).tap do |mem|
+            mem.add_filter(:erb, {})
+            mem.add_snapshot(:donkey, '/giraffe.txt')
+          end
+        end
+
+        it { is_expected.not_to be }
+      end
+    end
+
+    context 'only specific attribute dependency' do
+      before do
+        dependency_store.record_dependency(item, other_item, attributes: [:title])
+      end
+
+      context 'attribute changed' do
+        before { other_item.attributes[:title] = 'omg new title' }
+        it { is_expected.to be }
+      end
+
+      context 'other attribute changed' do
+        before { other_item.attributes[:subtitle] = 'tagline here' }
+        it { is_expected.not_to be }
+      end
+
+      context 'raw content changed' do
+        before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') }
+        it { is_expected.not_to be }
+      end
+
+      context 'attribute + raw content changed' do
+        before { other_item.attributes[:title] = 'omg new title' }
+        before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') }
+        it { is_expected.to be }
+      end
+
+      context 'other attribute + raw content changed' do
+        before { other_item.attributes[:subtitle] = 'tagline here' }
+        before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') }
+        it { is_expected.not_to be }
+      end
+
+      context 'path changed' do
+        let(:new_action_sequence_for_other_item_rep) do
+          Nanoc::Int::ActionSequence.new(other_item_rep).tap do |mem|
             mem.add_filter(:erb, {})
             mem.add_snapshot(:donkey, '/giraffe.txt')
           end
@@ -272,8 +316,8 @@ describe Nanoc::Int::OutdatednessChecker do
       end
 
       context 'path changed' do
-        let(:new_memory_for_other_item_rep) do
-          Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem|
+        let(:new_action_sequence_for_other_item_rep) do
+          Nanoc::Int::ActionSequence.new(other_item_rep).tap do |mem|
             mem.add_filter(:erb, {})
             mem.add_snapshot(:donkey, '/giraffe.txt')
           end
@@ -299,8 +343,8 @@ describe Nanoc::Int::OutdatednessChecker do
       end
 
       context 'path changed' do
-        let(:new_memory_for_other_item_rep) do
-          Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem|
+        let(:new_action_sequence_for_other_item_rep) do
+          Nanoc::Int::ActionSequence.new(other_item_rep).tap do |mem|
             mem.add_filter(:erb, {})
             mem.add_snapshot(:donkey, '/giraffe.txt')
           end
@@ -332,8 +376,8 @@ describe Nanoc::Int::OutdatednessChecker do
       end
 
       context 'rules changed' do
-        let(:new_memory_for_other_item_rep) do
-          Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem|
+        let(:new_action_sequence_for_other_item_rep) do
+          Nanoc::Int::ActionSequence.new(other_item_rep).tap do |mem|
             mem.add_filter(:erb, {})
             mem.add_filter(:donkey, {})
           end

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

@@ -9,7 +9,7 @@ describe Nanoc::Int::OutdatednessRules do
         site: site,
         checksum_store: checksum_store,
         dependency_store: dependency_store,
-        rule_memory_store: rule_memory_store,
+        action_sequence_store: action_sequence_store,
         action_provider: action_provider,
         reps: reps,
       )
@@ -33,7 +33,7 @@ describe Nanoc::Int::OutdatednessRules do
     let(:action_provider) { double(:action_provider) }
     let(:reps) { Nanoc::Int::ItemRepRepo.new }
     let(:dependency_store) { Nanoc::Int::DependencyStore.new(dependency_store_objects) }
-    let(:rule_memory_store) { Nanoc::Int::RuleMemoryStore.new }
+    let(:action_sequence_store) { Nanoc::Int::ActionSequenceStore.new }
     let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: objects) }
 
     let(:dependency_store_objects) { [item] }
@@ -213,8 +213,58 @@ describe Nanoc::Int::OutdatednessRules do
 
         context 'checksum available, but attributes different' do
           let(:old_item) { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') }
+
           before { checksum_store.add(old_item) }
+
           it { is_expected.to be }
+
+          it 'has the one changed attribute' do
+            expect(subject.attributes).to contain_exactly(:greeting)
+          end
+        end
+
+        context 'attribute kept identical' do
+          let(:item)     { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') }
+          let(:old_item) { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') }
+
+          before { checksum_store.add(old_item) }
+
+          it 'has the one changed attribute' do
+            expect(subject).to be_nil
+          end
+        end
+
+        context 'attribute changed' do
+          let(:item)     { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') }
+          let(:old_item) { Nanoc::Int::Item.new('stuff', { greeting: 'ho' }, '/foo.md') }
+
+          before { checksum_store.add(old_item) }
+
+          it 'has the one changed attribute' do
+            expect(subject.attributes).to contain_exactly(:greeting)
+          end
+        end
+
+        context 'attribute deleted' do
+          let(:item)     { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') }
+          let(:old_item) { Nanoc::Int::Item.new('stuff', {}, '/foo.md') }
+
+          before { checksum_store.add(old_item) }
+
+          it 'has the one changed attribute' do
+            expect(subject.attributes).to contain_exactly(:greeting)
+          end
+        end
+
+        context 'attribute added' do
+          let(:item)     { Nanoc::Int::Item.new('stuff', {}, '/foo.md') }
+          let(:old_item) { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') }
+
+          before { checksum_store.add(old_item) }
+
+          it 'has the one changed attribute' do
+            expect(subject.attributes).to contain_exactly(:greeting)
+          end
         end
       end
 
@@ -238,8 +288,14 @@ describe Nanoc::Int::OutdatednessRules do
 
         context 'checksum available, but attributes different' do
           let(:old_item) { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') }
+
           before { checksum_store.add(old_item) }
+
           it { is_expected.to be }
+
+          it 'has the one changed attribute' do
+            expect(subject.attributes).to contain_exactly(:greeting)
+          end
         end
       end
     end
@@ -248,14 +304,14 @@ describe Nanoc::Int::OutdatednessRules do
       let(:rule_class) { Nanoc::Int::OutdatednessRules::RulesModified }
 
       let(:old_mem) do
-        Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+        Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
           mem.add_filter(:erb, {})
         end
       end
 
       before do
-        rule_memory_store[item_rep] = old_mem.serialize
-        allow(action_provider).to receive(:memory_for).with(item_rep).and_return(new_mem)
+        action_sequence_store[item_rep] = old_mem.serialize
+        allow(action_provider).to receive(:action_sequence_for).with(item_rep).and_return(new_mem)
       end
 
       context 'memory is the same' do
@@ -265,7 +321,7 @@ describe Nanoc::Int::OutdatednessRules do
 
       context 'memory is different' do
         let(:new_mem) do
-          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+          Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
             mem.add_filter(:erb, {})
             mem.add_filter(:donkey, {})
           end
@@ -279,12 +335,12 @@ describe Nanoc::Int::OutdatednessRules do
       let(:rule_class) { Nanoc::Int::OutdatednessRules::PathsModified }
 
       before do
-        allow(action_provider).to receive(:memory_for).with(item_rep).and_return(new_mem)
+        allow(action_provider).to receive(:action_sequence_for).with(item_rep).and_return(new_mem)
       end
 
       context 'old mem does not exist' do
         let(:new_mem) do
-          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+          Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
             mem.add_snapshot(:donkey, '/foo.md')
             mem.add_filter(:asdf, {})
           end
@@ -295,19 +351,19 @@ describe Nanoc::Int::OutdatednessRules do
 
       context 'old mem exists' do
         let(:old_mem) do
-          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+          Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
             mem.add_filter(:erb, {})
             mem.add_snapshot(:donkey, '/foo.md')
           end
         end
 
         before do
-          rule_memory_store[item_rep] = old_mem.serialize
+          action_sequence_store[item_rep] = old_mem.serialize
         end
 
         context 'paths in memory are the same' do
           let(:new_mem) do
-            Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+            Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
               mem.add_snapshot(:donkey, '/foo.md')
               mem.add_filter(:asdf, {})
             end
@@ -318,7 +374,7 @@ describe Nanoc::Int::OutdatednessRules do
 
         context 'paths in memory are different' do
           let(:new_mem) do
-            Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+            Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
               mem.add_filter(:erb, {})
               mem.add_snapshot(:donkey, '/foo.md')
               mem.add_filter(:donkey, {})
@@ -382,8 +438,10 @@ describe Nanoc::Int::OutdatednessRules do
             before { checksum_store.add(stored_obj) }
 
             context 'but checksum data afterwards' do
+              # NOTE: ignored for attributes!
+
               let(:new_obj) { klass.new('a', {}, '/foo.md', checksum_data: 'cs-data-new') }
-              it { is_expected.to eql([true, true]) }
+              it { is_expected.to eql([true, false]) }
             end
 
             context 'and unchanged' do
@@ -415,6 +473,8 @@ describe Nanoc::Int::OutdatednessRules do
         end
 
         context 'attributes_checksum_data' do
+          # NOTE: attributes_checksum_data is ignored!
+
           let(:stored_obj) { klass.new('a', {}, '/foo.md', attributes_checksum_data: 'cs-data') }
           let(:new_obj)    { stored_obj }
 
@@ -427,7 +487,7 @@ describe Nanoc::Int::OutdatednessRules do
 
             context 'but checksum data afterwards' do
               let(:new_obj) { klass.new('a', {}, '/foo.md', attributes_checksum_data: 'cs-data-new') }
-              it { is_expected.to eql([false, true]) }
+              it { is_expected.to eql([false, false]) }
             end
 
             context 'and unchanged' do
@@ -454,12 +514,12 @@ describe Nanoc::Int::OutdatednessRules do
       let(:rule_class) { Nanoc::Int::OutdatednessRules::UsesAlwaysOutdatedFilter }
 
       before do
-        allow(action_provider).to receive(:memory_for).with(item_rep).and_return(mem)
+        allow(action_provider).to receive(:action_sequence_for).with(item_rep).and_return(mem)
       end
 
       context 'unknown filter' do
         let(:mem) do
-          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+          Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
             mem.add_snapshot(:donkey, '/foo.md')
             mem.add_filter(:asdf, {})
           end
@@ -470,7 +530,7 @@ describe Nanoc::Int::OutdatednessRules do
 
       context 'known filter, not always outdated' do
         let(:mem) do
-          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+          Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
             mem.add_snapshot(:donkey, '/foo.md')
             mem.add_filter(:erb, {})
           end
@@ -481,7 +541,7 @@ describe Nanoc::Int::OutdatednessRules do
 
       context 'known filter, always outdated' do
         let(:mem) do
-          Nanoc::Int::RuleMemory.new(item_rep).tap do |mem|
+          Nanoc::Int::ActionSequence.new(item_rep).tap do |mem|
             mem.add_snapshot(:donkey, '/foo.md')
             mem.add_filter(:xsl, {})
           end