nanoc-core 4.12.10 → 4.12.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3365fa09f4ff20a16df20f260562fca8c64342098ba70b4547dc38580204ea2e
-  data.tar.gz: 132a480e5593d19bb6c1802f6f740e3ed1d081eb88f0178fbde311d9a4e52cc0
+  metadata.gz: 5f5cba2759d0a1a3fed3b3ecd60b4d48fe74e4e47d9855f585731a52436b407c
+  data.tar.gz: cbe6128977455e8109c3991059521a6f97053eda60eccaa4597637c680f89a00
 SHA512:
-  metadata.gz: 5c0190dbbad1225882d5b76891e80f45cf5e02238c6f6418071d9e8968e82cdd0263099eb5a71963b179238fb57a86f53ef7f7677592299c61cc6197be6b5dd9
-  data.tar.gz: 13424fbb1cc81c95e471a8ba99f172d24b6f33b1e9220a50773ed32554f5577622db7d63825734b04254e33c624b2d382b16ced1628952f5cee7e6429d96e57a
+  metadata.gz: 488a4b2b75e2a0a49f1a66f810003f5f11961e156013852cd97e1495bc1b66a0906b7efe1816a760127ed4759cd8926426d0dccc9776d12bb159ac15be3eabc6
+  data.tar.gz: 32cc8224e2aaf4abff07af2fb0401211f927bfa1e057c3641acdf043097df4554f4a70142cfcbac37f791f54dfefd196d10e0f48c7637d2692a94134b4850658

data/lib/nanoc/core/action_sequence.rb

@@ -7,11 +7,9 @@ module Nanoc
       include Enumerable
       prepend MemoWise
 
-      attr_reader :item_rep
       attr_reader :actions
 
-      def initialize(item_rep, actions: [])
-        @item_rep = item_rep
+      def initialize(actions: [])
         @actions = actions
       end
 
@@ -54,7 +52,6 @@ module Nanoc
       # contract C::Func[Nanoc::Core::ProcessingAction => C::Any] => self
       def map(&block)
         self.class.new(
-          @item_rep,
           actions: @actions.map(&block),
         )
       end

data/lib/nanoc/core/action_sequence_builder.rb

@@ -15,14 +15,13 @@ module Nanoc
         end
       end
 
-      def self.build(rep)
-        builder = new(rep)
+      def self.build
+        builder = new
         yield(builder)
         builder.action_sequence
       end
 
-      def initialize(item_rep)
-        @item_rep = item_rep
+      def initialize
         @actions = []
       end
 
@@ -38,24 +37,23 @@ module Nanoc
         self
       end
 
-      contract Symbol, C::Maybe[String] => self
-      def add_snapshot(snapshot_name, path)
-        will_add_snapshot(snapshot_name)
+      def add_snapshot(snapshot_name, path, rep)
+        will_add_snapshot(snapshot_name, rep)
         @actions << Nanoc::Core::ProcessingActions::Snapshot.new([snapshot_name], path ? [path] : [])
         self
       end
 
       contract C::None => Nanoc::Core::ActionSequence
       def action_sequence
-        Nanoc::Core::ActionSequence.new(@item_rep, actions: @actions)
+        Nanoc::Core::ActionSequence.new(actions: @actions)
       end
 
       private
 
-      def will_add_snapshot(name)
+      def will_add_snapshot(name, rep)
         @_snapshot_names ||= Set.new
         if @_snapshot_names.include?(name)
-          raise CannotCreateMultipleSnapshotsWithSameNameError.new(@item_rep, name)
+          raise CannotCreateMultipleSnapshotsWithSameNameError.new(rep, name)
         else
           @_snapshot_names << name
         end

data/lib/nanoc/core/basic_item_view.rb

@@ -34,7 +34,7 @@ module Nanoc
         parent_identifier = '/' + _unwrap.identifier.components[0..-2].join('/') + '/'
         parent_identifier = '/' if parent_identifier == '//'
 
-        parent = @context.items[parent_identifier]
+        parent = @context.items.object_with_identifier(parent_identifier)
 
         parent && self.class.new(parent, @context)
       end

data/lib/nanoc/core/basic_outdatedness_checker.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class BasicOutdatednessChecker
+      include Nanoc::Core::ContractsSupport
+
+      attr_reader :site
+      attr_reader :checksum_store
+      attr_reader :checksums
+      attr_reader :dependency_store
+      attr_reader :action_sequence_store
+      attr_reader :action_sequences
+
+      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 = C::Or[
+        Nanoc::Core::Item,
+        Nanoc::Core::ItemRep,
+        Nanoc::Core::Configuration,
+        Nanoc::Core::Layout,
+        Nanoc::Core::ItemCollection,
+      ]
+
+      C_OBJ_MAYBE_REP = C::Or[
+        Nanoc::Core::Item,
+        Nanoc::Core::ItemRep,
+        Nanoc::Core::Configuration,
+        Nanoc::Core::Layout,
+        Nanoc::Core::ItemCollection,
+        Nanoc::Core::LayoutCollection,
+      ]
+
+      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
+      def initialize(site:, checksum_store:, checksums:, dependency_store:, action_sequence_store:, action_sequences:, reps:)
+        @reps = reps
+        @site = site
+        @checksum_store = checksum_store
+        @checksums = checksums
+        @dependency_store = dependency_store
+        @action_sequence_store = action_sequence_store
+        @action_sequences = action_sequences
+
+        # Memoize
+        @_outdatedness_status_for = {}
+      end
+
+      contract C_OBJ_MAYBE_REP => C::Maybe[Nanoc::Core::OutdatednessStatus]
+      def outdatedness_status_for(obj)
+        # TODO: remove memoization (no longer needed)
+        @_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
+
+      def action_sequence_for(rep)
+        @action_sequences.fetch(rep)
+      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, self)
+            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) do |acc, elem|
+          apply_rules(rules, elem, acc)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compilation_stages/determine_outdatedness.rb

@@ -41,7 +41,12 @@ module Nanoc
         end
 
         def outdated?(rep)
-          @outdatedness_store.include?(rep) || @outdatedness_checker.outdated?(rep)
+          if @outdatedness_store.include?(rep)
+            # We determined previously that this rep is outdated.
+            true
+          else
+            !@outdatedness_checker.outdatedness_reasons_for(rep).empty?
+          end
         end
       end
     end

data/lib/nanoc/core/compilation_stages/load_stores.rb

@@ -16,18 +16,11 @@ module Nanoc
 
         contract C::None => C::Any
         def run
-          load_store(@checksum_store)
-          load_store(@compiled_content_cache)
-          load_store(@dependency_store)
-          load_store(@action_sequence_store)
-          load_store(@outdatedness_store)
-        end
-
-        contract Nanoc::Core::Store => C::Any
-        def load_store(store)
-          Nanoc::Core::Instrumentor.call(:store_loaded, store.class) do
-            store.load
-          end
+          @checksum_store.load
+          @compiled_content_cache.load
+          @dependency_store.load
+          @action_sequence_store.load
+          @outdatedness_store.load
         end
       end
     end

data/lib/nanoc/core/configuration.rb

@@ -176,6 +176,21 @@ module Nanoc
         "<#{self.class}>"
       end
 
+      contract C::None => C::Num
+      def hash
+        [@dir, @env_name].hash
+      end
+
+      contract C::Any => C::Bool
+      def ==(other)
+        eql?(other)
+      end
+
+      contract C::Any => C::Bool
+      def eql?(other)
+        other.is_a?(self.class) && @dir == other.dir && @env_name == other.env_name
+      end
+
       private
 
       def make_absolute(path)

data/lib/nanoc/core/errors.rb

@@ -72,10 +72,7 @@ module Nanoc
       # Error that is raised during site compilation when an item (directly or
       # indirectly) includes its own item content, leading to endless recursion.
       class DependencyCycle < ::Nanoc::Core::Error
-        def initialize(stack)
-          start_idx = stack.index(stack.last)
-          cycle = stack[start_idx..-2]
-
+        def initialize(cycle)
           msg_bits = []
           msg_bits << 'The site cannot be compiled because there is a dependency cycle:'
           msg_bits << ''

data/lib/nanoc/core/executor.rb

@@ -90,10 +90,11 @@ module Nanoc
 
       def find_layout(arg)
         req_id = arg.__nanoc_cleaned_identifier
-        layout = layouts[req_id]
+        layout = layouts.object_with_identifier(req_id)
         return layout if layout
 
         if use_globs?
+          # TODO: use object_matching_glob instead
           pat = Nanoc::Core::Pattern.from(arg)
           layout = layouts.find { |l| pat.match?(l.identifier) }
           return layout if layout

data/lib/nanoc/core/identifiable_collection.rb

@@ -37,15 +37,6 @@ module Nanoc
         super
       end
 
-      # contract C::Any => C::Maybe[C::RespondTo[:identifier]]
-      def [](arg)
-        if frozen?
-          get_memoized(arg)
-        else
-          get_unmemoized(arg)
-        end
-      end
-
       # contract C::Any => C::IterOf[C::RespondTo[:identifier]]
       def find_all(arg)
         if frozen?
@@ -75,7 +66,6 @@ module Nanoc
         self.class.new(@config, @objects.reject(&block))
       end
 
-      # contract C::Any => C::Maybe[C::RespondTo[:identifier]]
       def object_with_identifier(identifier)
         if frozen?
           @mapping[identifier.to_s]
@@ -84,26 +74,26 @@ module Nanoc
         end
       end
 
-      protected
-
-      # contract C::Any => C::Maybe[C::RespondTo[:identifier]]
-      def get_unmemoized(arg)
-        case arg
-        when Nanoc::Core::Identifier
-          object_with_identifier(arg)
-        when String
-          object_with_identifier(arg) || object_matching_glob(arg)
-        when Regexp
-          find { |i| i.identifier.to_s =~ arg }
+      def object_matching_glob(glob)
+        if frozen?
+          object_matching_glob_memoized(glob)
         else
-          raise ArgumentError, "don’t know how to fetch objects by #{arg.inspect}"
+          object_matching_glob_unmemoized(glob)
         end
       end
 
-      # contract C::Any => C::Maybe[C::RespondTo[:identifier]]
-      def get_memoized(_arg)
-        # TODO: Figure out how to get memo_wise to work with subclasses
-        raise 'implement in subclasses'
+      protected
+
+      def object_matching_glob_memoized(glob)
+        object_matching_glob_unmemoized(glob)
+      end
+      memo_wise :object_matching_glob_memoized
+
+      def object_matching_glob_unmemoized(glob)
+        if use_globs?
+          pat = Pattern.from(glob)
+          find { |i| pat.match?(i.identifier) }
+        end
       end
 
       # contract C::Any => C::IterOf[C::RespondTo[:identifier]]
@@ -118,13 +108,6 @@ module Nanoc
       end
       memo_wise :find_all_memoized
 
-      def object_matching_glob(glob)
-        if use_globs?
-          pat = Pattern.from(glob)
-          find { |i| pat.match?(i.identifier) }
-        end
-      end
-
       def build_mapping
         @mapping = {}
         each do |object|

data/lib/nanoc/core/identifiable_collection_view.rb

@@ -120,19 +120,63 @@ module Nanoc
       #
       #   @return [#identifier] if an object was found
       def [](arg)
-        prop_attribute =
-          case arg
-          when String, Nanoc::Core::Identifier
-            [arg.to_s]
-          when Regexp
-            [arg]
+        # The argument to #[] fall in two categories: exact matches, and
+        # patterns. An example of an exact match is '/about.md', while an
+        # example of a pattern is '/about.*'.
+        #
+        # If a Nanoc::Core::Identifier is given, we know it will need to be an
+        # exact match. If a String is given, it could be either. If a Regexp is
+        # given, we know it’s a pattern match.
+        #
+        # If we have a pattern match, create a dependency on the item
+        # collection, with a `raw_content` property that contains the pattern.
+        # If we have an exact match, do nothing -- there is no reason to create
+        # a dependency on the item itself, because accessing that item
+        # (attributes, compiled content, …) will create the dependency later.
+
+        object_from_exact_match = nil
+        object_from_pattern_match = nil
+
+        case arg
+        when Nanoc::Core::Identifier
+          # Can only be an exact match
+          object_from_exact_match = @objects.object_with_identifier(arg)
+        when String
+          # Can be an exact match, or a pattern match
+          tmp = @objects.object_with_identifier(arg)
+          if tmp
+            object_from_exact_match = tmp
           else
-            true
+            object_from_pattern_match = @objects.object_matching_glob(arg)
           end
+        when Regexp
+          # Can only be a pattern match
+          object_from_pattern_match = @objects.find { |i| i.identifier.to_s =~ arg }
+        else
+          raise ArgumentError, "Unexpected argument #{arg.class} to []: Can only pass strings, identfiers, and regular expressions"
+        end
 
-        @context.dependency_tracker.bounce(_unwrap, raw_content: prop_attribute)
-        res = @objects[arg]
-        res && view_class.new(res, @context)
+        unless object_from_exact_match
+          # We got this object from a pattern match. Create a dependency with
+          # this pattern, because if the objects matching this pattern change,
+          # then the result of #[] will change too.
+          #
+          # NOTE: object_from_exact_match can also be nil, but in that case
+          # we still need to create a dependency.
+
+          prop_attribute =
+            case arg
+            when Identifier
+              [arg.to_s]
+            when String, Regexp
+              [arg]
+            end
+
+          @context.dependency_tracker.bounce(_unwrap, raw_content: prop_attribute)
+        end
+
+        object = object_from_exact_match || object_from_pattern_match
+        object && view_class.new(object, @context)
       end
     end
   end

data/lib/nanoc/core/item_collection.rb

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

data/lib/nanoc/core/item_rep.rb

@@ -42,6 +42,9 @@ module Nanoc
         # Reset flags
         @compiled = false
         @modified = false
+
+        # Precalculate for performance
+        @hash = [self.class, item, name].hash
       end
 
       contract C::HashOf[Symbol => C::IterOf[C::AbsolutePathString]] => C::HashOf[Symbol => C::IterOf[C::AbsolutePathString]]
@@ -75,6 +78,21 @@ module Nanoc
         @paths.fetch(snapshot, []).first
       end
 
+      contract C::None => C::Num
+      def hash
+        @hash
+      end
+
+      contract C::Any => C::Bool
+      def ==(other)
+        eql?(other)
+      end
+
+      contract C::Any => C::Bool
+      def eql?(other)
+        other.is_a?(self.class) && item == other.item && name == other.name
+      end
+
       # Returns an object that can be used for uniquely identifying objects.
       def reference
         "item_rep:#{item.identifier}:#{name}"

data/lib/nanoc/core/item_rep_builder.rb

@@ -25,15 +25,15 @@ module Nanoc
         action_sequences = Nanoc::Core::ItemRepRouter.new(@reps, @action_provider, @site).run
 
         @reps.each do |rep|
-          rep.snapshot_defs = self.class.snapshot_defs_for(action_sequences[rep])
+          rep.snapshot_defs = self.class.snapshot_defs_for(action_sequences[rep], rep)
         end
 
         action_sequences
       end
 
-      contract Nanoc::Core::ActionSequence => C::ArrayOf[Nanoc::Core::SnapshotDef]
-      def self.snapshot_defs_for(action_sequence)
-        is_binary = action_sequence.item_rep.item.content.binary?
+      contract Nanoc::Core::ActionSequence, Nanoc::Core::ItemRep => C::ArrayOf[Nanoc::Core::SnapshotDef]
+      def self.snapshot_defs_for(action_sequence, rep)
+        is_binary = rep.item.content.binary?
         snapshot_defs = []
 
         action_sequence.each do |action|

data/lib/nanoc/core/item_rep_selector.rb

@@ -8,54 +8,121 @@ 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)
-          @stack = []
+          # Prio A: most important; prio C: least important.
+          @prio_a = []
+          @prio_b = ItemRepIgnorableIterator.new(reps)
+          @prio_c = []
+
+          # 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
+
+          # Record (hard) dependencies. Used for detecting cycles.
+          @dependencies = Hash.new { |hash, key| hash[key] = 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
+            return @this
+          end
+
+          # Read prio B
+          @this = @prio_b.next_ignoring(@seen)
+          if @this
+            return @this
           end
+
+          # Read prio C
+          @this = @prio_c.pop
+          if @this
+            return @this
+          end
+
+          nil
         end
 
         def mark_ok
-          @stack.pop
+          # Nothing to do
         end
 
         def mark_failed(dep)
-          if @stack.include?(dep)
-            raise Nanoc::Core::Errors::DependencyCycle.new(@stack + [dep])
-          end
+          record_dependency(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) unless @prio_c.include?(@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
+
+        private
 
-          @reps.delete(dep)
-          @stack.push(dep)
+        def record_dependency(dep)
+          @dependencies[@this] << dep
+
+          find_cycle(@this, [@this])
+        end
+
+        def find_cycle(dep, path)
+          @dependencies[dep].each do |dep1|
+            # Check whether this dependency path ends in `@this` again. If it
+            # does, we have a cycle (because we started from `@this`).
+            if dep1 == @this
+              raise Nanoc::Core::Errors::DependencyCycle.new(path)
+            end
+
+            # Continue checking, starting from `dep1` this time.
+            find_cycle(dep1, [*path, dep1])
+          end
         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_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/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,7 +123,7 @@ 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)
@@ -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,23 +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)
 
           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 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
+            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.
+
+              new_value = new_object_checksums[key]
+              new_value == dep_value
+            end
           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

data/lib/nanoc/core/store.rb

@@ -7,11 +7,7 @@ module Nanoc
     # graphs.
     #
     # Each store has a version number. When attempting to load data from a store
-    # that has an incompatible version number, no data will be loaded, but
-    # {#version_mismatch_detected} will be called.
-    #
-    # @abstract Subclasses must implement {#data} and {#data=}, and may
-    #   implement {#no_data_found} and {#version_mismatch_detected}.
+    # that has an incompatible version number, no data will be loaded.
     #
     # @api private
     class Store
@@ -78,17 +74,8 @@ module Nanoc
       #
       # @return [void]
       def load
-        return unless File.file?(filename)
-
-        begin
-          pstore.transaction(true) do
-            return if pstore[:version] != version
-
-            self.data = pstore[:data]
-          end
-        rescue
-          FileUtils.rm_f(filename)
-          load
+        Nanoc::Core::Instrumentor.call(:store_loaded, self.class) do
+          load_uninstrumented
         end
       end
 
@@ -97,18 +84,64 @@ module Nanoc
       #
       # @return [void]
       def store
-        FileUtils.mkdir_p(File.dirname(filename))
-
-        pstore.transaction do
-          pstore[:data]    = data
-          pstore[:version] = version
+        # NOTE: Yes, the “store stored” name is a little silly. Maybe stores
+        # need to be renamed to databases or so.
+        Nanoc::Core::Instrumentor.call(:store_stored, self.class) do
+          store_uninstrumented
         end
       end
 
       private
 
-      def pstore
-        @pstore ||= PStore.new(filename)
+      def load_uninstrumented
+        unsafe_load_uninstrumented
+      rescue
+        # An error occurred! Remove the database and try again
+        FileUtils.rm_f(version_filename)
+        FileUtils.rm_f(data_filename)
+
+        # Try again
+        unsafe_load_uninstrumented
+      end
+
+      def store_uninstrumented
+        FileUtils.mkdir_p(File.dirname(filename))
+
+        write_obj_to_file(version_filename, version)
+        write_obj_to_file(data_filename, data)
+
+        # Remove old file (back from the PStore days), if there are any.
+        FileUtils.rm_f(filename)
+      end
+
+      # Unsafe, because it can throw exceptions.
+      def unsafe_load_uninstrumented
+        # If there is no database, no point in loading anything
+        return unless File.file?(version_filename)
+
+        # Check if store version is the expected version. If it is not, don’t
+        # load.
+        read_version = read_obj_from_file(version_filename)
+        return if read_version != version
+
+        # Load data
+        self.data = read_obj_from_file(data_filename)
+      end
+
+      def write_obj_to_file(fn, obj)
+        File.binwrite(fn, Marshal.dump(obj))
+      end
+
+      def read_obj_from_file(fn)
+        Marshal.load(File.binread(fn))
+      end
+
+      def version_filename
+        "#{filename}.version.db"
+      end
+
+      def data_filename
+        "#{filename}.data.db"
       end
     end
   end

data/lib/nanoc/core/version.rb

@@ -2,6 +2,6 @@
 
 module Nanoc
   module Core
-    VERSION = '4.12.10'
+    VERSION = '4.12.12'
   end
 end

data/lib/nanoc/core.rb

@@ -33,6 +33,14 @@ module Nanoc
     # thus cannot be used to mean the presence of nothing.
     UNDEFINED = Object.new
 
+    def UNDEFINED.inspect
+      '<UNDEFINED>'
+    end
+
+    def UNDEFINED.to_s
+      inspect
+    end
+
     # @return [String] A string containing information about this Nanoc version
     #   and its environment (Ruby engine and version, Rubygems version if any).
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nanoc-core
 version: !ruby/object:Gem::Version
-  version: 4.12.10
+  version: 4.12.12
 platform: ruby
 authors:
 - Denis Defreyne
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-18 00:00:00.000000000 Z
+date: 2022-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -169,6 +169,7 @@ files:
 - lib/nanoc/core/basic_item_rep_collection_view.rb
 - lib/nanoc/core/basic_item_rep_view.rb
 - lib/nanoc/core/basic_item_view.rb
+- lib/nanoc/core/basic_outdatedness_checker.rb
 - lib/nanoc/core/binary_compiled_content_cache.rb
 - lib/nanoc/core/binary_content.rb
 - lib/nanoc/core/changes_stream.rb
@@ -315,7 +316,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.24
+rubygems_version: 3.3.25
 signing_key:
 specification_version: 4
 summary: Core of Nanoc