nanoc-core 4.12.9 → 4.12.11

data/lib/nanoc/core/item_rep_selector.rb

@@ -8,23 +8,62 @@ module Nanoc
         @reps = reps
       end
 
-      class MicroGraph
+      # An iterator (FIFO) over an array, with ability to ignore certain
+      # elements.
+      class ItemRepIgnorableIterator
+        def initialize(array)
+          @array = array.dup
+        end
+
+        def next_ignoring(ignored)
+          elem = @array.shift
+          elem = @array.shift while ignored.include?(elem)
+          elem
+        end
+      end
+
+      # A priority queue that tracks dependencies and can detect circular
+      # dependencies.
+      class ItemRepPriorityQueue
         def initialize(reps)
-          @reps = Set.new(reps)
+          # Prio A: most important; prio C: least important.
+          @prio_a = []
+          @prio_b = ItemRepIgnorableIterator.new(reps)
+          @prio_c = []
+
+          # Stack of things that depend on each other. This is used for
+          # detecting and reporting circular dependencies.
           @stack = []
+
+          # List of reps that we’ve already seen. Reps from `reps` will end up
+          # in here. Reps can end up in here even *before* they come from
+          # `reps`, when they are part of a dependency.
+          @seen = Set.new
         end
 
         def next
-          if @stack.any?
-            @stack.last
-          elsif @reps.any?
-            @reps.each { |rep| break rep }.tap do |rep|
-              @reps.delete(rep)
-              @stack.push(rep)
-            end
-          else
-            nil
+          # Read prio A
+          @this = @prio_a.pop
+          if @this
+            @stack.push(@this)
+            return @this
           end
+
+          # Read prio B
+          @this = @prio_b.next_ignoring(@seen)
+          if @this
+            @stack.push(@this)
+            return @this
+          end
+
+          # Read prio C
+          @this = @prio_c.pop
+          if @this
+            @stack.push(@this)
+            return @this
+          end
+
+          nil
         end
 
         def mark_ok
@@ -36,26 +75,39 @@ module Nanoc
             raise Nanoc::Core::Errors::DependencyCycle.new(@stack + [dep])
           end
 
-          @reps.delete(dep)
-          @stack.push(dep)
+          # `@this` depends on `dep`, so `dep` has to be compiled first. Thus,
+          # move `@this` into priority C, and `dep` into priority A.
+
+          # Put `@this` (item rep that needs `dep` to be compiled first) into
+          # priority C (lowest prio).
+          @prio_c.push(@this)
+
+          # Put `dep` (item rep that needs to be compiled first, before
+          # `@this`) into priority A (highest prio).
+          @prio_a.push(dep)
+
+          # Remember that we’ve prioritised `dep`. This particular element will
+          # come from @prio_b at some point in the future, so we’ll have to skip
+          # it then.
+          @seen << dep
         end
       end
 
       def each
-        mg = MicroGraph.new(@reps)
+        pq = ItemRepPriorityQueue.new(@reps)
 
         loop do
-          rep = mg.next
+          rep = pq.next
           break if rep.nil?
 
           begin
             yield(rep)
-            mg.mark_ok
+            pq.mark_ok
           rescue => e
             actual_error = e.is_a?(Nanoc::Core::Errors::CompilationError) ? e.unwrap : e
 
             if actual_error.is_a?(Nanoc::Core::Errors::UnmetDependency)
-              mg.mark_failed(actual_error.rep)
+              pq.mark_failed(actual_error.rep)
             else
               raise(e)
             end

data/lib/nanoc/core/layout.rb

@@ -4,7 +4,7 @@ module Nanoc
   module Core
     class Layout < ::Nanoc::Core::Document
       def reference
-        "layout:#{identifier}"
+        @_reference ||= "layout:#{identifier}"
       end
     end
   end

data/lib/nanoc/core/layout_collection.rb

@@ -9,12 +9,6 @@ module Nanoc
         initialize_basic(config, objects, 'layouts')
       end
 
-      # contract C::Any => C::Maybe[C::RespondTo[:identifier]]
-      def get_memoized(arg)
-        get_unmemoized(arg)
-      end
-      memo_wise :get_memoized
-
       def reference
         'layouts'
       end

data/lib/nanoc/core/mutable_document_view_mixin.rb

@@ -26,13 +26,7 @@ module Nanoc
       #
       # @see Hash#[]=
       def []=(key, value)
-        disallowed_value_classes = Set.new([
-          Nanoc::Core::Item,
-          Nanoc::Core::Layout,
-          Nanoc::Core::CompilationItemView,
-          Nanoc::Core::LayoutView,
-        ])
-        if disallowed_value_classes.include?(value.class)
+        if disallowed_value_class?(value.class)
           raise DisallowedAttributeValueError.new(value)
         end
 
@@ -55,6 +49,21 @@ module Nanoc
         hash.each { |k, v| _unwrap.set_attribute(k, v) }
         self
       end
+
+      private
+
+      def disallowed_value_class?(klass)
+        # NOTE: We’re explicitly disabling Style/MultipleComparison, because
+        # the suggested alternative (Array#include?) carries a measurable
+        # performance penatly.
+        #
+        # rubocop:disable Style/MultipleComparison
+        klass == Nanoc::Core::Item ||
+          klass == Nanoc::Core::Layout ||
+          klass == Nanoc::Core::CompilationItemView ||
+          klass == Nanoc::Core::LayoutView
+        # rubocop:enable Style/MultipleComparison
+      end
     end
   end
 end

data/lib/nanoc/core/outdatedness_checker.rb

@@ -6,92 +6,6 @@ module Nanoc
     #
     # @api private
     class OutdatednessChecker
-      class Basic
-        include Nanoc::Core::ContractsSupport
-
-        Rules = Nanoc::Core::OutdatednessRules
-
-        RULES_FOR_ITEM_REP =
-          [
-            Rules::ItemAdded,
-            Rules::RulesModified,
-            Rules::ContentModified,
-            Rules::AttributesModified,
-            Rules::NotWritten,
-            Rules::CodeSnippetsModified,
-            Rules::UsesAlwaysOutdatedFilter,
-          ].freeze
-
-        RULES_FOR_LAYOUT =
-          [
-            Rules::LayoutAdded,
-            Rules::RulesModified,
-            Rules::ContentModified,
-            Rules::AttributesModified,
-            Rules::UsesAlwaysOutdatedFilter,
-          ].freeze
-
-        RULES_FOR_CONFIG =
-          [
-            Rules::AttributesModified,
-          ].freeze
-
-        C_OBJ_MAYBE_REP = C::Or[Nanoc::Core::Item, Nanoc::Core::ItemRep, Nanoc::Core::Configuration, Nanoc::Core::Layout, Nanoc::Core::ItemCollection, Nanoc::Core::LayoutCollection]
-
-        contract C::KeywordArgs[outdatedness_checker: OutdatednessChecker, reps: Nanoc::Core::ItemRepRepo] => C::Any
-        def initialize(outdatedness_checker:, reps:)
-          @outdatedness_checker = outdatedness_checker
-          @reps = reps
-
-          # Memoize
-          @_outdatedness_status_for = {}
-        end
-
-        contract C_OBJ_MAYBE_REP => C::Maybe[Nanoc::Core::OutdatednessStatus]
-        def outdatedness_status_for(obj)
-          @_outdatedness_status_for[obj] ||=
-            case obj
-            when Nanoc::Core::ItemRep
-              apply_rules(RULES_FOR_ITEM_REP, obj)
-            when Nanoc::Core::Item
-              apply_rules_multi(RULES_FOR_ITEM_REP, @reps[obj])
-            when Nanoc::Core::Layout
-              apply_rules(RULES_FOR_LAYOUT, obj)
-            when Nanoc::Core::Configuration
-              apply_rules(RULES_FOR_CONFIG, obj)
-            when Nanoc::Core::ItemCollection, Nanoc::Core::LayoutCollection
-              # Collections are never outdated. Objects inside them might be,
-              # however.
-              apply_rules([], obj)
-            else
-              raise Nanoc::Core::Errors::InternalInconsistency, "do not know how to check outdatedness of #{obj.inspect}"
-            end
-        end
-
-        private
-
-        contract C::ArrayOf[Class], C_OBJ_MAYBE_REP, Nanoc::Core::OutdatednessStatus => C::Maybe[Nanoc::Core::OutdatednessStatus]
-        def apply_rules(rules, obj, status = Nanoc::Core::OutdatednessStatus.new)
-          rules.inject(status) do |acc, rule|
-            if acc.useful_to_apply?(rule)
-              reason = rule.instance.call(obj, @outdatedness_checker)
-              if reason
-                acc.update(reason)
-              else
-                acc
-              end
-            else
-              acc
-            end
-          end
-        end
-
-        contract C::ArrayOf[Class], C::ArrayOf[C_OBJ_MAYBE_REP] => C::Maybe[Nanoc::Core::OutdatednessStatus]
-        def apply_rules_multi(rules, objs)
-          objs.inject(Nanoc::Core::OutdatednessStatus.new) { |acc, elem| apply_rules(rules, elem, acc) }
-        end
-      end
-
       include Nanoc::Core::ContractsSupport
 
       attr_reader :checksum_store
@@ -107,7 +21,15 @@ module Nanoc
       C_ITEM_OR_REP = C::Or[Nanoc::Core::Item, Nanoc::Core::ItemRep]
       C_ACTION_SEQUENCES = C::HashOf[C_OBJ => Nanoc::Core::ActionSequence]
 
-      contract C::KeywordArgs[site: Nanoc::Core::Site, checksum_store: Nanoc::Core::ChecksumStore, checksums: Nanoc::Core::ChecksumCollection, dependency_store: Nanoc::Core::DependencyStore, action_sequence_store: Nanoc::Core::ActionSequenceStore, action_sequences: C_ACTION_SEQUENCES, reps: Nanoc::Core::ItemRepRepo] => C::Any
+      contract C::KeywordArgs[
+        site: Nanoc::Core::Site,
+        checksum_store: Nanoc::Core::ChecksumStore,
+        checksums: Nanoc::Core::ChecksumCollection,
+        dependency_store: Nanoc::Core::DependencyStore,
+        action_sequence_store: Nanoc::Core::ActionSequenceStore,
+        action_sequences: C_ACTION_SEQUENCES,
+        reps: Nanoc::Core::ItemRepRepo
+      ] => C::Any
       def initialize(site:, checksum_store:, checksums:, dependency_store:, action_sequence_store:, action_sequences:, reps:)
         @site = site
         @checksum_store = checksum_store
@@ -120,20 +42,11 @@ module Nanoc
         @objects_outdated_due_to_dependencies = {}
       end
 
-      def action_sequence_for(rep)
-        @action_sequences.fetch(rep)
-      end
-
-      contract C_OBJ => C::Bool
-      def outdated?(obj)
-        outdatedness_reasons_for(obj).any?
-      end
-
       contract C_OBJ => C::IterOf[Reasons::Generic]
       def outdatedness_reasons_for(obj)
-        reasons = basic.outdatedness_status_for(obj).reasons
-        if reasons.any?
-          reasons
+        basic_reasons = basic_outdatedness_statuses.fetch(obj).reasons
+        if basic_reasons.any?
+          basic_reasons
         elsif outdated_due_to_dependencies?(obj)
           [Reasons::DependenciesOutdated]
         else
@@ -143,9 +56,28 @@ module Nanoc
 
       private
 
-      contract C::None => Basic
+      def basic_outdatedness_statuses
+        @_basic_outdatedness_statuses ||= {}.tap do |tmp|
+          collections = [[@site.config], @site.layouts, @site.items, @reps]
+          collections.each do |collection|
+            collection.each do |obj|
+              tmp[obj] = basic.outdatedness_status_for(obj)
+            end
+          end
+        end
+      end
+
+      contract C::None => BasicOutdatednessChecker
       def basic
-        @_basic ||= Basic.new(outdatedness_checker: self, reps: @reps)
+        @_basic ||= BasicOutdatednessChecker.new(
+          site: @site,
+          checksum_store: @checksum_store,
+          checksums: @checksums,
+          dependency_store: @dependency_store,
+          action_sequence_store: @action_sequence_store,
+          action_sequences: @action_sequences,
+          reps: @reps,
+        )
       end
 
       contract C_OBJ, Hamster::Set => C::Bool
@@ -191,12 +123,12 @@ module Nanoc
           raw_content_prop_causes_outdatedness?(all_objects, dependency.props.raw_content) ||
             attributes_prop_causes_outdatedness?(all_objects, dependency.props.attributes)
         else
-          status = basic.outdatedness_status_for(dependency.from)
+          status = basic_outdatedness_statuses.fetch(dependency.from)
 
           active = status.props.active & dependency.props.active
           active.delete(:attributes) if attributes_unaffected?(status, dependency)
 
-          active.any?
+          !active.empty?
         end
       end
 
@@ -217,8 +149,7 @@ module Nanoc
           when Enumerable
             # If the `raw_content` dependency prop is a collection, then this
             # is a dependency on specific objects, given by the patterns.
-            patterns = raw_content_prop.map { |r| Nanoc::Core::Pattern.from(r) }
-            patterns.flat_map { |pat| objects.select { |obj| pat.match?(obj.identifier) } }
+            raw_content_prop.flat_map { |pat| objects.find_all(pat) }
           else
             raise(
               Nanoc::Core::Errors::InternalInconsistency,
@@ -236,7 +167,7 @@ module Nanoc
         # accessed), then another dependency will exist that will cause
         # outdatedness.
         matching_objects.any? do |obj|
-          status = basic.outdatedness_status_for(obj)
+          status = basic_outdatedness_statuses.fetch(obj)
           status.reasons.any? { |r| Nanoc::Core::OutdatednessReasons::DocumentAdded == r }
         end
       end
@@ -265,27 +196,30 @@ module Nanoc
         objects.any? do |object|
           # Find old and new attribute checksums for the object
           old_object_checksums = checksum_store.attributes_checksum_for(object)
-          next false unless old_object_checksums
-
           new_object_checksums = checksums.attributes_checksum_for(object)
 
-          # Ignore any attribute not mentioned in the dependency
-          old_object_checksums = old_object_checksums.select { |k, _v| dep_checksums.key?(k) }
-          new_object_checksums = new_object_checksums.select { |k, _v| dep_checksums.key?(k) }
-
           dep_checksums.any? do |key, dep_value|
-            # Get old and new checksum for this particular attribute
-            old_value = old_object_checksums[key]
-            new_value = new_object_checksums[key]
-
-            # If either the old or new vale match the value in the dependency,
-            # then a potential change is relevant to us, and can cause
-            # outdatedness.
-            is_match = [old_value, new_value].include?(dep_value)
-
-            is_changed = old_value != new_value
+            if old_object_checksums
+              # Get old and new checksum for this particular attribute
+              old_value = old_object_checksums[key]
+              new_value = new_object_checksums[key]
+
+              # If the old and new checksums are identical, then the attribute
+              # is unchanged and can’t cause outdatedness.
+              next false unless old_value != new_value
+
+              # We already know that the old value and new value are different.
+              # This attribute will cause outdatedness if either of those
+              # checksums is identical to the one in the prop.
+              old_value == dep_value || new_value == dep_value
+            else
+              # We don’t have the previous checksums, which means this item is
+              # newly added. In this case, we can compare the value in the
+              # dependency with the new checksum.
 
-            is_match && is_changed
+              new_value = new_object_checksums[key]
+              new_value == dep_value
+            end
           end
         end
       end

data/lib/nanoc/core/outdatedness_rule.rb

@@ -23,11 +23,39 @@ module Nanoc
       end
 
       def self.affects_props(*names)
-        @affected_props = Set.new(names)
+        @affects_raw_content = false
+        @affects_attributes = false
+        @affects_compiled_content = false
+        @affects_path = false
+
+        names.each do |name|
+          case name
+          when :raw_content
+            @affects_raw_content = true
+          when :attributes
+            @affects_attributes = true
+          when :compiled_content
+            @affects_compiled_content = true
+          when :path
+            @affects_path = true
+          end
+        end
+      end
+
+      def self.affects_raw_content?
+        @affects_raw_content
+      end
+
+      def self.affects_attributes?
+        @affects_attributes
+      end
+
+      def self.affects_compiled_content?
+        @affects_compiled_content
       end
 
-      def self.affected_props
-        @affected_props
+      def self.affects_path?
+        @affects_path
       end
     end
   end

data/lib/nanoc/core/outdatedness_rules/attributes_modified.rb

@@ -8,22 +8,22 @@ module Nanoc
 
         affects_props :attributes, :compiled_content
 
-        contract C::Or[Nanoc::Core::ItemRep, Nanoc::Core::Item, Nanoc::Core::Configuration, Nanoc::Core::Layout], C::Named['Nanoc::Core::OutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
-        def apply(obj, outdatedness_checker)
+        contract C::Or[Nanoc::Core::ItemRep, Nanoc::Core::Item, Nanoc::Core::Configuration, Nanoc::Core::Layout], C::Named['Nanoc::Core::BasicOutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
+        def apply(obj, basic_outdatedness_checker)
           case obj
           when Nanoc::Core::ItemRep
-            apply(obj.item, outdatedness_checker)
+            apply(obj.item, basic_outdatedness_checker)
           when Nanoc::Core::Item, Nanoc::Core::Layout, Nanoc::Core::Configuration
-            if outdatedness_checker.checksum_store[obj] == outdatedness_checker.checksums.checksum_for(obj)
+            if basic_outdatedness_checker.checksum_store[obj] == basic_outdatedness_checker.checksums.checksum_for(obj)
               return nil
             end
 
-            old_checksums = outdatedness_checker.checksum_store.attributes_checksum_for(obj)
+            old_checksums = basic_outdatedness_checker.checksum_store.attributes_checksum_for(obj)
             unless old_checksums
               return Nanoc::Core::OutdatednessReasons::AttributesModified.new(true)
             end
 
-            new_checksums = outdatedness_checker.checksums.attributes_checksum_for(obj)
+            new_checksums = basic_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/core/outdatedness_rules/code_snippets_modified.rb

@@ -10,18 +10,18 @@ module Nanoc
 
         affects_props :raw_content, :attributes, :compiled_content, :path
 
-        def apply(_obj, outdatedness_checker)
-          if any_snippets_modified?(outdatedness_checker)
+        def apply(_obj, basic_outdatedness_checker)
+          if any_snippets_modified?(basic_outdatedness_checker)
             Nanoc::Core::OutdatednessReasons::CodeSnippetsModified
           end
         end
 
         private
 
-        def any_snippets_modified?(outdatedness_checker)
-          outdatedness_checker.site.code_snippets.any? do |cs|
-            ch_old = outdatedness_checker.checksum_store[cs]
-            ch_new = outdatedness_checker.checksums.checksum_for(cs)
+        def any_snippets_modified?(basic_outdatedness_checker)
+          basic_outdatedness_checker.site.code_snippets.any? do |cs|
+            ch_old = basic_outdatedness_checker.checksum_store[cs]
+            ch_new = basic_outdatedness_checker.checksums.checksum_for(cs)
             ch_old != ch_new
           end
         end

data/lib/nanoc/core/outdatedness_rules/content_modified.rb

@@ -6,11 +6,11 @@ module Nanoc
       class ContentModified < Nanoc::Core::OutdatednessRule
         affects_props :raw_content, :compiled_content
 
-        def apply(obj, outdatedness_checker)
+        def apply(obj, basic_outdatedness_checker)
           obj = obj.item if obj.is_a?(Nanoc::Core::ItemRep)
 
-          ch_old = outdatedness_checker.checksum_store.content_checksum_for(obj)
-          ch_new = outdatedness_checker.checksums.content_checksum_for(obj)
+          ch_old = basic_outdatedness_checker.checksum_store.content_checksum_for(obj)
+          ch_new = basic_outdatedness_checker.checksums.content_checksum_for(obj)
           if ch_old != ch_new
             Nanoc::Core::OutdatednessReasons::ContentModified
           end

data/lib/nanoc/core/outdatedness_rules/item_added.rb

@@ -6,9 +6,9 @@ module Nanoc
       class ItemAdded < Nanoc::Core::OutdatednessRule
         affects_props :raw_content
 
-        contract Nanoc::Core::ItemRep, C::Named['Nanoc::Core::OutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
-        def apply(obj, outdatedness_checker)
-          if outdatedness_checker.dependency_store.new_items.include?(obj.item)
+        contract Nanoc::Core::ItemRep, C::Named['Nanoc::Core::BasicOutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
+        def apply(obj, basic_outdatedness_checker)
+          if basic_outdatedness_checker.dependency_store.new_items.include?(obj.item)
             Nanoc::Core::OutdatednessReasons::DocumentAdded
           end
         end

data/lib/nanoc/core/outdatedness_rules/layout_added.rb

@@ -6,9 +6,9 @@ module Nanoc
       class LayoutAdded < Nanoc::Core::OutdatednessRule
         affects_props :raw_content
 
-        contract Nanoc::Core::Layout, C::Named['Nanoc::Core::OutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
-        def apply(obj, outdatedness_checker)
-          if outdatedness_checker.dependency_store.new_layouts.include?(obj)
+        contract Nanoc::Core::Layout, C::Named['Nanoc::Core::BasicOutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
+        def apply(obj, basic_outdatedness_checker)
+          if basic_outdatedness_checker.dependency_store.new_layouts.include?(obj)
             Nanoc::Core::OutdatednessReasons::DocumentAdded
           end
         end

data/lib/nanoc/core/outdatedness_rules/not_written.rb

@@ -6,30 +6,30 @@ module Nanoc
       class NotWritten < Nanoc::Core::OutdatednessRule
         affects_props :raw_content, :attributes, :compiled_content, :path
 
-        def apply(obj, outdatedness_checker)
-          if obj.raw_paths.values.flatten.compact.any? { |fn| !exist?(fn, outdatedness_checker) }
+        def apply(obj, basic_outdatedness_checker)
+          if obj.raw_paths.values.flatten.compact.any? { |fn| !exist?(fn, basic_outdatedness_checker) }
             Nanoc::Core::OutdatednessReasons::NotWritten
           end
         end
 
         private
 
-        def exist?(fn, outdatedness_checker)
-          all(outdatedness_checker).include?(fn)
+        def exist?(fn, basic_outdatedness_checker)
+          all(basic_outdatedness_checker).include?(fn)
         end
 
-        def all(outdatedness_checker)
+        def all(basic_outdatedness_checker)
           # NOTE: Cached per outdatedness checker, so that unrelated invocations
           # later on don’t reuse an old cache.
 
           @all ||= {}
-          @all[outdatedness_checker] ||= Set.new(
-            Dir.glob("#{site_root(outdatedness_checker)}/**/*", File::FNM_DOTMATCH),
+          @all[basic_outdatedness_checker] ||= Set.new(
+            Dir.glob("#{site_root(basic_outdatedness_checker)}/**/*", File::FNM_DOTMATCH),
           )
         end
 
-        def site_root(outdatedness_checker)
-          outdatedness_checker.site.config.output_dir
+        def site_root(basic_outdatedness_checker)
+          basic_outdatedness_checker.site.config.output_dir
         end
       end
     end

data/lib/nanoc/core/outdatedness_rules/rules_modified.rb

@@ -6,15 +6,15 @@ module Nanoc
       class RulesModified < Nanoc::Core::OutdatednessRule
         affects_props :compiled_content, :path
 
-        def apply(obj, outdatedness_checker)
+        def apply(obj, basic_outdatedness_checker)
           # Check rules of obj itself
-          if rules_modified?(obj, outdatedness_checker)
+          if rules_modified?(obj, basic_outdatedness_checker)
             return Nanoc::Core::OutdatednessReasons::RulesModified
           end
 
           # Check rules of layouts used by obj
-          layouts = layouts_touched_by(obj, outdatedness_checker)
-          if layouts.any? { |layout| rules_modified?(layout, outdatedness_checker) }
+          layouts = layouts_touched_by(obj, basic_outdatedness_checker)
+          if layouts.any? { |layout| rules_modified?(layout, basic_outdatedness_checker) }
             return Nanoc::Core::OutdatednessReasons::RulesModified
           end
 
@@ -23,20 +23,22 @@ module Nanoc
 
         private
 
-        def rules_modified?(obj, outdatedness_checker)
-          seq_old = outdatedness_checker.action_sequence_store[obj]
-          seq_new = outdatedness_checker.action_sequence_for(obj).serialize
+        def rules_modified?(obj, basic_outdatedness_checker)
+          seq_old = basic_outdatedness_checker.action_sequence_store[obj]
+          seq_new = basic_outdatedness_checker.action_sequence_for(obj).serialize
 
           !seq_old.eql?(seq_new)
         end
 
-        def layouts_touched_by(obj, outdatedness_checker)
-          actions = outdatedness_checker.action_sequence_store[obj]
+        def layouts_touched_by(obj, basic_outdatedness_checker)
+          actions = basic_outdatedness_checker.action_sequence_store[obj]
           layout_actions = actions.select { |a| a.first == :layout }
 
+          layouts = basic_outdatedness_checker.site.layouts
+
           layout_actions.map do |layout_action|
             layout_pattern = layout_action[1]
-            outdatedness_checker.site.layouts[layout_pattern]
+            layouts.object_with_identifier(layout_pattern) || layouts.object_matching_glob(layout_pattern)
           end.compact
         end
       end

data/lib/nanoc/core/outdatedness_rules/uses_always_outdated_filter.rb

@@ -6,8 +6,8 @@ module Nanoc
       class UsesAlwaysOutdatedFilter < Nanoc::Core::OutdatednessRule
         affects_props :raw_content, :attributes, :path
 
-        def apply(obj, outdatedness_checker)
-          seq = outdatedness_checker.action_sequence_for(obj)
+        def apply(obj, basic_outdatedness_checker)
+          seq = basic_outdatedness_checker.action_sequence_for(obj)
           if any_always_outdated?(seq)
             Nanoc::Core::OutdatednessReasons::UsesAlwaysOutdatedFilter
           end