nanoc 4.7.7 → 4.7.8

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

@@ -2,32 +2,25 @@ module Nanoc::Int::Compiler::Stages
   class StorePreCompilationState
     include Nanoc::Int::ContractsSupport
 
-    def initialize(reps:, layouts:, items:, code_snippets:, config:, checksum_store:, action_sequence_store:, action_sequences:)
+    def initialize(reps:, layouts:, checksum_store:, action_sequence_store:, action_sequences:)
       @reps = reps
       @layouts = layouts
-      @items = items
-      @code_snippets = code_snippets
-      @config = config
       @checksum_store = checksum_store
       @action_sequence_store = action_sequence_store
       @action_sequences = action_sequences
     end
 
-    contract C::None => C::Any
-    def run
+    contract Nanoc::Int::ChecksumCollection => C::Any
+    def run(checksums)
       # Calculate action sequence
       (@reps.to_a + @layouts.to_a).each do |obj|
         @action_sequence_store[obj] = @action_sequences[obj].serialize
       end
+      @action_sequence_store.store
 
-      # Calculate checksums
-      objects_to_checksum =
-        @items.to_a + @layouts.to_a + @code_snippets + [@config]
-      objects_to_checksum.each { |obj| @checksum_store.add(obj) }
-
-      # Store
+      # Set checksums
+      @checksum_store.checksums = checksums.to_h
       @checksum_store.store
-      @action_sequence_store.store
     end
   end
 end

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

@@ -78,6 +78,7 @@ module Nanoc::Int
     include Nanoc::Int::ContractsSupport
 
     attr_reader :checksum_store
+    attr_reader :checksums
     attr_reader :dependency_store
     attr_reader :action_sequence_store
     attr_reader :action_sequences
@@ -88,10 +89,11 @@ module Nanoc::Int
     C_OBJ = C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout]
     C_ACTION_SEQUENCES = C::HashOf[C_OBJ => Nanoc::Int::ActionSequence]
 
-    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:)
+    contract C::KeywordArgs[site: Nanoc::Int::Site, checksum_store: Nanoc::Int::ChecksumStore, checksums: Nanoc::Int::ChecksumCollection, 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:, checksums:, dependency_store:, action_sequence_store:, action_sequences:, reps:)
       @site = site
       @checksum_store = checksum_store
+      @checksums = checksums
       @dependency_store = dependency_store
       @action_sequence_store = action_sequence_store
       @action_sequences = action_sequences

data/lib/nanoc/base/services/outdatedness_rules/attributes_modified.rb

@@ -17,7 +17,7 @@ module Nanoc::Int::OutdatednessRules
           return Nanoc::Int::OutdatednessReasons::AttributesModified.new(true)
         end
 
-        new_checksums = Nanoc::Int::Checksummer.calc_for_each_attribute_of(obj)
+        new_checksums = outdatedness_checker.checksums.attributes_checksum_for(obj)
 
         attributes = Set.new(old_checksums.keys) + Set.new(new_checksums.keys)
         changed_attributes = attributes.reject { |a| old_checksums[a] == new_checksums[a] }

data/lib/nanoc/base/services/outdatedness_rules/code_snippets_modified.rb

@@ -17,7 +17,7 @@ module Nanoc::Int::OutdatednessRules
     memoized def any_snippets_modified?(outdatedness_checker)
       outdatedness_checker.site.code_snippets.any? do |cs|
         ch_old = outdatedness_checker.checksum_store[cs]
-        ch_new = Nanoc::Int::Checksummer.calc(cs)
+        ch_new = outdatedness_checker.checksums.checksum_for(cs)
         ch_old != ch_new
       end
     end

data/lib/nanoc/base/services/outdatedness_rules/configuration_modified.rb

@@ -15,7 +15,7 @@ module Nanoc::Int::OutdatednessRules
     memoized def config_modified?(outdatedness_checker)
       obj = outdatedness_checker.site.config
       ch_old = outdatedness_checker.checksum_store[obj]
-      ch_new = Nanoc::Int::Checksummer.calc(obj)
+      ch_new = outdatedness_checker.checksums.checksum_for(obj)
       ch_old != ch_new
     end
   end

data/lib/nanoc/base/services/outdatedness_rules/content_modified.rb

@@ -6,7 +6,7 @@ module Nanoc::Int::OutdatednessRules
       obj = obj.item if obj.is_a?(Nanoc::Int::ItemRep)
 
       ch_old = outdatedness_checker.checksum_store.content_checksum_for(obj)
-      ch_new = Nanoc::Int::Checksummer.calc_for_content_of(obj)
+      ch_new = outdatedness_checker.checksums.content_checksum_for(obj)
       if ch_old != ch_new
         Nanoc::Int::OutdatednessReasons::ContentModified
       end

data/lib/nanoc/cli/cleaning_stream.rb

@@ -147,7 +147,7 @@ module Nanoc::CLI
     protected
 
     def _nanoc_clean(s)
-      @stream_cleaners.reduce(s.to_s) { |acc, elem| elem.clean(acc) }
+      @stream_cleaners.reduce(s.to_s.scrub) { |acc, elem| elem.clean(acc) }
     end
 
     def _nanoc_swallow_broken_pipe_errors_while

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

@@ -144,6 +144,7 @@ module Nanoc::CLI::Commands
     end
 
     def print_outdatedness_reasons_for(obj, compiler)
+      compiler.calculate_checksums
       outdatedness_checker = compiler.create_outdatedness_checker
       reasons = outdatedness_checker.outdatedness_reasons_for(obj)
       if reasons.any?

data/lib/nanoc/rule_dsl/action_sequence_calculator.rb

@@ -58,8 +58,7 @@ module Nanoc::RuleDSL
       dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
       view_context = @site.compiler.compilation_context.create_view_context(dependency_tracker)
 
-      action_sequence = Nanoc::Int::ActionSequence.new(rep)
-      executor = Nanoc::RuleDSL::RecordingExecutor.new(action_sequence)
+      executor = Nanoc::RuleDSL::RecordingExecutor.new(rep)
       rule = @rules_collection.compilation_rule_for(rep)
 
       unless rule
@@ -68,17 +67,11 @@ module Nanoc::RuleDSL
 
       executor.snapshot(:raw)
       rule.apply_to(rep, executor: executor, site: @site, view_context: view_context)
-      if action_sequence.any_layouts?
-        executor.snapshot(:post)
-      end
-      unless action_sequence.snapshot_actions.any? { |sa| sa.snapshot_names.include?(:last) }
-        executor.snapshot(:last)
-      end
-      unless action_sequence.snapshot_actions.any? { |sa| sa.snapshot_names.include?(:pre) }
-        executor.snapshot(:pre)
-      end
+      executor.snapshot(:post) if executor.any_layouts?
+      executor.snapshot(:last) unless executor.last_snapshot?
+      executor.snapshot(:pre) unless executor.pre_snapshot?
 
-      copy_paths_from_routing_rules(compact_snapshots(action_sequence), rep: rep)
+      copy_paths_from_routing_rules(compact_snapshots(executor.action_sequence), rep: rep)
     end
 
     # @param [Nanoc::Int::Layout] layout
@@ -91,8 +84,8 @@ module Nanoc::RuleDSL
         raise NoActionSequenceForLayoutException.new(layout)
       end
 
-      Nanoc::Int::ActionSequence.new(layout).tap do |rm|
-        rm.add_filter(res[0], res[1])
+      Nanoc::Int::ActionSequence.build(layout) do |b|
+        b.add_filter(res[0], res[1])
       end
     end
 

data/lib/nanoc/rule_dsl/recording_executor.rb

@@ -3,12 +3,17 @@ module Nanoc
     class RecordingExecutor
       include Nanoc::Int::ContractsSupport
 
-      def initialize(action_sequence)
-        @action_sequence = action_sequence
+      contract Nanoc::Int::ItemRep => C::Any
+      def initialize(rep)
+        @action_sequence_builder = Nanoc::Int::ActionSequenceBuilder.new(rep)
+
+        @any_layouts = false
+        @last_snapshot = false
+        @pre_snapshot = false
       end
 
       def filter(filter_name, filter_args = {})
-        @action_sequence.add_filter(filter_name, filter_args)
+        @action_sequence_builder.add_filter(filter_name, filter_args)
       end
 
       def layout(layout_identifier, extra_filter_args = {})
@@ -16,19 +21,47 @@ module Nanoc
           raise ArgumentError.new('The layout passed to #layout must be a string')
         end
 
-        unless @action_sequence.any_layouts?
-          @action_sequence.add_snapshot(:pre, nil)
+        unless any_layouts?
+          @pre_snapshot = true
+          @action_sequence_builder.add_snapshot(:pre, nil)
         end
 
-        @action_sequence.add_layout(layout_identifier, extra_filter_args)
+        @action_sequence_builder.add_layout(layout_identifier, extra_filter_args)
+        @any_layouts = true
       end
 
       Pathlike = C::Maybe[C::Or[String, Nanoc::Identifier]]
       contract Symbol, C::KeywordArgs[path: C::Optional[Pathlike]] => nil
       def snapshot(snapshot_name, path: nil)
-        @action_sequence.add_snapshot(snapshot_name, path && path.to_s)
+        @action_sequence_builder.add_snapshot(snapshot_name, path && path.to_s)
+        case snapshot_name
+        when :last
+          @last_snapshot = true
+        when :pre
+          @pre_snapshot = true
+        end
         nil
       end
+
+      contract C::None => Nanoc::Int::ActionSequence
+      def action_sequence
+        @action_sequence_builder.action_sequence
+      end
+
+      contract C::None => C::Bool
+      def any_layouts?
+        @any_layouts
+      end
+
+      contract C::None => C::Bool
+      def last_snapshot?
+        @last_snapshot
+      end
+
+      contract C::None => C::Bool
+      def pre_snapshot?
+        @pre_snapshot
+      end
     end
   end
 end

data/lib/nanoc/version.rb

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

data/spec/nanoc/base/compiler_spec.rb

@@ -58,6 +58,10 @@ describe Nanoc::Int::Compiler do
     Nanoc::Int::ActionSequence.new(nil, actions: actions)
   end
 
+  let(:action_sequences) do
+    { rep => memory, other_rep => memory }
+  end
+
   before do
     reps << rep
     reps << other_rep
@@ -66,15 +70,11 @@ describe Nanoc::Int::Compiler do
       rep.snapshot_defs << Nanoc::Int::SnapshotDef.new(:last, binary: false)
     end
 
-    # FIXME: eww
-    action_sequences = { rep => memory, other_rep => memory }
-    compiler.instance_variable_set(:@action_sequences, action_sequences)
-
     allow(Nanoc::Int::NotificationCenter).to receive(:post)
   end
 
   describe '#compile_rep' do
-    let(:stage) { compiler.send(:compile_reps_stage) }
+    let(:stage) { compiler.send(:compile_reps_stage, action_sequences) }
 
     subject { stage.send(:compile_rep, rep, is_outdated: is_outdated) }
 

data/spec/nanoc/base/directed_graph_spec.rb

@@ -27,6 +27,18 @@ describe Nanoc::Int::DirectedGraph do
       it { is_expected.to eq([2, 3]) }
     end
 
+    context 'one cycle with tail' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 20)
+        graph.add_edge(20, 21)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 1)
+      end
+
+      it { is_expected.to eq([1, 2, 3]) }
+    end
+
     context 'large cycle' do
       before do
         graph.add_edge(1, 2)

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

@@ -1,17 +1,26 @@
 describe Nanoc::Int::ActionSequence do
-  let(:action_sequence) { described_class.new(rep) }
-  let(:rep) { double(:rep) }
+  let(:action_sequence) { raise 'override me' }
+
+  let(:item) { Nanoc::Int::Item.new('foo', {}, '/foo.md') }
+  let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
 
   describe '#size' do
     subject { action_sequence.size }
 
     context 'no actions' do
+      let(:action_sequence) do
+        described_class.build(rep) do |b|
+        end
+      end
+
       it { is_expected.to eql(0) }
     end
 
     context 'some actions' do
-      before do
-        action_sequence.add_filter(:foo, {})
+      let(:action_sequence) do
+        described_class.build(rep) do |b|
+          b.add_filter(:foo, {})
+        end
       end
 
       it { is_expected.to eql(1) }
@@ -23,12 +32,19 @@ describe Nanoc::Int::ActionSequence do
     let(:index) { 0 }
 
     context 'no actions' do
+      let(:action_sequence) do
+        described_class.build(rep) do |b|
+        end
+      end
+
       it { is_expected.to be_nil }
     end
 
     context 'some actions' do
-      before do
-        action_sequence.add_filter(:foo, {})
+      let(:action_sequence) do
+        described_class.build(rep) do |b|
+          b.add_filter(:foo, {})
+        end
       end
 
       it { is_expected.to be_a(Nanoc::Int::ProcessingActions::Filter) }
@@ -36,9 +52,13 @@ describe Nanoc::Int::ActionSequence do
   end
 
   describe '#add_filter' do
-    example do
-      action_sequence.add_filter(:foo, donkey: 123)
+    let(:action_sequence) do
+      described_class.build(rep) do |b|
+        b.add_filter(:foo, donkey: 123)
+      end
+    end
 
+    example do
       expect(action_sequence.size).to eql(1)
       expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Filter)
       expect(action_sequence[0].filter_name).to eql(:foo)
@@ -47,9 +67,13 @@ describe Nanoc::Int::ActionSequence do
   end
 
   describe '#add_layout' do
-    example do
-      action_sequence.add_layout('/foo.*', donkey: 123)
+    let(:action_sequence) do
+      described_class.build(rep) do |b|
+        b.add_layout('/foo.*', donkey: 123)
+      end
+    end
 
+    example do
       expect(action_sequence.size).to eql(1)
       expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Layout)
       expect(action_sequence[0].layout_identifier).to eql('/foo.*')
@@ -59,9 +83,13 @@ describe Nanoc::Int::ActionSequence do
 
   describe '#add_snapshot' do
     context 'snapshot does not yet exist' do
-      example do
-        action_sequence.add_snapshot(:before_layout, '/foo.md')
+      let(:action_sequence) do
+        described_class.build(rep) do |b|
+          b.add_snapshot(:before_layout, '/foo.md')
+        end
+      end
 
+      example do
         expect(action_sequence.size).to eql(1)
         expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
         expect(action_sequence[0].snapshot_names).to eql([:before_layout])
@@ -70,22 +98,23 @@ describe Nanoc::Int::ActionSequence do
     end
 
     context 'snapshot already exist' do
-      before do
-        action_sequence.add_snapshot(:before_layout, '/bar.md')
-      end
-
       it 'raises' do
-        expect { action_sequence.add_snapshot(:before_layout, '/foo.md') }
-          .to raise_error(Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName)
+        described_class.build(rep) do |b|
+          b.add_snapshot(:before_layout, '/bar.md')
+          expect { b.add_snapshot(:before_layout, '/foo.md') }
+            .to raise_error(Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName)
+        end
       end
     end
   end
 
   describe '#each' do
-    before do
-      action_sequence.add_filter(:erb, awesomeness: 'high')
-      action_sequence.add_snapshot(:bar, '/foo.md')
-      action_sequence.add_layout('/default.erb', somelayoutparam: 'yes')
+    let(:action_sequence) do
+      described_class.build(rep) do |b|
+        b.add_filter(:erb, awesomeness: 'high')
+        b.add_snapshot(:bar, '/foo.md')
+        b.add_layout('/default.erb', somelayoutparam: 'yes')
+      end
     end
 
     example do
@@ -96,10 +125,12 @@ describe Nanoc::Int::ActionSequence do
   end
 
   describe '#map' do
-    before do
-      action_sequence.add_filter(:erb, awesomeness: 'high')
-      action_sequence.add_snapshot(:bar, '/foo.md')
-      action_sequence.add_layout('/default.erb', somelayoutparam: 'yes')
+    let(:action_sequence) do
+      described_class.build(rep) do |b|
+        b.add_filter(:erb, awesomeness: 'high')
+        b.add_snapshot(:bar, '/foo.md')
+        b.add_layout('/default.erb', somelayoutparam: 'yes')
+      end
     end
 
     example do
@@ -112,10 +143,12 @@ describe Nanoc::Int::ActionSequence do
   describe '#serialize' do
     subject { action_sequence.serialize }
 
-    before do
-      action_sequence.add_filter(:erb, awesomeness: 'high')
-      action_sequence.add_snapshot(:bar, '/foo.md')
-      action_sequence.add_layout('/default.erb', somelayoutparam: 'yes')
+    let(:action_sequence) do
+      described_class.build(rep) do |b|
+        b.add_filter(:erb, awesomeness: 'high')
+        b.add_snapshot(:bar, '/foo.md')
+        b.add_layout('/default.erb', somelayoutparam: 'yes')
+      end
     end
 
     example do
@@ -130,8 +163,6 @@ describe Nanoc::Int::ActionSequence do
   end
 
   describe '#snapshots_defs' do
-    subject { action_sequence.snapshots_defs }
-
     let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
     let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
 
@@ -164,42 +195,55 @@ describe Nanoc::Int::ActionSequence do
     end
 
     it 'has no snapshot defs by default' do
-      expect(subject).to be_empty
+      action_sequence =
+        described_class.build(rep) do |b|
+        end
+
+      expect(action_sequence.snapshots_defs).to be_empty
     end
 
     context 'textual item' do
       let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
 
       it 'generates initial textual snapshot def' do
-        action_sequence.add_snapshot(:giraffe, nil)
-
-        expect(subject.size).to eq(1)
-        expect(subject[0].name).to eq(:giraffe)
-        expect(subject[0]).not_to be_binary
+        action_sequence =
+          described_class.build(rep) do |b|
+            b.add_snapshot(:giraffe, nil)
+          end
+
+        expect(action_sequence.snapshots_defs.size).to eq(1)
+        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
+        expect(action_sequence.snapshots_defs[0]).not_to be_binary
       end
 
       it 'generated follow-up textual snapshot def if previous filter is textual' do
-        action_sequence.add_snapshot(:giraffe, nil)
-        action_sequence.add_filter(:RuleMemSpec_filter_t2t, arguments: 'irrelevant')
-        action_sequence.add_snapshot(:zebra, nil)
-
-        expect(subject.size).to eq(2)
-        expect(subject[0].name).to eq(:giraffe)
-        expect(subject[0]).not_to be_binary
-        expect(subject[1].name).to eq(:zebra)
-        expect(subject[1]).not_to be_binary
+        action_sequence =
+          described_class.build(rep) do |b|
+            b.add_snapshot(:giraffe, nil)
+            b.add_filter(:RuleMemSpec_filter_t2t, arguments: 'irrelevant')
+            b.add_snapshot(:zebra, nil)
+          end
+
+        expect(action_sequence.snapshots_defs.size).to eq(2)
+        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
+        expect(action_sequence.snapshots_defs[0]).not_to be_binary
+        expect(action_sequence.snapshots_defs[1].name).to eq(:zebra)
+        expect(action_sequence.snapshots_defs[1]).not_to be_binary
       end
 
       it 'generated follow-up binary snapshot def if previous filter is text-to-bianry' do
-        action_sequence.add_snapshot(:giraffe, nil)
-        action_sequence.add_filter(:RuleMemSpec_filter_t2b, arguments: 'irrelevant')
-        action_sequence.add_snapshot(:zebra, nil)
-
-        expect(subject.size).to eq(2)
-        expect(subject[0].name).to eq(:giraffe)
-        expect(subject[0]).not_to be_binary
-        expect(subject[1].name).to eq(:zebra)
-        expect(subject[1]).to be_binary
+        action_sequence =
+          described_class.build(rep) do |b|
+            b.add_snapshot(:giraffe, nil)
+            b.add_filter(:RuleMemSpec_filter_t2b, arguments: 'irrelevant')
+            b.add_snapshot(:zebra, nil)
+          end
+
+        expect(action_sequence.snapshots_defs.size).to eq(2)
+        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
+        expect(action_sequence.snapshots_defs[0]).not_to be_binary
+        expect(action_sequence.snapshots_defs[1].name).to eq(:zebra)
+        expect(action_sequence.snapshots_defs[1]).to be_binary
       end
     end
 
@@ -207,35 +251,44 @@ describe Nanoc::Int::ActionSequence do
       let(:item) { Nanoc::Int::Item.new(Nanoc::Int::BinaryContent.new('/asdf.dat'), {}, '/foo.md') }
 
       it 'generates initial binary snapshot def' do
-        action_sequence.add_snapshot(:giraffe, nil)
-
-        expect(subject.size).to eq(1)
-        expect(subject[0].name).to eq(:giraffe)
-        expect(subject[0]).to be_binary
+        action_sequence =
+          described_class.build(rep) do |b|
+            b.add_snapshot(:giraffe, nil)
+          end
+
+        expect(action_sequence.snapshots_defs.size).to eq(1)
+        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
+        expect(action_sequence.snapshots_defs[0]).to be_binary
       end
 
       it 'generated follow-up binary snapshot def if previous filter is binary' do
-        action_sequence.add_snapshot(:giraffe, nil)
-        action_sequence.add_filter(:RuleMemSpec_filter_b2b, arguments: 'irrelevant')
-        action_sequence.add_snapshot(:zebra, nil)
-
-        expect(subject.size).to eq(2)
-        expect(subject[0].name).to eq(:giraffe)
-        expect(subject[0]).to be_binary
-        expect(subject[1].name).to eq(:zebra)
-        expect(subject[1]).to be_binary
+        action_sequence =
+          described_class.build(rep) do |b|
+            b.add_snapshot(:giraffe, nil)
+            b.add_filter(:RuleMemSpec_filter_b2b, arguments: 'irrelevant')
+            b.add_snapshot(:zebra, nil)
+          end
+
+        expect(action_sequence.snapshots_defs.size).to eq(2)
+        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
+        expect(action_sequence.snapshots_defs[0]).to be_binary
+        expect(action_sequence.snapshots_defs[1].name).to eq(:zebra)
+        expect(action_sequence.snapshots_defs[1]).to be_binary
       end
 
       it 'generated follow-up textual snapshot def if previous filter is binary-to-text' do
-        action_sequence.add_snapshot(:giraffe, nil)
-        action_sequence.add_filter(:RuleMemSpec_filter_b2t, arguments: 'irrelevant')
-        action_sequence.add_snapshot(:zebra, nil)
-
-        expect(subject.size).to eq(2)
-        expect(subject[0].name).to eq(:giraffe)
-        expect(subject[0]).to be_binary
-        expect(subject[1].name).to eq(:zebra)
-        expect(subject[1]).not_to be_binary
+        action_sequence =
+          described_class.build(rep) do |b|
+            b.add_snapshot(:giraffe, nil)
+            b.add_filter(:RuleMemSpec_filter_b2t, arguments: 'irrelevant')
+            b.add_snapshot(:zebra, nil)
+          end
+
+        expect(action_sequence.snapshots_defs.size).to eq(2)
+        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
+        expect(action_sequence.snapshots_defs[0]).to be_binary
+        expect(action_sequence.snapshots_defs[1].name).to eq(:zebra)
+        expect(action_sequence.snapshots_defs[1]).not_to be_binary
       end
     end
   end