nanoc-core 4.12.9 → 4.12.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 835f6e4a74f07183143caa0c2d27f304fa5a712c3231dddc2dd28974f714b117
-  data.tar.gz: 71331c08284b2f0da1b6410c8a5c17230efa1606640c1ca7e8724fb97e037951
+  metadata.gz: d7fc026255728ddb8de8c0756afdfbdc7548e47938d9c4fb464023c0811ae4e2
+  data.tar.gz: a8531e9c3920f81c9caa88996b1f195eedec21ef392cda04cd2fcf76c0f83106
 SHA512:
-  metadata.gz: 1c3b6430105aab73a5e9efff550b3519bd3e19cf99cb9b70f7a3b42916fd48becc091ea7325740673936373650e0d2950f986e507128aa1a7156f0e95bbb1520
-  data.tar.gz: 24ef14012f2ed47f9dd77f885601c395b58fb4d50fb61afa2196fedeecac2571d3702ad87f0e7d80d8806a07b6712364774cf6012650595f4a0cae072e85353e
+  metadata.gz: f819fe95a0d25831e51ba4ce360ca76921c01517402bf67d3407d369b1fc8c7f05a7262fe0df1dbfd03e3c3f12d72281d818db19746f294f135e8b017a21a07d
+  data.tar.gz: c0de0aef8f83c0a7723d755bf804a25f3ca574e308b54b36cac6e0a91ac5b0b2c4658635cd899d18fdc830d51250a151cbb23d69dfdd4b4abd1cde5b12c96a2c

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/checksum_collection.rb

@@ -9,6 +9,8 @@ module Nanoc
 
       def initialize(checksums)
         @checksums = checksums
+
+        @_attribute_checksums = {}
       end
 
       contract c_obj => C::Maybe[String]
@@ -23,7 +25,7 @@ module Nanoc
 
       contract c_obj => C::Maybe[C::HashOf[Symbol, String]]
       def attributes_checksum_for(obj)
-        @checksums[[obj.reference, :each_attribute]]
+        @_attribute_checksums[obj] ||= @checksums[[obj.reference, :each_attribute]]
       end
 
       def to_h

data/lib/nanoc/core/checksum_store.rb

@@ -21,6 +21,8 @@ module Nanoc
         @objects = objects
 
         @checksums = {}
+
+        invalidate_memoization
       end
 
       contract c_obj => C::Maybe[String]
@@ -50,7 +52,7 @@ module Nanoc
 
       contract c_obj => C::Maybe[C::HashOf[Symbol, String]]
       def attributes_checksum_for(obj)
-        @checksums[[obj.reference, :each_attribute]]
+        @_attribute_checksums[obj] ||= @checksums[[obj.reference, :each_attribute]]
       end
 
       protected
@@ -60,6 +62,8 @@ module Nanoc
       end
 
       def data=(new_data)
+        invalidate_memoization
+
         references = Set.new(@objects.map(&:reference))
 
         @checksums = {}
@@ -69,6 +73,12 @@ module Nanoc
           end
         end
       end
+
+      private
+
+      def invalidate_memoization
+        @_attribute_checksums = {}
+      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/dependency_props.rb

@@ -111,7 +111,7 @@ module Nanoc
       def raw_content?
         case @raw_content
         when Set
-          @raw_content.any?
+          !@raw_content.empty?
         else
           @raw_content
         end
@@ -121,7 +121,7 @@ module Nanoc
       def attributes?
         case @attributes
         when Set
-          @attributes.any?
+          !@attributes.empty?
         else
           @attributes
         end

data/lib/nanoc/core/dependency_store.rb

@@ -71,12 +71,7 @@ module Nanoc
           Nanoc::Core::Dependency.new(
             other_object,
             object,
-            Nanoc::Core::DependencyProps.new(
-              raw_content: props.fetch(:raw_content, false),
-              attributes: props.fetch(:attributes, false),
-              compiled_content: props.fetch(:compiled_content, false),
-              path: props.fetch(:path, false),
-            ),
+            props,
           )
         end
       end
@@ -192,15 +187,22 @@ module Nanoc
         refs.map { |r| ref2obj(r) }
       end
 
-      # TODO: Return not a Hash, but a DependencyProps instead
       def props_for(from, to)
         props = @graph.props_for(obj2ref(from), obj2ref(to))
-
-        if props&.active&.any?
-          props.to_h
-        else
-          { raw_content: true, attributes: true, compiled_content: true, path: true }
-        end
+        return props if props
+
+        # This is for backwards compatibility, in case there are no dependency
+        # props available yet. Pretend everything is set to `true`; it’ll be
+        # recompiled and correct props will be available in the next run.
+        #
+        # NOTE: This isn’t covered by tests, yet. (Not trivial to test because
+        # it’s not a condition that can arise in the current Nanoc version.)
+        Nanoc::Core::DependencyProps.new(
+          raw_content: true,
+          attributes: true,
+          compiled_content: true,
+          path: true,
+        )
       end
 
       def data

data/lib/nanoc/core/document.rb

@@ -49,6 +49,10 @@ module Nanoc
         @checksum_data = checksum_data
         @content_checksum_data = content_checksum_data
         @attributes_checksum_data = attributes_checksum_data
+
+        # Precalculate for performance
+        @hash = [self.class, identifier].hash
+        reference
       end
 
       # @return [Hash]
@@ -107,7 +111,7 @@ module Nanoc
 
       contract C::None => C::Num
       def hash
-        [self.class, identifier].hash
+        @hash
       end
 
       contract C::Any => C::Bool

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.rb

@@ -4,7 +4,7 @@ module Nanoc
   module Core
     class Item < ::Nanoc::Core::Document
       def reference
-        "item:#{identifier}"
+        @_reference ||= "item:#{identifier}"
       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|