nanoc 4.11.8 → 4.11.9

data/lib/nanoc/base/repos/binary_compiled_content_cache.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # Represents a cache than can be used to store already compiled content,
-    # to prevent it from being needlessly recompiled.
-    #
-    # @api private
-    class BinaryCompiledContentCache < ::Nanoc::Int::Store
-      include Nanoc::Core::ContractsSupport
-
-      contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
-      def initialize(config:)
-        super(Nanoc::Int::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/base/repos/checksum_store.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # 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::Int::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::Int::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/base/repos/compiled_content_cache.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # Represents a cache than can be used to store already compiled content,
-    # to prevent it from being needlessly recompiled.
-    #
-    # @api private
-    class CompiledContentCache < ::Nanoc::Int::Store
-      include Nanoc::Core::ContractsSupport
-
-      contract C::KeywordArgs[config: Nanoc::Core::Configuration] => C::Any
-      def initialize(config:)
-        @textual_cache = Nanoc::Int::TextualCompiledContentCache.new(config: config)
-        @binary_cache = Nanoc::Int::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/base/repos/compiled_content_store.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # @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::Int::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::Int::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::Int::Errors::CannotGetCompiledContentOfBinaryItem.new(rep)
-        end
-
-        snapshot_content.string
-      end
-    end
-  end
-end

data/lib/nanoc/base/repos/dependency_store.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # @api private
-    class DependencyStore < ::Nanoc::Int::Store
-      include Nanoc::Core::ContractsSupport
-
-      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::Int::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
-
-      C_OBJ_SRC = Nanoc::Core::Item
-      C_OBJ_DST = C::Or[Nanoc::Core::Item, Nanoc::Core::Layout, Nanoc::Core::Configuration, Nanoc::Core::IdentifiableCollection]
-
-      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
-
-      C_RAW_CONTENT = C::Or[C::IterOf[C::Or[String, Regexp]], C::Bool]
-      C_ATTR = C::Or[C::IterOf[Symbol], 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]]
-
-      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