nanoc-core 4.11.8 → 4.11.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eba8e5453c73cc3e17520767764cb248aaa81e3bd5a6bfebc622a0df4f6085c1
-  data.tar.gz: 3fe67279f02a1dc8e49ca35a8d31a62e9a880f7672fc30523e9225b4f750dbcd
+  metadata.gz: b0c47871b0eb4f46b025c03db997f1b12971c30ca2a0ce5d5c00a6ad346bacd5
+  data.tar.gz: 558b36a88d1e4b943154368f7e2ee820dcf8ae8606cb5bb67b45dfaf2ba7cd07
 SHA512:
-  metadata.gz: 87209d422a9a8da4ee3cbf6f99895a52b3b947d463fd84a94acf15b22de44b590256ec34f8863b3f7524d178871d2346603c8ca2835617ff05e13bdb05b1d8c0
-  data.tar.gz: b897dc708603f243c69cf613b1d2fe617e9352dd3280ade6d6390cb3f3d71c48e0df10525e387496bbe638a8c7b2cdf707f014b02b37e6e3d66430f54845ded0
+  metadata.gz: 701578c317c2879ceca2e40efc2029f2b43cde150f53bd80c65383c18d0c8f80580e130e191082968302f68d5d148fd995e04f98893e3e57f24f310eb65ef4d4
+  data.tar.gz: f8511f35512c5dc0e041482691ddd0283a9d686e101aac99336653aa5b404cfaebad74dc33487d887daadce850d946b9c33d427d3afa8dab2a7e6d6822122224

data/lib/nanoc/core/action_sequence_store.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Stores action sequences for objects that can be run through a rule (item
+    # representations and layouts).
+    #
+    # @api private
+    class ActionSequenceStore < ::Nanoc::Core::Store
+      include Nanoc::Core::ContractsSupport
+
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
+      def initialize(config:)
+        super(Nanoc::Core::Store.tmp_path_for(config: config, store_name: 'rule_memory'), 1)
+
+        @action_sequences = {}
+      end
+
+      # @param [Nanoc::Core::ItemRep, Nanoc::Core::Layout] obj The item representation or
+      #   the layout to get the action sequence for
+      #
+      # @return [Array] The action sequence for the given object
+      def [](obj)
+        @action_sequences[obj.reference]
+      end
+
+      # @param [Nanoc::Core::ItemRep, Nanoc::Core::Layout] obj The item representation or
+      #   the layout to set the action sequence for
+      #
+      # @param [Array] action_sequence The new action sequence to be stored
+      #
+      # @return [void]
+      def []=(obj, action_sequence)
+        @action_sequences[obj.reference] = action_sequence
+      end
+
+      protected
+
+      # @see Nanoc::Core::Store#data
+      def data
+        @action_sequences
+      end
+
+      # @see Nanoc::Core::Store#data=
+      def data=(new_data)
+        @action_sequences = new_data
+      end
+    end
+  end
+end

data/lib/nanoc/core/binary_compiled_content_cache.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Represents a cache than can be used to store already compiled content,
+    # to prevent it from being needlessly recompiled.
+    #
+    # @api private
+    class BinaryCompiledContentCache < ::Nanoc::Core::Store
+      include Nanoc::Core::ContractsSupport
+
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
+      def initialize(config:)
+        super(Nanoc::Core::Store.tmp_path_for(config: config, store_name: 'binary_content'), 1)
+
+        @cache = {}
+      end
+
+      contract Nanoc::Core::ItemRep => C::Maybe[C::HashOf[Symbol => Nanoc::Core::Content]]
+      # Returns the cached compiled content for the given item representation.
+      #
+      # This cached compiled content is a hash where the keys are the snapshot
+      # names, and the values the compiled content at the given snapshot.
+      def [](rep)
+        item_cache = @cache[rep.item.identifier] || {}
+
+        rep_cache = item_cache[rep.name]
+        return nil if rep_cache.nil?
+
+        rep_cache.transform_values do |filename|
+          Nanoc::Core::Content.create(filename, binary: true)
+        end
+      end
+
+      contract Nanoc::Core::ItemRep => C::Bool
+      def include?(rep)
+        item_cache = @cache[rep.item.identifier] || {}
+        item_cache.key?(rep.name)
+      end
+
+      contract Nanoc::Core::ItemRep, C::HashOf[Symbol => Nanoc::Core::BinaryContent] => C::HashOf[Symbol => Nanoc::Core::Content]
+      # Sets the compiled content for the given representation.
+      #
+      # This cached compiled content is a hash where the keys are the snapshot
+      # names, and the values the compiled content at the given snapshot.
+      def []=(rep, content)
+        @cache[rep.item.identifier] ||= {}
+        @cache[rep.item.identifier][rep.name] ||= {}
+        rep_cache = @cache[rep.item.identifier][rep.name]
+
+        content.each do |snapshot, binary_content|
+          filename = build_filename(rep, snapshot)
+          rep_cache[snapshot] = filename
+
+          # Avoid reassigning the same content if this binary cached content was
+          # already used, because it was available and the item wasn’t oudated.
+          next if binary_content.filename == filename
+
+          # Copy
+          #
+          # NOTE: hardlinking is not an option in this case, because hardlinking
+          # would make it possible for the content to be (inadvertently)
+          # changed outside of Nanoc.
+          FileUtils.mkdir_p(File.dirname(filename))
+          FileUtils.cp(binary_content.filename, filename)
+        end
+      end
+
+      def prune(items:)
+        item_identifiers = Set.new(items.map(&:identifier))
+
+        @cache.each_key do |key|
+          # TODO: remove unused item reps
+          next if item_identifiers.include?(key)
+
+          @cache.delete(key)
+          path = dirname_for_item_identifier(key)
+          FileUtils.rm_rf(path)
+        end
+      end
+
+      def data
+        @cache
+      end
+
+      def data=(new_data)
+        @cache = {}
+
+        new_data.each_pair do |item_identifier, content_per_rep|
+          @cache[item_identifier] ||= content_per_rep
+        end
+      end
+
+      private
+
+      def dirname
+        filename + '_data'
+      end
+
+      def string_to_path_component(string)
+        string.gsub(/[^a-zA-Z0-9]+/, '_') +
+          '-' +
+          Digest::SHA1.hexdigest(string)[0..9]
+      end
+
+      def dirname_for_item_identifier(item_identifier)
+        File.join(
+          dirname,
+          string_to_path_component(item_identifier.to_s),
+        )
+      end
+
+      def dirname_for_item_rep(rep)
+        File.join(
+          dirname_for_item_identifier(rep.item.identifier),
+          string_to_path_component(rep.name.to_s),
+        )
+      end
+
+      def build_filename(rep, snapshot_name)
+        File.join(
+          dirname_for_item_rep(rep),
+          string_to_path_component(snapshot_name.to_s),
+        )
+      end
+    end
+  end
+end

data/lib/nanoc/core/checksum_store.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Stores checksums for objects in order to be able to detect whether a file
+    # has changed since the last site compilation.
+    #
+    # @api private
+    class ChecksumStore < ::Nanoc::Core::Store
+      include Nanoc::Core::ContractsSupport
+
+      attr_writer :checksums
+      attr_accessor :objects
+
+      c_obj = C::Or[Nanoc::Core::Item, Nanoc::Core::Layout, Nanoc::Core::Configuration, Nanoc::Core::CodeSnippet]
+
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration, objects: C::IterOf[c_obj]] => C::Any
+      def initialize(config:, objects:)
+        super(Nanoc::Core::Store.tmp_path_for(config: config, store_name: 'checksums'), 2)
+
+        @objects = objects
+
+        @checksums = {}
+      end
+
+      contract c_obj => C::Maybe[String]
+      def [](obj)
+        @checksums[obj.reference]
+      end
+
+      contract c_obj => self
+      def add(obj)
+        if obj.is_a?(Nanoc::Core::Document)
+          @checksums[[obj.reference, :content]] = Nanoc::Core::Checksummer.calc_for_content_of(obj)
+        end
+
+        if obj.is_a?(Nanoc::Core::Document) || obj.is_a?(Nanoc::Core::Configuration)
+          @checksums[[obj.reference, :each_attribute]] = Nanoc::Core::Checksummer.calc_for_each_attribute_of(obj)
+        end
+
+        @checksums[obj.reference] = Nanoc::Core::Checksummer.calc(obj)
+
+        self
+      end
+
+      contract c_obj => C::Maybe[String]
+      def content_checksum_for(obj)
+        @checksums[[obj.reference, :content]]
+      end
+
+      contract c_obj => C::Maybe[C::HashOf[Symbol, String]]
+      def attributes_checksum_for(obj)
+        @checksums[[obj.reference, :each_attribute]]
+      end
+
+      protected
+
+      def data
+        @checksums
+      end
+
+      def data=(new_data)
+        references = Set.new(@objects.map(&:reference))
+
+        @checksums = {}
+        new_data.each_pair do |key, checksum|
+          if references.include?(key) || references.include?(key.first)
+            @checksums[key] = checksum
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/compiled_content_cache.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Represents a cache than can be used to store already compiled content,
+    # to prevent it from being needlessly recompiled.
+    #
+    # @api private
+    class CompiledContentCache < ::Nanoc::Core::Store
+      include Nanoc::Core::ContractsSupport
+
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
+      def initialize(config:)
+        @textual_cache = Nanoc::Core::TextualCompiledContentCache.new(config: config)
+        @binary_cache = Nanoc::Core::BinaryCompiledContentCache.new(config: config)
+
+        @wrapped_caches = [@textual_cache, @binary_cache]
+      end
+
+      contract Nanoc::Core::ItemRep => C::Maybe[C::HashOf[Symbol => Nanoc::Core::Content]]
+      # Returns the cached compiled content for the given item representation.
+      #
+      # This cached compiled content is a hash where the keys are the snapshot
+      # names. and the values the compiled content at the given snapshot.
+      def [](rep)
+        textual_content_map = @textual_cache[rep]
+        binary_content_map = @binary_cache[rep]
+
+        # If either the textual or the binary content cache is nil, assume the
+        # cache is entirely absent.
+        #
+        # This is necessary to support the case where only textual content is
+        # cached (which was the case in older versions of Nanoc).
+        return nil if [textual_content_map, binary_content_map].any?(&:nil?)
+
+        textual_content_map.merge(binary_content_map)
+      end
+
+      contract Nanoc::Core::ItemRep, C::HashOf[Symbol => Nanoc::Core::Content] => C::Any
+      # Sets the compiled content for the given representation.
+      #
+      # This cached compiled content is a hash where the keys are the snapshot
+      # names and the values the compiled content at the given snapshot.
+      def []=(rep, content)
+        @textual_cache[rep] = content.select { |_key, c| c.textual? }
+        @binary_cache[rep] = content.select { |_key, c| c.binary? }
+      end
+
+      def prune(*args)
+        @wrapped_caches.each { |w| w.prune(*args) }
+      end
+
+      # True if there is cached compiled content available for this item, and
+      # all entries are present (either textual or binary).
+      def full_cache_available?(rep)
+        @textual_cache.include?(rep) && @binary_cache.include?(rep)
+      end
+
+      def load(*args)
+        @wrapped_caches.each { |w| w.load(*args) }
+      end
+
+      def store(*args)
+        @wrapped_caches.each { |w| w.store(*args) }
+      end
+    end
+  end
+end

data/lib/nanoc/core/compiled_content_store.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # @api private
+    class CompiledContentStore
+      include Nanoc::Core::ContractsSupport
+
+      def initialize
+        @contents = Hash.new { |hash, rep| hash[rep] = {} }
+        @current_content = {}
+      end
+
+      contract Nanoc::Core::ItemRep, Symbol => C::Maybe[Nanoc::Core::Content]
+      def get(rep, snapshot_name)
+        @contents[rep][snapshot_name]
+      end
+
+      contract Nanoc::Core::ItemRep => C::Maybe[Nanoc::Core::Content]
+      def get_current(rep)
+        @current_content[rep]
+      end
+
+      contract Nanoc::Core::ItemRep, Symbol, Nanoc::Core::Content => C::Any
+      def set(rep, snapshot_name, contents)
+        @contents[rep][snapshot_name] = contents
+      end
+
+      contract Nanoc::Core::ItemRep, Nanoc::Core::Content => C::Any
+      def set_current(rep, content)
+        @current_content[rep] = content
+      end
+
+      contract Nanoc::Core::ItemRep => C::HashOf[Symbol => Nanoc::Core::Content]
+      def get_all(rep)
+        @contents[rep]
+      end
+
+      contract Nanoc::Core::ItemRep, C::HashOf[Symbol => Nanoc::Core::Content] => C::Any
+      def set_all(rep, contents_per_snapshot)
+        @contents[rep] = contents_per_snapshot
+      end
+
+      contract C::KeywordArgs[rep: Nanoc::Core::ItemRep, snapshot: C::Optional[C::Maybe[Symbol]]] => Nanoc::Core::Content
+      def raw_compiled_content(rep:, snapshot: nil)
+        # Get name of last pre-layout snapshot
+        has_pre = rep.snapshot_defs.any? { |sd| sd.name == :pre }
+        snapshot_name = snapshot || (has_pre ? :pre : :last)
+
+        # Check existance of snapshot
+        snapshot_def = rep.snapshot_defs.reverse.find { |sd| sd.name == snapshot_name }
+        unless snapshot_def
+          raise Nanoc::Core::Errors::NoSuchSnapshot.new(rep, snapshot_name)
+        end
+
+        # Return content if it is available
+        content = get(rep, snapshot_name)
+        return content if content
+
+        # Content is unavailable; notify and try again
+        Fiber.yield(Nanoc::Core::Errors::UnmetDependency.new(rep, snapshot_name))
+        get(rep, snapshot_name)
+      end
+
+      contract C::KeywordArgs[rep: Nanoc::Core::ItemRep, snapshot: C::Optional[C::Maybe[Symbol]]] => String
+      def compiled_content(rep:, snapshot: nil)
+        snapshot_content = raw_compiled_content(rep: rep, snapshot: snapshot)
+
+        if snapshot_content.binary?
+          raise Nanoc::Core::Errors::CannotGetCompiledContentOfBinaryItem.new(rep)
+        end
+
+        snapshot_content.string
+      end
+    end
+  end
+end

data/lib/nanoc/core/configuration-schema.json

@@ -78,6 +78,18 @@
     "checks": {
       "type": "object",
       "properties": {
+        "all": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "exclude_files": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          }
+        },
         "internal_links": {
           "type": "object",
           "additionalProperties": false,

data/lib/nanoc/core/dependency_store.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # @api private
+    class DependencyStore < ::Nanoc::Core::Store
+      include Nanoc::Core::ContractsSupport
+
+      C_ATTR = C::Or[C::IterOf[Symbol], C::Bool]
+      C_RAW_CONTENT = C::Or[C::IterOf[C::Or[String, Regexp]], C::Bool]
+      C_KEYWORD_PROPS = C::KeywordArgs[raw_content: C::Optional[C_RAW_CONTENT], attributes: C::Optional[C_ATTR], compiled_content: C::Optional[C::Bool], path: C::Optional[C::Bool]]
+      C_OBJ_SRC = Nanoc::Core::Item
+      C_OBJ_DST = C::Or[Nanoc::Core::Item, Nanoc::Core::Layout, Nanoc::Core::Configuration, Nanoc::Core::IdentifiableCollection]
+
+      attr_reader :items
+      attr_reader :layouts
+
+      contract Nanoc::Core::ItemCollection, Nanoc::Core::LayoutCollection, Nanoc::Core::Configuration => C::Any
+      def initialize(items, layouts, config)
+        super(Nanoc::Core::Store.tmp_path_for(config: config, store_name: 'dependencies'), 5)
+
+        @items = items
+        @layouts = layouts
+
+        @refs2objs = {}
+        items.each   { |o| add_vertex_for(o) }
+        layouts.each { |o| add_vertex_for(o) }
+        add_vertex_for(config)
+        add_vertex_for(items)
+        add_vertex_for(layouts)
+
+        @new_objects = []
+        @graph = Nanoc::Core::DirectedGraph.new([nil] + objs2refs(@items) + objs2refs(@layouts))
+      end
+
+      contract C_OBJ_SRC => C::ArrayOf[Nanoc::Core::Dependency]
+      def dependencies_causing_outdatedness_of(object)
+        objects_causing_outdatedness_of(object).map do |other_object|
+          props = props_for(other_object, object)
+
+          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),
+            ),
+          )
+        end
+      end
+
+      def items=(items)
+        @items = items
+        items.each { |o| @refs2objs[obj2ref(o)] = o }
+        add_vertex_for(items)
+      end
+
+      def layouts=(layouts)
+        @layouts = layouts
+        layouts.each { |o| @refs2objs[obj2ref(o)] = o }
+        add_vertex_for(layouts)
+      end
+
+      def new_items
+        @new_objects.select { |o| o.is_a?(Nanoc::Core::Item) }
+      end
+
+      def new_layouts
+        @new_objects.select { |o| o.is_a?(Nanoc::Core::Layout) }
+      end
+
+      # Returns the direct dependencies for the given object.
+      #
+      # The direct dependencies of the given object include the items and
+      # layouts that, when outdated will cause the given object to be marked as
+      # outdated. Indirect dependencies will not be returned (e.g. if A depends
+      # on B which depends on C, then the direct dependencies of A do not
+      # include C).
+      #
+      # The direct predecessors can include nil, which indicates an item that is
+      # no longer present in the site.
+      #
+      # @param [Nanoc::Core::Item, Nanoc::Core::Layout] object The object for
+      #   which to fetch the direct predecessors
+      #
+      # @return [Array<Nanoc::Core::Item, Nanoc::Core::Layout, nil>] The direct
+      # predecessors of
+      #   the given object
+      def objects_causing_outdatedness_of(object)
+        refs2objs(@graph.direct_predecessors_of(obj2ref(object)))
+      end
+
+      contract C::Maybe[C_OBJ_SRC], C::Maybe[C_OBJ_DST], C_KEYWORD_PROPS => C::Any
+      # Records a dependency from `src` to `dst` in the dependency graph. When
+      # `dst` is oudated, `src` will also become outdated.
+      #
+      # @param [Nanoc::Core::Item, Nanoc::Core::Layout] src The source of the dependency,
+      #   i.e. the object that will become outdated if dst is outdated
+      #
+      # @param [Nanoc::Core::Item, Nanoc::Core::Layout] dst The destination of the
+      #   dependency, i.e. the object that will cause the source to become
+      #   outdated if the destination is outdated
+      #
+      # @return [void]
+      def record_dependency(src, dst, raw_content: false, attributes: false, compiled_content: false, path: false)
+        return if src == dst
+
+        add_vertex_for(src)
+        add_vertex_for(dst)
+
+        src_ref = obj2ref(src)
+        dst_ref = obj2ref(dst)
+
+        existing_props = Nanoc::Core::DependencyProps.new(@graph.props_for(dst_ref, src_ref) || {})
+        new_props = Nanoc::Core::DependencyProps.new(raw_content: raw_content, attributes: attributes, compiled_content: compiled_content, path: path)
+        props = existing_props.merge(new_props)
+
+        @graph.add_edge(dst_ref, src_ref, props: props.to_h)
+      end
+
+      def add_vertex_for(obj)
+        @refs2objs[obj2ref(obj)] = obj
+      end
+
+      # Empties the list of dependencies for the given object. This is necessary
+      # before recompiling the given object, because otherwise old dependencies
+      # will stick around and new dependencies will appear twice. This function
+      # removes all incoming edges for the given vertex.
+      #
+      # @param [Nanoc::Core::Item, Nanoc::Core::Layout] object The object for which to
+      #   forget all dependencies
+      #
+      # @return [void]
+      def forget_dependencies_for(object)
+        @graph.delete_edges_to(obj2ref(object))
+      end
+
+      protected
+
+      def obj2ref(obj)
+        obj&.reference
+      end
+
+      def ref2obj(reference)
+        if reference
+          @refs2objs[reference]
+        else
+          nil
+        end
+      end
+
+      def objs2refs(objs)
+        objs.map { |o| obj2ref(o) }
+      end
+
+      def refs2objs(refs)
+        refs.map { |r| ref2obj(r) }
+      end
+
+      def props_for(from, to)
+        props = @graph.props_for(obj2ref(from), obj2ref(to)) || {}
+
+        if props.values.any? { |v| v }
+          props
+        else
+          { raw_content: true, attributes: true, compiled_content: true, path: true }
+        end
+      end
+
+      def data
+        {
+          edges: @graph.edges,
+          vertices: @graph.vertices,
+        }
+      end
+
+      def data=(new_data)
+        objects = Set.new(@items.to_a + @layouts.to_a)
+        refs = objs2refs(objects)
+
+        # Create new graph
+        @graph = Nanoc::Core::DirectedGraph.new([nil] + refs)
+
+        # Load vertices
+        previous_refs = new_data[:vertices]
+        previous_objects = Set.new(refs2objs(previous_refs))
+
+        # Load edges
+        new_data[:edges].each do |edge|
+          from_index, to_index, props = *edge
+          from = from_index && previous_refs[from_index]
+          to   = to_index && previous_refs[to_index]
+          @graph.add_edge(from, to, props: props)
+        end
+
+        # Record dependency from all items on new items
+        @new_objects = objects - previous_objects
+      end
+    end
+  end
+end

data/lib/nanoc/core/dependency_tracker.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # @api private
+    class DependencyTracker
+      include Nanoc::Core::ContractsSupport
+
+      C_OBJ = C::Or[Nanoc::Core::Item, Nanoc::Core::Layout, Nanoc::Core::Configuration, Nanoc::Core::IdentifiableCollection]
+      C_RAW_CONTENT = C::Or[C::IterOf[C::Or[String, Regexp]], C::Bool]
+      C_ATTR = C::Or[C::IterOf[Symbol], C::Bool]
+      C_ARGS = C::KeywordArgs[raw_content: C::Optional[C_RAW_CONTENT], attributes: C::Optional[C_ATTR], compiled_content: C::Optional[C::Bool], path: C::Optional[C::Bool]]
+
+      class Null
+        include Nanoc::Core::ContractsSupport
+
+        contract C_OBJ, C_ARGS => C::Any
+        def enter(_obj, raw_content: false, attributes: false, compiled_content: false, path: false); end
+
+        contract C_OBJ => C::Any
+        def exit; end
+
+        contract C_OBJ, C_ARGS => C::Any
+        def bounce(_obj, raw_content: false, attributes: false, compiled_content: false, path: false); end
+      end
+
+      attr_reader :dependency_store
+
+      def initialize(dependency_store)
+        @dependency_store = dependency_store
+        @stack = []
+      end
+
+      contract C_OBJ, C_ARGS => C::Any
+      def enter(obj, raw_content: false, attributes: false, compiled_content: false, path: false)
+        unless @stack.empty?
+          Nanoc::Core::NotificationCenter.post(:dependency_created, @stack.last, obj)
+          @dependency_store.record_dependency(
+            @stack.last,
+            obj,
+            raw_content: raw_content,
+            attributes: attributes,
+            compiled_content: compiled_content,
+            path: path,
+          )
+        end
+
+        @stack.push(obj)
+      end
+
+      contract C_OBJ => C::Any
+      def exit
+        @stack.pop
+      end
+
+      contract C_OBJ, C_ARGS => C::Any
+      def bounce(obj, raw_content: false, attributes: false, compiled_content: false, path: false)
+        enter(obj, raw_content: raw_content, attributes: attributes, compiled_content: compiled_content, path: path)
+        exit
+      end
+    end
+  end
+end

data/lib/nanoc/core/errors.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    module Errors
+      # Error that is raised when the compiled content at a non-existing snapshot
+      # is requested.
+      class NoSuchSnapshot < ::Nanoc::Core::Error
+        # @return [Nanoc::Core::ItemRep] The item rep from which the compiled content
+        #   was requested
+        attr_reader :item_rep
+
+        # @return [Symbol] The requested snapshot
+        attr_reader :snapshot
+
+        # @param [Nanoc::Core::ItemRep] item_rep The item rep from which the compiled
+        #   content was requested
+        #
+        # @param [Symbol] snapshot The requested snapshot
+        def initialize(item_rep, snapshot)
+          @item_rep = item_rep
+          @snapshot = snapshot
+          super("The “#{item_rep.inspect}” item rep does not have a snapshot “#{snapshot.inspect}”")
+        end
+      end
+
+      # Error that is raised when an rep cannot be compiled because it depends
+      # on other representations.
+      class UnmetDependency < ::Nanoc::Core::Error
+        # @return [Nanoc::Core::ItemRep] The item representation that cannot yet be
+        #   compiled
+        attr_reader :rep
+
+        # @return [Symbol] The name of the snapshot that cannot yet be compiled
+        attr_reader :snapshot_name
+
+        # @param [Nanoc::Core::ItemRep] rep The item representation that cannot yet be
+        #   compiled
+        def initialize(rep, snapshot_name)
+          @rep = rep
+          @snapshot_name = snapshot_name
+
+          super("The current item cannot be compiled yet because of an unmet dependency on the “#{rep.item.identifier}” item (rep “#{rep.name}”, snapshot “#{snapshot_name}”).")
+        end
+      end
+
+      # Error that is raised when the compiled content of a binary item is attempted to be accessed.
+      class CannotGetCompiledContentOfBinaryItem < ::Nanoc::Core::Error
+        # @param [Nanoc::Core::ItemRep] rep The binary item representation whose compiled content was attempted to be accessed
+        def initialize(rep)
+          super("You cannot access the compiled content of a binary item representation (but you can access the path). The offending item rep is #{rep}.")
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/item_rep_repo.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Stores item reps (in memory).
+    #
+    # @api private
+    class ItemRepRepo
+      include Enumerable
+
+      def initialize
+        @reps = []
+        @reps_by_item = {}
+      end
+
+      def <<(rep)
+        @reps << rep
+
+        @reps_by_item[rep.item] ||= []
+        @reps_by_item[rep.item] << rep
+      end
+
+      def to_a
+        @reps
+      end
+
+      def each(&block)
+        @reps.each(&block)
+        self
+      end
+
+      def [](item)
+        @reps_by_item.fetch(item, [])
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_reasons.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Module that contains all outdatedness reasons.
+    #
+    # @api private
+    module OutdatednessReasons
+      # A generic outdatedness reason. An outdatedness reason is basically a
+      # descriptive message that explains why a given object is outdated.
+      class Generic
+        # @return [String] A descriptive message for this outdatedness reason
+        attr_reader :message
+
+        # @return [Nanoc::Core::DependencyProps]
+        attr_reader :props
+
+        # @param [String] message The descriptive message for this outdatedness
+        #   reason
+        def initialize(message, props = Nanoc::Core::DependencyProps.new)
+          @message = message
+          @props = props
+        end
+      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),
+      )
+
+      DependenciesOutdated = Generic.new(
+        '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),
+      )
+
+      RulesModified = Generic.new(
+        'The rules file has been modified since the last time the site was compiled.',
+        Nanoc::Core::DependencyProps.new(compiled_content: true, path: true),
+      )
+
+      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),
+      )
+
+      class DocumentCollectionExtended < Generic
+        attr_reader :objects
+
+        def initialize(objects)
+          super(
+            'New items/layouts have been added to the site.',
+            Nanoc::Core::DependencyProps.new(raw_content: true),
+          )
+
+          @objects = objects
+        end
+      end
+
+      class ItemCollectionExtended < DocumentCollectionExtended
+      end
+
+      class LayoutCollectionExtended < DocumentCollectionExtended
+      end
+
+      class AttributesModified < Generic
+        attr_reader :attributes
+
+        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),
+          )
+
+          @attributes = attributes
+        end
+      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),
+      )
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_rule.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # @api private
+    class OutdatednessRule
+      include Nanoc::Core::ContractsSupport
+      include Singleton
+
+      def call(obj, outdatedness_checker)
+        Nanoc::Core::Instrumentor.call(:outdatedness_rule_ran, self.class) do
+          apply(obj, outdatedness_checker)
+        end
+      end
+
+      def apply(_obj, _outdatedness_checker)
+        raise NotImplementedError.new('Nanoc::Core::OutdatednessRule subclasses must implement #apply')
+      end
+
+      contract C::None => String
+      def inspect
+        "#{self.class.name}(#{reason})"
+      end
+
+      def self.affects_props(*names)
+        @affected_props = Set.new(names)
+      end
+
+      def self.affected_props
+        @affected_props
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_status.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # @api private
+    class OutdatednessStatus
+      attr_reader :reasons
+      attr_reader :props
+
+      def initialize(reasons: [], props: Nanoc::Core::DependencyProps.new)
+        @reasons = reasons
+        @props = props
+      end
+
+      def useful_to_apply?(rule)
+        (rule.affected_props - @props.active).any?
+      end
+
+      def update(reason)
+        self.class.new(
+          reasons: @reasons + [reason],
+          props: @props.merge(reason.props),
+        )
+      end
+    end
+  end
+end

data/lib/nanoc/core/outdatedness_store.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # @api private
+    class OutdatednessStore < ::Nanoc::Core::Store
+      include Nanoc::Core::ContractsSupport
+
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
+      def initialize(config:)
+        super(Nanoc::Core::Store.tmp_path_for(config: config, store_name: 'outdatedness'), 1)
+
+        @outdated_refs = Set.new
+      end
+
+      contract Nanoc::Core::ItemRep => C::Bool
+      def include?(obj)
+        @outdated_refs.include?(obj.reference)
+      end
+
+      contract Nanoc::Core::ItemRep => self
+      def add(obj)
+        @outdated_refs << obj.reference
+        self
+      end
+
+      contract Nanoc::Core::ItemRep => self
+      def remove(obj)
+        @outdated_refs.delete(obj.reference)
+        self
+      end
+
+      contract C::None => C::Bool
+      def empty?
+        @outdated_refs.empty?
+      end
+
+      contract C::None => self
+      def clear
+        @outdated_refs = Set.new
+        self
+      end
+
+      protected
+
+      def data
+        @outdated_refs
+      end
+
+      def data=(new_data)
+        @outdated_refs = Set.new(new_data)
+      end
+    end
+  end
+end

data/lib/nanoc/core/prefixed_data_source.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class PrefixedDataSource < Nanoc::Core::DataSource
+      def initialize(data_source, items_prefix, layouts_prefix)
+        super({}, '/', '/', {})
+
+        @data_source = data_source
+        @items_prefix = items_prefix
+        @layouts_prefix = layouts_prefix
+      end
+
+      def items
+        @data_source.items.map { |d| d.with_identifier_prefix(@items_prefix) }
+      end
+
+      def layouts
+        @data_source.layouts.map { |d| d.with_identifier_prefix(@layouts_prefix) }
+      end
+
+      def item_changes
+        @data_source.item_changes
+      end
+
+      def layout_changes
+        @data_source.layout_changes
+      end
+    end
+  end
+end

data/lib/nanoc/core/store.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # An abstract superclass for classes that need to store data to the
+    # filesystem, such as checksums, cached compiled content and dependency
+    # 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}.
+    #
+    # @api private
+    class Store
+      include Nanoc::Core::ContractsSupport
+
+      # @return [String] The name of the file where data will be loaded from and
+      #   stored to.
+      attr_reader :filename
+
+      # @return [Numeric] The version number corresponding to the file format
+      #   the data is in. When the file format changes, the version number
+      #   should be incremented.
+      attr_reader :version
+
+      # Creates a new store for the given filename.
+      #
+      # @param [String] filename The name of the file where data will be loaded
+      #   from and stored to.
+      #
+      # @param [Numeric] version The version number corresponding to the file
+      #   format the data is in. When the file format changes, the version
+      #   number should be incremented.
+      def initialize(filename, version)
+        @filename = filename
+        @version  = version
+      end
+
+      # Logic for building tmp path from active environment and store name
+      # @api private
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration, store_name: String] => C::AbsolutePathString
+      def self.tmp_path_for(store_name:, config:)
+        File.absolute_path(
+          File.join(tmp_path_prefix(config.output_dir), store_name),
+          config.dir,
+        )
+      end
+
+      def self.tmp_path_prefix(output_dir)
+        dir = Digest::SHA1.hexdigest(output_dir)[0..12]
+        File.join('tmp', 'nanoc', dir)
+      end
+
+      # @group Loading and storing data
+
+      # @return The data that should be written to the disk
+      #
+      # @abstract This method must be implemented by the subclass.
+      def data
+        raise NotImplementedError.new('Nanoc::Core::Store subclasses must implement #data and #data=')
+      end
+
+      # @param new_data The data that has been loaded from the disk
+      #
+      # @abstract This method must be implemented by the subclass.
+      #
+      # @return [void]
+      def data=(new_data) # rubocop:disable Lint/UnusedMethodArgument
+        raise NotImplementedError.new('Nanoc::Core::Store subclasses must implement #data and #data=')
+      end
+
+      # Loads the data from the filesystem into memory. This method will set the
+      #   loaded data using the {#data=} method.
+      #
+      # @return [void]
+      def load
+        return unless File.file?(filename)
+
+        begin
+          pstore.transaction do
+            return if pstore[:version] != version
+
+            self.data = pstore[:data]
+          end
+        rescue
+          FileUtils.rm_f(filename)
+          load
+        end
+      end
+
+      # Stores the data contained in memory to the filesystem. This method will
+      #   use the {#data} method to fetch the data that should be written.
+      #
+      # @return [void]
+      def store
+        FileUtils.mkdir_p(File.dirname(filename))
+
+        pstore.transaction do
+          pstore[:data]    = data
+          pstore[:version] = version
+        end
+      end
+
+      private
+
+      def pstore
+        @pstore ||= PStore.new(filename)
+      end
+    end
+  end
+end

data/lib/nanoc/core/textual_compiled_content_cache.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Represents a cache than can be used to store already compiled content,
+    # to prevent it from being needlessly recompiled.
+    #
+    # @api private
+    class TextualCompiledContentCache < ::Nanoc::Core::Store
+      include Nanoc::Core::ContractsSupport
+
+      contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
+      def initialize(config:)
+        super(Nanoc::Core::Store.tmp_path_for(config: config, store_name: 'compiled_content'), 2)
+
+        @cache = {}
+      end
+
+      contract Nanoc::Core::ItemRep => C::Maybe[C::HashOf[Symbol => Nanoc::Core::Content]]
+      # Returns the cached compiled content for the given item representation.
+      #
+      # This cached compiled content is a hash where the keys are the snapshot
+      # names, and the values the compiled content at the given snapshot.
+      def [](rep)
+        item_cache = @cache[rep.item.identifier] || {}
+        item_cache[rep.name]
+      end
+
+      contract Nanoc::Core::ItemRep => C::Bool
+      def include?(rep)
+        item_cache = @cache[rep.item.identifier] || {}
+        item_cache.key?(rep.name)
+      end
+
+      contract Nanoc::Core::ItemRep, C::HashOf[Symbol => Nanoc::Core::Content] => C::Any
+      # Sets the compiled content for the given representation.
+      #
+      # This cached compiled content is a hash where the keys are the snapshot
+      # names, and the values the compiled content at the given snapshot.
+      def []=(rep, content)
+        # FIXME: once the binary content cache is properly enabled (no longer
+        # behind a feature flag), change contract to be TextualContent, rather
+        # than Content.
+
+        @cache[rep.item.identifier] ||= {}
+        @cache[rep.item.identifier][rep.name] = content
+      end
+
+      def prune(items:)
+        item_identifiers = Set.new(items.map(&:identifier))
+
+        @cache.each_key do |key|
+          # TODO: remove unused item reps
+          next if item_identifiers.include?(key)
+
+          @cache.delete(key)
+        end
+      end
+
+      # True if there is cached compiled content available for this item, and
+      # all entries are textual.
+      def full_cache_available?(rep)
+        cache = self[rep]
+        cache ? cache.none? { |_snapshot_name, content| content.binary? } : false
+      end
+
+      protected
+
+      def data
+        @cache
+      end
+
+      def data=(new_data)
+        @cache = {}
+
+        new_data.each_pair do |item_identifier, content_per_rep|
+          @cache[item_identifier] ||= content_per_rep
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/core/version.rb

@@ -2,6 +2,6 @@
 
 module Nanoc
   module Core
-    VERSION = '4.11.8'
+    VERSION = '4.11.9'
   end
 end

data/lib/nanoc/core.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # Ruby stdlib
+require 'pstore'
 require 'singleton'
 require 'tmpdir'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nanoc-core
 version: !ruby/object:Gem::Version
-  version: 4.11.8
+  version: 4.11.9
 platform: ruby
 authors:
 - Denis Defreyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-08 00:00:00.000000000 Z
+date: 2019-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ddmemoize
@@ -121,11 +121,16 @@ files:
 - lib/nanoc/core/action_provider.rb
 - lib/nanoc/core/action_sequence.rb
 - lib/nanoc/core/action_sequence_builder.rb
+- lib/nanoc/core/action_sequence_store.rb
 - lib/nanoc/core/aggregate_data_source.rb
+- lib/nanoc/core/binary_compiled_content_cache.rb
 - lib/nanoc/core/binary_content.rb
 - lib/nanoc/core/checksum_collection.rb
+- lib/nanoc/core/checksum_store.rb
 - lib/nanoc/core/checksummer.rb
 - lib/nanoc/core/code_snippet.rb
+- lib/nanoc/core/compiled_content_cache.rb
+- lib/nanoc/core/compiled_content_store.rb
 - lib/nanoc/core/configuration-schema.json
 - lib/nanoc/core/configuration.rb
 - lib/nanoc/core/content.rb
@@ -137,9 +142,12 @@ files:
 - lib/nanoc/core/data_source.rb
 - lib/nanoc/core/dependency.rb
 - lib/nanoc/core/dependency_props.rb
+- lib/nanoc/core/dependency_store.rb
+- lib/nanoc/core/dependency_tracker.rb
 - lib/nanoc/core/directed_graph.rb
 - lib/nanoc/core/document.rb
 - lib/nanoc/core/error.rb
+- lib/nanoc/core/errors.rb
 - lib/nanoc/core/identifiable_collection.rb
 - lib/nanoc/core/identifier.rb
 - lib/nanoc/core/in_memory_data_source.rb
@@ -147,11 +155,17 @@ files:
 - lib/nanoc/core/item.rb
 - lib/nanoc/core/item_collection.rb
 - lib/nanoc/core/item_rep.rb
+- lib/nanoc/core/item_rep_repo.rb
 - lib/nanoc/core/layout.rb
 - lib/nanoc/core/layout_collection.rb
 - lib/nanoc/core/lazy_value.rb
 - lib/nanoc/core/notification_center.rb
+- lib/nanoc/core/outdatedness_reasons.rb
+- lib/nanoc/core/outdatedness_rule.rb
+- lib/nanoc/core/outdatedness_status.rb
+- lib/nanoc/core/outdatedness_store.rb
 - lib/nanoc/core/pattern.rb
+- lib/nanoc/core/prefixed_data_source.rb
 - lib/nanoc/core/processing_action.rb
 - lib/nanoc/core/processing_actions.rb
 - lib/nanoc/core/processing_actions/filter.rb
@@ -160,8 +174,10 @@ files:
 - lib/nanoc/core/regexp_pattern.rb
 - lib/nanoc/core/site.rb
 - lib/nanoc/core/snapshot_def.rb
+- lib/nanoc/core/store.rb
 - lib/nanoc/core/string_pattern.rb
 - lib/nanoc/core/temp_filename_factory.rb
+- lib/nanoc/core/textual_compiled_content_cache.rb
 - lib/nanoc/core/textual_content.rb
 - lib/nanoc/core/version.rb
 homepage: https://nanoc.ws/
@@ -183,7 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Core of Nanoc