nanoc-core 4.14.6 → 4.14.8

data/lib/nanoc/core/layout_collection.rb

@@ -2,7 +2,7 @@
 
 module Nanoc
   module Core
-    class LayoutCollection < IdentifiableCollection
+    class LayoutCollection < Nanoc::Core::IdentifiableCollection
       prepend MemoWise
 
       def initialize(config, objects = [])
@@ -10,7 +10,7 @@ module Nanoc
       end
 
       def reference
-        'layouts'
+        :layouts
       end
     end
   end

data/lib/nanoc/core/mutable_document_view_mixin.rb

@@ -8,11 +8,9 @@ module Nanoc
         attr_reader :value
 
         def initialize(value)
-          @value = value
-        end
+          super("The #{value.class} cannot be stored inside an attribute. Store its identifier instead.")
 
-        def message
-          "The #{value.class} cannot be stored inside an attribute. Store its identifier instead."
+          @value = value
         end
       end
 
@@ -57,12 +55,11 @@ module Nanoc
         # the suggested alternative (Array#include?) carries a measurable
         # performance penatly.
         #
-        # rubocop:disable Style/MultipleComparison
+        # rubocop:disable-next 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

data/lib/nanoc/core/outdatedness_checker.rb

@@ -17,7 +17,13 @@ module Nanoc
 
       Reasons = Nanoc::Core::OutdatednessReasons
 
-      C_OBJ = C::Or[Nanoc::Core::Item, Nanoc::Core::ItemRep, Nanoc::Core::Configuration, Nanoc::Core::Layout, Nanoc::Core::ItemCollection]
+      C_OBJ = C::Or[
+        Nanoc::Core::Item,
+        Nanoc::Core::ItemRep,
+        Nanoc::Core::Configuration,
+        Nanoc::Core::Layout,
+        Nanoc::Core::ItemCollection,
+      ]
       C_ITEM_OR_REP = C::Or[Nanoc::Core::Item, Nanoc::Core::ItemRep]
       C_ACTION_SEQUENCES = C::HashOf[C_OBJ => Nanoc::Core::ActionSequence]
 
@@ -30,7 +36,10 @@ module Nanoc
         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:)
+      def initialize(
+        site:, checksum_store:, checksums:, dependency_store:,
+        action_sequence_store:, action_sequences:, reps:
+      )
         @site = site
         @checksum_store = checksum_store
         @checksums = checksums
@@ -40,31 +49,139 @@ module Nanoc
         @reps = reps
 
         @objects_outdated_due_to_dependencies = {}
+        @ran = false
       end
 
       contract C_OBJ => C::IterOf[Reasons::Generic]
       def outdatedness_reasons_for(obj)
-        basic_reasons = basic_outdatedness_statuses.fetch(obj).reasons
-        if !basic_reasons.empty?
-          basic_reasons
-        elsif outdated_due_to_dependencies?(obj)
-          [Reasons::DependenciesOutdated]
-        else
-          []
+        precalculate
+
+        basic_reasons = @basic_outdatedness_statuses.fetch(obj).reasons
+        unless basic_reasons.empty?
+          return basic_reasons
         end
+
+        obj = obj.item if obj.is_a?(Nanoc::Core::ItemRep)
+        if @objs_outdated_due_to_dependencies.include?(obj)
+          return [Reasons::DependenciesOutdated]
+        end
+
+        []
       end
 
       private
 
-      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)
+      def precalculate
+        return if @precalculated
+
+        @basic_outdatedness_statuses, basic_outdated_objs =
+          calc_basic_outdatedness_statuses
+
+        @objs_outdated_due_to_dependencies =
+          propagate_outdatedness(
+            @basic_outdatedness_statuses,
+            basic_outdated_objs,
+          )
+
+        @precalculated = true
+      end
+
+      def propagate_outdatedness(
+        basic_outdatedness_statuses,
+        basic_outdated_objs
+      )
+        objs_outdated_due_to_dependencies = Set.new
+
+        seen = Set.new
+        pending = [nil, @site.items, @site.layouts] + basic_outdated_objs.to_a
+        until pending.empty?
+          obj = pending.shift
+          obj = obj.item if obj.is_a?(Nanoc::Core::ItemRep)
+          next if seen.include?(obj)
+
+          seen << obj
+
+          deps = dependency_store.dependencies_outdated_because_of(obj)
+          deps.each do |dep|
+            # NOTE: dep.from == obj
+
+            status = basic_outdatedness_statuses[dep.to]
+            next if status && status.reasons.size.positive?
+            next if objs_outdated_due_to_dependencies.include?(dep.to)
+
+            case dep.from # from = what causes outdatedness
+
+            when nil
+              # Dependency from a removed object
+              objs_outdated_due_to_dependencies << dep.to
+              pending << dep.to
+
+            when Nanoc::Core::ItemCollection,
+              Nanoc::Core::LayoutCollection
+              coll = dep.from # or simply `obj`
+              props = dep.props
+
+              if raw_content_prop_causes_outdatedness?(
+                coll, props.raw_content, basic_outdatedness_statuses
+              ) || attributes_prop_causes_outdatedness?(
+                coll, props.attributes
+              )
+                objs_outdated_due_to_dependencies << dep.to
+                pending << dep.to
+              end
+
+            when Nanoc::Core::Item,
+              Nanoc::Core::Layout,
+              Nanoc::Core::Configuration
+              status = basic_outdatedness_statuses[dep.from]
+
+              active = status.props.active & dep.props.active
+              if attributes_unaffected?(status, dep)
+                active &= ~DependencyProps::BIT_PATTERN_ATTRIBUTES
+              end
+
+              if active != 0x00 || (
+                dep.props.compiled_content? &&
+                objs_outdated_due_to_dependencies.include?(dep.from)
+              )
+                objs_outdated_due_to_dependencies << dep.to
+                pending << dep.to
+              end
+
+            else
+              raise Nanoc::Core::Errors::InternalInconsistency,
+                    "unexpected object type: #{dep.from.inspect}"
+            end
+          end
+        end
+
+        objs_outdated_due_to_dependencies
+      end
+
+      def calc_basic_outdatedness_statuses
+        basic_outdatedness_statuses = {}
+        basic_outdated_objs = Set.new
+
+        collections = [
+          [@site.config, @site.layouts, @site.items],
+          @site.layouts,
+          @site.items,
+          @reps,
+        ]
+
+        collections.each do |collection|
+          collection.each do |obj|
+            status = basic.outdatedness_status_for(obj)
+
+            basic_outdatedness_statuses[obj] = status
+
+            unless status.reasons.empty?
+              basic_outdated_objs << obj
             end
           end
         end
+
+        [basic_outdatedness_statuses, basic_outdated_objs.freeze]
       end
 
       contract C::None => BasicOutdatednessChecker
@@ -80,95 +197,51 @@ module Nanoc
         )
       end
 
-      contract C_OBJ, Immutable::Set => C::Bool
-      def outdated_due_to_dependencies?(obj, processed = Immutable::Set.new)
-        # Convert from rep to item if necessary
-        obj = obj.item if obj.is_a?(Nanoc::Core::ItemRep)
-
-        # Only items can have dependencies
-        return false unless obj.is_a?(Nanoc::Core::Item)
-
-        # Get from cache
-        if @objects_outdated_due_to_dependencies.key?(obj)
-          return @objects_outdated_due_to_dependencies[obj]
-        end
-
-        # Check processed
-        # Don’t return true; the false will be or’ed into a true if there
-        # really is a dependency that is causing outdatedness.
-        return false if processed.include?(obj)
-
-        # Calculate
-        is_outdated = dependency_store.dependencies_causing_outdatedness_of(obj).any? do |dep|
-          dependency_causes_outdatedness?(dep) ||
-            (dep.props.compiled_content? &&
-              outdated_due_to_dependencies?(dep.from, processed.merge([obj])))
+      def attributes_unaffected?(status, dependency)
+        reason = status.reasons.find do |r|
+          r.is_a?(Nanoc::Core::OutdatednessReasons::AttributesModified)
         end
 
-        # Cache
-        @objects_outdated_due_to_dependencies[obj] = is_outdated
-
-        # Done
-        is_outdated
+        reason &&
+          !dependency.props.attribute_keys.empty? &&
+          !dependency.props.attribute_keys.intersect?(reason.attributes)
       end
 
-      contract Nanoc::Core::Dependency => C::Bool
-      def dependency_causes_outdatedness?(dependency)
-        case dependency.from
-        when nil
-          true
-        when Nanoc::Core::ItemCollection, Nanoc::Core::LayoutCollection
-          all_objects = dependency.from
-
-          raw_content_prop_causes_outdatedness?(all_objects, dependency.props.raw_content) ||
-            attributes_prop_causes_outdatedness?(all_objects, dependency.props.attributes)
-        else
-          status = basic_outdatedness_statuses.fetch(dependency.from)
+      def raw_content_prop_causes_outdatedness?(
+        collection, raw_content_prop, basic_outdatedness_statuses
+      )
+        return false unless raw_content_prop
 
-          active = status.props.active & dependency.props.active
-          active.delete(:attributes) if attributes_unaffected?(status, dependency)
+        document_added_reason =
+          basic_outdatedness_statuses
+          .fetch(collection)
+          .reasons
+          .grep(Nanoc::Core::OutdatednessReasons::DocumentAdded)
+          .first
+        return false unless document_added_reason
 
-          !active.empty?
-        end
-      end
+        case raw_content_prop
+        when true
+          true
 
-      def attributes_unaffected?(status, dependency)
-        reason = status.reasons.find { |r| r.is_a?(Nanoc::Core::OutdatednessReasons::AttributesModified) }
-        reason && !dependency.props.attribute_keys.empty? && !dependency.props.attribute_keys.intersect?(reason.attributes)
-      end
+        when Enumerable
+          patterns = raw_content_prop
+          identifiers = document_added_reason.identifiers
 
-      def raw_content_prop_causes_outdatedness?(objects, raw_content_prop)
-        return false unless raw_content_prop
+          patterns.any? do |pat|
+            coerced_pattern = Nanoc::Core::Pattern.from(pat)
 
-        matching_objects =
-          case raw_content_prop
-          when true
-            # If the `raw_content` dependency prop is `true`, then this is a
-            # dependency on all *objects* (items or layouts).
-            objects
-          when Enumerable
-            # If the `raw_content` dependency prop is a collection, then this
-            # is a dependency on specific objects, given by the patterns.
-            raw_content_prop.flat_map { |pat| objects.find_all(pat) }
-          else
-            raise(
-              Nanoc::Core::Errors::InternalInconsistency,
-              "Unexpected type of raw_content: #{raw_content_prop.inspect}",
-            )
+            identifiers.any? do |identifier|
+              coerced_pattern.match?(identifier)
+            end
           end
 
-        # For all objects matching the `raw_content` dependency prop:
-        # If the object is outdated because it is newly added,
-        # then this dependency causes outdatedness.
-        #
-        # Note that these objects might be modified but *not* newly added,
-        # in which case this dependency will *not* cause outdatedness.
-        # However, when the object is used later (e.g. attributes are
-        # accessed), then another dependency will exist that will cause
-        # outdatedness.
-        matching_objects.any? do |obj|
-          status = basic_outdatedness_statuses.fetch(obj)
-          status.reasons.any? { |r| r == Nanoc::Core::OutdatednessReasons::DocumentAdded }
+        else
+          raise(
+            Nanoc::Core::Errors::InternalInconsistency,
+            "Unexpected type of raw_content: #{raw_content_prop.inspect}",
+          )
+
         end
       end
 
@@ -182,7 +255,7 @@ module Nanoc
           )
         end
 
-        pairs = attributes_prop.select { |a| a.is_a?(Array) }.to_h
+        pairs = attributes_prop.grep(Array).to_h
 
         if pairs.empty?
           raise(
@@ -191,7 +264,9 @@ module Nanoc
           )
         end
 
-        dep_checksums = pairs.transform_values { |value| Nanoc::Core::Checksummer.calc(value) }
+        dep_checksums = pairs.transform_values do |value|
+          Nanoc::Core::Checksummer.calc(value)
+        end
 
         objects.any? do |object|
           # Find old and new attribute checksums for the object

data/lib/nanoc/core/outdatedness_reasons.rb

@@ -28,32 +28,55 @@ module Nanoc
       end
 
       CodeSnippetsModified = Generic.new(
-        'The code snippets have been modified since the last time the site was compiled.',
-        Nanoc::Core::DependencyProps.new(raw_content: true, attributes: true, compiled_content: true, path: true),
+        'The code snippets have been modified since the last time the site ' \
+        'was compiled.',
+        Nanoc::Core::DependencyProps.new(
+          raw_content: true, attributes: true,
+          compiled_content: true, path: true
+        ),
       )
 
       DependenciesOutdated = Generic.new(
-        'This item uses content or attributes that have changed since the last time the site was compiled.',
+        'This item uses content or attributes that have changed since the ' \
+        'last time the site was compiled.',
       )
 
       NotWritten = Generic.new(
-        'This item representation has not yet been written to the output directory (but it does have a path).',
-        Nanoc::Core::DependencyProps.new(raw_content: true, attributes: true, compiled_content: true, path: true),
+        'This item representation has not yet been written to the output ' \
+        'directory (but it does have a path).',
+        Nanoc::Core::DependencyProps.new(
+          raw_content: true, attributes: true,
+          compiled_content: true, path: true
+        ),
       )
 
       RulesModified = Generic.new(
-        'The rules file has been modified since the last time the site was compiled.',
+        'The rules file has been modified since the last time the site was ' \
+        'compiled.',
         Nanoc::Core::DependencyProps.new(compiled_content: true, path: true),
       )
 
-      DocumentAdded = Generic.new(
-        'The item or layout is newly added to the site.',
-        Nanoc::Core::DependencyProps.new, # NOTE: empty props, because they’re not relevant
-      )
+      class DocumentAdded < Generic
+        attr_reader :identifiers
+
+        def initialize(identifiers:)
+          super(
+            'Items or layouts were newly added to the site.',
+            Nanoc::Core::DependencyProps.new(
+              raw_content: true, compiled_content: true,
+            ),
+          )
+
+          @identifiers = identifiers
+        end
+      end
 
       ContentModified = Generic.new(
-        'The content of this item has been modified since the last time the site was compiled.',
-        Nanoc::Core::DependencyProps.new(raw_content: true, compiled_content: true),
+        'The content of this item has been modified since the last time ' \
+        'the site was compiled.',
+        Nanoc::Core::DependencyProps.new(
+          raw_content: true, compiled_content: true,
+        ),
       )
 
       class AttributesModified < Generic
@@ -61,8 +84,11 @@ module Nanoc
 
         def initialize(attributes)
           super(
-            'The attributes of this item have been modified since the last time the site was compiled.',
-            Nanoc::Core::DependencyProps.new(attributes: true, compiled_content: true),
+            'The attributes of this item have been modified since the last ' \
+            'time the site was compiled.',
+            Nanoc::Core::DependencyProps.new(
+              attributes: true, compiled_content: true,
+            ),
           )
 
           @attributes = attributes
@@ -70,8 +96,11 @@ module Nanoc
       end
 
       UsesAlwaysOutdatedFilter = Generic.new(
-        'This item rep uses one or more filters that cannot track dependencies, and will thus always be considered as outdated.',
-        Nanoc::Core::DependencyProps.new(raw_content: true, attributes: true, compiled_content: true),
+        'This item rep uses one or more filters that cannot track ' \
+        'dependencies, and will thus always be considered as outdated.',
+        Nanoc::Core::DependencyProps.new(
+          raw_content: true, attributes: true, compiled_content: true,
+        ),
       )
     end
   end

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

@@ -8,28 +8,42 @@ 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::BasicOutdatednessChecker'] => C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
+        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)
+          boc = basic_outdatedness_checker
+
           case obj
           when Nanoc::Core::ItemRep
-            apply(obj.item, basic_outdatedness_checker)
-          when Nanoc::Core::Item, Nanoc::Core::Layout, Nanoc::Core::Configuration
-            if basic_outdatedness_checker.checksum_store[obj] == basic_outdatedness_checker.checksums.checksum_for(obj)
+            apply(obj.item, boc)
+          when Nanoc::Core::Item,
+            Nanoc::Core::Layout,
+            Nanoc::Core::Configuration
+            if boc.checksum_store[obj] == boc.checksums.checksum_for(obj)
               return nil
             end
 
-            old_checksums = basic_outdatedness_checker.checksum_store.attributes_checksum_for(obj)
+            old_checksums = boc.checksum_store.attributes_checksum_for(obj)
             unless old_checksums
-              return Nanoc::Core::OutdatednessReasons::AttributesModified.new(true)
+              return Nanoc::Core::OutdatednessReasons::AttributesModified
+                     .new(true)
             end
 
-            new_checksums = basic_outdatedness_checker.checksums.attributes_checksum_for(obj)
+            new_checksums = boc.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] }
+            attributes =
+              Set.new(old_checksums.keys) + Set.new(new_checksums.keys)
+            changed_attributes =
+              attributes.reject { |a| old_checksums[a] == new_checksums[a] }
 
             unless changed_attributes.empty?
-              Nanoc::Core::OutdatednessReasons::AttributesModified.new(changed_attributes)
+              Nanoc::Core::OutdatednessReasons::AttributesModified
+                .new(changed_attributes)
             end
           else
             raise ArgumentError

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

@@ -6,10 +6,15 @@ module Nanoc
       class ItemAdded < Nanoc::Core::OutdatednessRule
         affects_props :raw_content
 
-        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
+        contract Nanoc::Core::ItemCollection,
+                 C::Named['Nanoc::Core::BasicOutdatednessChecker'] =>
+                 C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
+        def apply(_obj, basic_outdatedness_checker)
+          new_items = basic_outdatedness_checker.dependency_store.new_items
+          if new_items.size.positive?
+            Nanoc::Core::OutdatednessReasons::DocumentAdded.new(
+              identifiers: new_items.map(&:identifier),
+            )
           end
         end
       end

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

@@ -6,10 +6,15 @@ module Nanoc
       class LayoutAdded < Nanoc::Core::OutdatednessRule
         affects_props :raw_content
 
-        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
+        contract Nanoc::Core::LayoutCollection,
+                 C::Named['Nanoc::Core::BasicOutdatednessChecker'] =>
+                 C::Maybe[Nanoc::Core::OutdatednessReasons::Generic]
+        def apply(_obj, basic_outdatedness_checker)
+          new_layouts = basic_outdatedness_checker.dependency_store.new_layouts
+          if new_layouts.size.positive?
+            Nanoc::Core::OutdatednessReasons::DocumentAdded.new(
+              identifiers: new_layouts.map(&:identifier),
+            )
           end
         end
       end

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

@@ -7,7 +7,9 @@ module Nanoc
         affects_props :raw_content, :attributes, :compiled_content, :path
 
         def apply(obj, basic_outdatedness_checker)
-          if obj.raw_paths.values.flatten.compact.any? { |fn| !exist?(fn, basic_outdatedness_checker) }
+          if obj.raw_paths.values.flatten.compact.any? do |fn|
+            !exist?(fn, basic_outdatedness_checker)
+          end
             Nanoc::Core::OutdatednessReasons::NotWritten
           end
         end
@@ -24,7 +26,10 @@ module Nanoc
 
           @all ||= {}
           @all[basic_outdatedness_checker] ||= Set.new(
-            Dir.glob("#{site_root(basic_outdatedness_checker)}/**/*", File::FNM_DOTMATCH),
+            Dir.glob(
+              "#{site_root(basic_outdatedness_checker)}/**/*",
+              File::FNM_DOTMATCH,
+            ),
           )
         end
 

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

@@ -7,14 +7,16 @@ module Nanoc
         affects_props :compiled_content, :path
 
         def apply(obj, basic_outdatedness_checker)
+          boc = basic_outdatedness_checker
+
           # Check rules of obj itself
-          if rules_modified?(obj, basic_outdatedness_checker)
+          if rules_modified?(obj, boc)
             return Nanoc::Core::OutdatednessReasons::RulesModified
           end
 
           # Check rules of layouts used by obj
-          layouts = layouts_touched_by(obj, basic_outdatedness_checker)
-          if layouts.any? { |layout| rules_modified?(layout, basic_outdatedness_checker) }
+          layouts = layouts_touched_by(obj, boc)
+          if layouts.any? { |l| rules_modified?(l, boc) }
             return Nanoc::Core::OutdatednessReasons::RulesModified
           end
 
@@ -24,8 +26,13 @@ module Nanoc
         private
 
         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 =
+            basic_outdatedness_checker
+            .action_sequence_store[obj]
+          seq_new =
+            basic_outdatedness_checker
+            .action_sequence_for(obj)
+            .serialize
 
           !seq_old.eql?(seq_new)
         end
@@ -38,7 +45,8 @@ module Nanoc
 
           layout_actions.map do |layout_action|
             layout_pattern = layout_action[1]
-            layouts.object_with_identifier(layout_pattern) || layouts.object_matching_glob(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

@@ -15,7 +15,7 @@ module Nanoc
 
         def any_always_outdated?(seq)
           seq
-            .select { |a| a.is_a?(Nanoc::Core::ProcessingActions::Filter) }
+            .grep(Nanoc::Core::ProcessingActions::Filter)
             .map { |a| Nanoc::Core::Filter.named(a.filter_name) }
             .compact
             .any?(&:always_outdated?)

data/lib/nanoc/core/outdatedness_store.rb

@@ -8,7 +8,13 @@ module Nanoc
 
       contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
       def initialize(config:)
-        super(Nanoc::Core::Store.tmp_path_for(config:, store_name: 'outdatedness'), 2)
+        super(
+          self.class.tmp_path_for(
+            config:,
+            store_name: 'outdatedness',
+          ),
+          2,
+        )
 
         @outdated_refs = Set.new
       end

data/lib/nanoc/core/pattern.rb

@@ -17,7 +17,10 @@ module Nanoc
         when Symbol
           Nanoc::Core::StringPattern.new(obj.to_s)
         else
-          raise ArgumentError, "Do not know how to convert `#{obj.inspect}` into a Nanoc::Pattern"
+          raise(
+            ArgumentError,
+            "Do not know how to convert `#{obj.inspect}` into a Nanoc::Pattern",
+          )
         end
       end