nanoc 4.7.3 → 4.7.4

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

@@ -0,0 +1,13 @@
+module Nanoc::Int::OutdatednessRules
+  class RulesModified < Nanoc::Int::OutdatednessRule
+    affects_props :compiled_content, :path
+
+    def apply(obj, outdatedness_checker)
+      mem_old = outdatedness_checker.action_sequence_store[obj]
+      mem_new = outdatedness_checker.action_sequence_for(obj).serialize
+      unless mem_old.eql?(mem_new)
+        Nanoc::Int::OutdatednessReasons::RulesModified
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Nanoc::Int::OutdatednessRules
+  class UsesAlwaysOutdatedFilter < Nanoc::Int::OutdatednessRule
+    affects_props :raw_content, :attributes, :path
+
+    def apply(obj, outdatedness_checker)
+      mem = outdatedness_checker.action_sequence_for(obj)
+      if any_always_outdated?(mem)
+        Nanoc::Int::OutdatednessReasons::UsesAlwaysOutdatedFilter
+      end
+    end
+
+    def any_always_outdated?(mem)
+      mem
+        .select { |a| a.is_a?(Nanoc::Int::ProcessingActions::Filter) }
+        .map { |a| Nanoc::Filter.named(a.filter_name) }
+        .compact
+        .any?(&:always_outdated?)
+    end
+  end
+end

data/lib/nanoc/rule_dsl.rb

@@ -2,7 +2,7 @@ require_relative 'rule_dsl/compiler_dsl'
 require_relative 'rule_dsl/action_provider'
 require_relative 'rule_dsl/recording_executor'
 require_relative 'rule_dsl/rule_context'
-require_relative 'rule_dsl/rule_memory_calculator'
+require_relative 'rule_dsl/action_sequence_calculator'
 require_relative 'rule_dsl/rule'
 require_relative 'rule_dsl/rules_collection'
 require_relative 'rule_dsl/rules_loader'

data/lib/nanoc/rule_dsl/action_provider.rb

@@ -8,21 +8,21 @@ module Nanoc::RuleDSL
     def self.for(site)
       rules_collection = Nanoc::RuleDSL::RulesCollection.new
 
-      rule_memory_calculator =
-        Nanoc::RuleDSL::RuleMemoryCalculator.new(
+      action_sequence_calculator =
+        Nanoc::RuleDSL::ActionSequenceCalculator.new(
           rules_collection: rules_collection, site: site,
         )
 
-      action_provider = new(rules_collection, rule_memory_calculator)
+      action_provider = new(rules_collection, action_sequence_calculator)
 
       Nanoc::RuleDSL::RulesLoader.new(site.config, rules_collection).load
 
       action_provider
     end
 
-    def initialize(rules_collection, rule_memory_calculator)
+    def initialize(rules_collection, action_sequence_calculator)
       @rules_collection = rules_collection
-      @rule_memory_calculator = rule_memory_calculator
+      @action_sequence_calculator = action_sequence_calculator
     end
 
     def rep_names_for(item)
@@ -32,12 +32,8 @@ module Nanoc::RuleDSL
       matching_rules.map(&:rep_name).uniq
     end
 
-    def memory_for(rep)
-      @rule_memory_calculator[rep]
-    end
-
-    def snapshots_defs_for(rep)
-      @rule_memory_calculator.snapshots_defs_for(rep)
+    def action_sequence_for(rep)
+      @action_sequence_calculator[rep]
     end
 
     def need_preprocessing?

data/lib/nanoc/rule_dsl/{rule_memory_calculator.rb → action_sequence_calculator.rb}

@@ -1,24 +1,24 @@
 module Nanoc::RuleDSL
-  # Calculates rule memories for objects that can be run through a rule (item
+  # Calculates action sequences for objects that can be run through a rule (item
   # representations and layouts).
   #
   # @api private
-  class RuleMemoryCalculator
+  class ActionSequenceCalculator
     extend Nanoc::Int::Memoization
 
     class UnsupportedObjectTypeException < ::Nanoc::Error
       def initialize(obj)
-        super("Do not know how to calculate the rule memory for #{obj.inspect}")
+        super("Do not know how to calculate the action sequence for #{obj.inspect}")
       end
     end
 
-    class NoRuleMemoryForLayoutException < ::Nanoc::Error
+    class NoActionSequenceForLayoutException < ::Nanoc::Error
       def initialize(layout)
         super("There is no layout rule specified for #{layout.inspect}")
       end
     end
 
-    class NoRuleMemoryForItemRepException < ::Nanoc::Error
+    class NoActionSequenceForItemRepException < ::Nanoc::Error
       def initialize(item)
         super("There is no compilation rule specified for #{item.inspect}")
       end
@@ -42,78 +42,60 @@ module Nanoc::RuleDSL
 
     # @param [#reference] obj
     #
-    # @return [Nanoc::Int::RuleMemory]
+    # @return [Nanoc::Int::ActionSequence]
     def [](obj)
       case obj
       when Nanoc::Int::ItemRep
-        new_rule_memory_for_rep(obj)
+        new_action_sequence_for_rep(obj)
       when Nanoc::Int::Layout
-        new_rule_memory_for_layout(obj)
+        new_action_sequence_for_layout(obj)
       else
         raise UnsupportedObjectTypeException.new(obj)
       end
     end
 
-    def snapshots_defs_for(rep)
-      is_binary = rep.item.content.binary?
-      snapshot_defs = []
-
-      self[rep].each do |action|
-        case action
-        when Nanoc::Int::ProcessingActions::Snapshot
-          action.snapshot_names.each do |snapshot_name|
-            snapshot_defs << Nanoc::Int::SnapshotDef.new(snapshot_name, binary: is_binary)
-          end
-        when Nanoc::Int::ProcessingActions::Filter
-          is_binary = Nanoc::Filter.named!(action.filter_name).to_binary?
-        end
-      end
-
-      snapshot_defs
-    end
-
     # @param [Nanoc::Int::ItemRep] rep The item representation to get the rule
     #   memory for
     #
-    # @return [Nanoc::Int::RuleMemory]
-    def new_rule_memory_for_rep(rep)
+    # @return [Nanoc::Int::ActionSequence]
+    def new_action_sequence_for_rep(rep)
       dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
       view_context = @site.compiler.compilation_context.create_view_context(dependency_tracker)
 
-      rule_memory = Nanoc::Int::RuleMemory.new(rep)
-      executor = Nanoc::RuleDSL::RecordingExecutor.new(rule_memory)
+      action_sequence = Nanoc::Int::ActionSequence.new(rep)
+      executor = Nanoc::RuleDSL::RecordingExecutor.new(action_sequence)
       rule = @rules_collection.compilation_rule_for(rep)
 
       unless rule
-        raise NoRuleMemoryForItemRepException.new(rep)
+        raise NoActionSequenceForItemRepException.new(rep)
       end
 
       executor.snapshot(:raw)
       rule.apply_to(rep, executor: executor, site: @site, view_context: view_context)
-      if rule_memory.any_layouts?
+      if action_sequence.any_layouts?
         executor.snapshot(:post)
       end
-      unless rule_memory.snapshot_actions.any? { |sa| sa.snapshot_names.include?(:last) }
+      unless action_sequence.snapshot_actions.any? { |sa| sa.snapshot_names.include?(:last) }
         executor.snapshot(:last)
       end
-      unless rule_memory.snapshot_actions.any? { |sa| sa.snapshot_names.include?(:pre) }
+      unless action_sequence.snapshot_actions.any? { |sa| sa.snapshot_names.include?(:pre) }
         executor.snapshot(:pre)
       end
 
-      copy_paths_from_routing_rules(rule_memory.compact_snapshots, rep: rep)
+      copy_paths_from_routing_rules(action_sequence.compact_snapshots, rep: rep)
     end
 
     # @param [Nanoc::Int::Layout] layout
     #
-    # @return [Nanoc::Int::RuleMemory]
-    def new_rule_memory_for_layout(layout)
+    # @return [Nanoc::Int::ActionSequence]
+    def new_action_sequence_for_layout(layout)
       res = @rules_collection.filter_for_layout(layout)
 
       unless res
-        raise NoRuleMemoryForLayoutException.new(layout)
+        raise NoActionSequenceForLayoutException.new(layout)
       end
 
-      Nanoc::Int::RuleMemory.new(layout).tap do |rm|
+      Nanoc::Int::ActionSequence.new(layout).tap do |rm|
         rm.add_filter(res[0], res[1])
       end
     end

data/lib/nanoc/rule_dsl/recording_executor.rb

@@ -3,12 +3,12 @@ module Nanoc
     class RecordingExecutor
       include Nanoc::Int::ContractsSupport
 
-      def initialize(rule_memory)
-        @rule_memory = rule_memory
+      def initialize(action_sequence)
+        @action_sequence = action_sequence
       end
 
       def filter(filter_name, filter_args = {})
-        @rule_memory.add_filter(filter_name, filter_args)
+        @action_sequence.add_filter(filter_name, filter_args)
       end
 
       def layout(layout_identifier, extra_filter_args = {})
@@ -16,17 +16,17 @@ module Nanoc
           raise ArgumentError.new('The layout passed to #layout must be a string')
         end
 
-        unless @rule_memory.any_layouts?
-          @rule_memory.add_snapshot(:pre, nil)
+        unless @action_sequence.any_layouts?
+          @action_sequence.add_snapshot(:pre, nil)
         end
 
-        @rule_memory.add_layout(layout_identifier, extra_filter_args)
+        @action_sequence.add_layout(layout_identifier, extra_filter_args)
       end
 
       Pathlike = C::Maybe[C::Or[String, Nanoc::Identifier]]
       contract Symbol, C::KeywordArgs[path: C::Optional[Pathlike]] => nil
       def snapshot(snapshot_name, path: nil)
-        @rule_memory.add_snapshot(snapshot_name, path && path.to_s)
+        @action_sequence.add_snapshot(snapshot_name, path && path.to_s)
         nil
       end
     end

data/lib/nanoc/spec.rb

@@ -12,7 +12,7 @@ module Nanoc
         @mod = mod
 
         @erbout = ''
-        @rule_memory = {}
+        @action_sequence = {}
         @config = Nanoc::Int::Configuration.new.with_defaults
         @reps = Nanoc::Int::ItemRepRepo.new
         @items = Nanoc::Int::IdentifiableCollection.new(@config)
@@ -103,12 +103,12 @@ module Nanoc
         assigns[:layouts]
       end
 
-      def rule_memory_for(obj)
-        @rule_memory.fetch(obj, [])
+      def action_sequence_for(obj)
+        @action_sequence.fetch(obj, [])
       end
 
-      def update_rule_memory(obj, memory)
-        @rule_memory[obj] = memory
+      def update_action_sequence(obj, memory)
+        @action_sequence[obj] = memory
       end
 
       def snapshot_repo
@@ -141,8 +141,8 @@ module Nanoc
             [:default]
           end
 
-          def memory_for(obj)
-            @context.rule_memory_for(obj)
+          def action_sequence_for(obj)
+            @context.action_sequence_for(obj)
           end
 
           def snapshots_defs_for(_rep)

data/lib/nanoc/version.rb

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

data/spec/nanoc/base/checksummer_spec.rb

@@ -23,6 +23,26 @@ end
 describe Nanoc::Int::Checksummer do
   subject { described_class.calc(obj, Nanoc::Int::Checksummer::VerboseDigest) }
 
+  describe '.calc_for_each_attribute_of' do
+    let(:obj) { Nanoc::Int::Item.new('asdf', { 'foo' => 'bar' }, '/foo.md') }
+
+    context 'compact' do
+      subject do
+        described_class.calc_for_each_attribute_of(obj)
+      end
+
+      it { is_expected.to have_key(:foo) }
+    end
+
+    context 'verbose' do
+      subject do
+        described_class.calc_for_each_attribute_of(obj, Nanoc::Int::Checksummer::VerboseDigest)
+      end
+
+      it { is_expected.to eq(foo: 'String<bar>') }
+    end
+  end
+
   context 'String' do
     let(:obj) { 'hello' }
     it { is_expected.to eql('String<hello>') }

data/spec/nanoc/base/compiler_spec.rb

@@ -4,7 +4,7 @@ describe Nanoc::Int::Compiler do
       site,
       compiled_content_cache: compiled_content_cache,
       checksum_store: checksum_store,
-      rule_memory_store: rule_memory_store,
+      action_sequence_store: action_sequence_store,
       action_provider: action_provider,
       dependency_store: dependency_store,
       outdatedness_checker: outdatedness_checker,
@@ -13,8 +13,8 @@ describe Nanoc::Int::Compiler do
     )
   end
 
-  let(:checksum_store)    { Nanoc::Int::ChecksumStore.new(objects: items) }
-  let(:rule_memory_store) { Nanoc::Int::RuleMemoryStore.new }
+  let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: items) }
+  let(:action_sequence_store) { Nanoc::Int::ActionSequenceStore.new }
 
   let(:dependency_store) { Nanoc::Int::DependencyStore.new(items.to_a) }
   let(:reps) { Nanoc::Int::ItemRepRepo.new }
@@ -54,7 +54,7 @@ describe Nanoc::Int::Compiler do
         Nanoc::Int::ProcessingActions::Snapshot.new([:last], []),
       ]
 
-    Nanoc::Int::RuleMemory.new(nil, actions: actions)
+    Nanoc::Int::ActionSequence.new(nil, actions: actions)
   end
 
   before do
@@ -68,8 +68,9 @@ describe Nanoc::Int::Compiler do
     allow(outdatedness_checker).to receive(:outdated?).with(rep).and_return(true)
     allow(outdatedness_checker).to receive(:outdated?).with(other_rep).and_return(true)
 
-    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)
+    # 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
@@ -100,10 +101,6 @@ describe Nanoc::Int::Compiler do
     context 'interrupted compilation' do
       let(:item) { Nanoc::Int::Item.new('other=<%= @items["/other.*"].compiled_content %>', {}, '/hi.md') }
 
-      before do
-        expect(action_provider).to receive(:memory_for).with(other_rep).and_return(memory)
-      end
-
       it 'generates expected output' do
         expect(compiler.snapshot_repo.get(rep, :last)).to be_nil
 

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

@@ -0,0 +1,278 @@
+describe Nanoc::Int::ActionSequence do
+  let(:action_sequence) { described_class.new(rep) }
+  let(:rep) { double(:rep) }
+
+  describe '#size' do
+    subject { action_sequence.size }
+
+    context 'no actions' do
+      it { is_expected.to eql(0) }
+    end
+
+    context 'some actions' do
+      before do
+        action_sequence.add_filter(:foo, {})
+      end
+
+      it { is_expected.to eql(1) }
+    end
+  end
+
+  describe '#[]' do
+    subject { action_sequence[index] }
+    let(:index) { 0 }
+
+    context 'no actions' do
+      it { is_expected.to be_nil }
+    end
+
+    context 'some actions' do
+      before do
+        action_sequence.add_filter(:foo, {})
+      end
+
+      it { is_expected.to be_a(Nanoc::Int::ProcessingActions::Filter) }
+    end
+  end
+
+  describe '#add_filter' do
+    example do
+      action_sequence.add_filter(:foo, donkey: 123)
+
+      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)
+      expect(action_sequence[0].params).to eql(donkey: 123)
+    end
+  end
+
+  describe '#add_layout' do
+    example do
+      action_sequence.add_layout('/foo.*', donkey: 123)
+
+      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.*')
+      expect(action_sequence[0].params).to eql(donkey: 123)
+    end
+  end
+
+  describe '#add_snapshot' do
+    context 'snapshot does not yet exist' do
+      example do
+        action_sequence.add_snapshot(:before_layout, '/foo.md')
+
+        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])
+        expect(action_sequence[0].paths).to eql(['/foo.md'])
+      end
+    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)
+      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')
+    end
+
+    example do
+      actions = []
+      action_sequence.each { |a| actions << a }
+      expect(actions.size).to eq(3)
+    end
+  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')
+    end
+
+    example do
+      res = action_sequence.map { Nanoc::Int::ProcessingActions::Filter.new(:donkey, {}) }
+      expect(res.to_a.size).to eq(3)
+      expect(res.to_a).to all(be_a(Nanoc::Int::ProcessingActions::Filter))
+    end
+  end
+
+  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')
+    end
+
+    example do
+      expect(subject).to eql(
+        [
+          [:filter, :erb, 'PeWUm2PtXYtqeHJdTqnY7kkwAow='],
+          [:snapshot, [:bar], true, ['/foo.md']],
+          [:layout, '/default.erb', '97LAe1pYTLKczxBsu+x4MmvqdkU='],
+        ],
+      )
+    end
+  end
+
+  describe '#compact_snapshots' do
+    subject { action_sequence.compact_snapshots }
+
+    before do
+      action_sequence.add_snapshot(:a1, nil)
+      action_sequence.add_snapshot(:a2, '/a2.md')
+      action_sequence.add_snapshot(:a3, nil)
+      action_sequence.add_filter(:erb, awesomeness: 'high')
+      action_sequence.add_snapshot(:b1, '/b1.md')
+      action_sequence.add_snapshot(:b2, nil)
+      action_sequence.add_snapshot(:b3, '/b3.md')
+      action_sequence.add_filter(:erb, awesomeness: 'high')
+      action_sequence.add_snapshot(:c, nil)
+    end
+
+    example do
+      expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+      expect(subject[0].snapshot_names).to eql(%i(a1 a2 a3))
+      expect(subject[0].paths).to eql(['/a2.md'])
+
+      expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Filter)
+
+      expect(subject[2]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+      expect(subject[2].snapshot_names).to eql(%i(b1 b2 b3))
+      expect(subject[2].paths).to eql(['/b1.md', '/b3.md'])
+
+      expect(subject[3]).to be_a(Nanoc::Int::ProcessingActions::Filter)
+
+      expect(subject[4]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+      expect(subject[4].snapshot_names).to eql([:c])
+      expect(subject[4].paths).to be_empty
+
+      expect(subject.size).to eql(5)
+    end
+  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) }
+
+    Class.new(Nanoc::Filter) do
+      identifier :RuleMemSpec_filter_b2b
+      type :binary => :binary # rubocop:disable Style/HashSyntax
+
+      def run(content, params = {}); end
+    end
+
+    Class.new(Nanoc::Filter) do
+      identifier :RuleMemSpec_filter_b2t
+      type :binary => :text # rubocop:disable Style/HashSyntax
+
+      def run(content, params = {}); end
+    end
+
+    Class.new(Nanoc::Filter) do
+      identifier :RuleMemSpec_filter_t2t
+      type :text => :text # rubocop:disable Style/HashSyntax
+
+      def run(content, params = {}); end
+    end
+
+    Class.new(Nanoc::Filter) do
+      identifier :RuleMemSpec_filter_t2b
+      type :text => :binary # rubocop:disable Style/HashSyntax
+
+      def run(content, params = {}); end
+    end
+
+    it 'has no snapshot defs by default' do
+      expect(subject).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
+      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
+      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
+      end
+    end
+
+    context 'binary item' 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
+      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
+      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
+      end
+    end
+  end
+end