nanoc-core 4.11.1

data/lib/nanoc/core/directed_graph.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Represents a directed graph. It is used by the dependency tracker for
+    # storing and querying dependencies between items.
+    #
+    # @example Creating and using a directed graph
+    #
+    #   # Create a graph with three vertices
+    #   graph = Nanoc::Core::DirectedGraph.new(%w( a b c d e f g ))
+    #
+    #   # Add edges
+    #   graph.add_edge('a', 'b')
+    #   graph.add_edge('b', 'c')
+    #   graph.add_edge('b', 'f')
+    #   graph.add_edge('b', 'g')
+    #   graph.add_edge('c', 'd')
+    #   graph.add_edge('d', 'e')
+    #
+    #   # Get (direct) predecessors
+    #   graph.direct_predecessors_of('b').sort
+    #     # => %w( a )
+    #   graph.predecessors_of('e').sort
+    #     # => %w( a b c d )
+    #
+    #   # Modify edges
+    #   graph.delete_edges_to('c')
+    #
+    #   # Get (direct) predecessors again
+    #   graph.direct_predecessors_of('e').sort
+    #     # => %w( d )
+    #   graph.predecessors_of('e').sort
+    #     # => %w( c d )
+    class DirectedGraph
+      # @group Creating a graph
+
+      # Creates a new directed graph with the given vertices.
+      def initialize(vertices)
+        @vertices = {}
+        @next_vertex_idx = 0
+        vertices.each do |v|
+          @vertices[v] = @next_vertex_idx.tap { @next_vertex_idx += 1 }
+        end
+
+        @to_graph   = {}
+
+        @edge_props = {}
+
+        invalidate_caches
+      end
+
+      def inspect
+        s = []
+
+        @vertices.each_pair do |v2, _|
+          direct_predecessors_of(v2).each do |v1|
+            s << [v1.inspect + ' -> ' + v2.inspect + ' props=' + @edge_props[[v1, v2]].inspect]
+          end
+        end
+
+        self.class.to_s + '(' + s.join(', ') + ')'
+      end
+
+      # @group Modifying the graph
+
+      # Adds an edge from the first vertex to the second vertex.
+      #
+      # @param from Vertex where the edge should start
+      #
+      # @param to   Vertex where the edge should end
+      #
+      # @return [void]
+      def add_edge(from, to, props: nil)
+        add_vertex(from)
+        add_vertex(to)
+
+        @to_graph[to] ||= Set.new
+        @to_graph[to] << from
+
+        if props
+          @edge_props[[from, to]] = props
+        end
+
+        invalidate_caches
+      end
+
+      # Adds the given vertex to the graph.
+      #
+      # @param vertex The vertex to add to the graph
+      #
+      # @return [void]
+      def add_vertex(vertex)
+        return if @vertices.key?(vertex)
+
+        @vertices[vertex] = @next_vertex_idx.tap { @next_vertex_idx += 1 }
+      end
+
+      # Deletes all edges going to the given vertex.
+      #
+      # @param to Vertex to which all edges should be removed
+      #
+      # @return [void]
+      def delete_edges_to(to)
+        return if @to_graph[to].nil?
+
+        @to_graph[to].each do |from|
+          @edge_props.delete([from, to])
+        end
+        @to_graph.delete(to)
+
+        invalidate_caches
+      end
+
+      # @group Querying the graph
+
+      # Returns the direct predecessors of the given vertex, i.e. the vertices
+      # x where there is an edge from x to the given vertex y.
+      #
+      # @param to The vertex of which the predecessors should be calculated
+      #
+      # @return [Array] Direct predecessors of the given vertex
+      def direct_predecessors_of(to)
+        @to_graph.fetch(to, Set.new)
+      end
+
+      # Returns the predecessors of the given vertex, i.e. the vertices x for
+      # which there is a path from x to the given vertex y.
+      #
+      # @param to The vertex of which the predecessors should be calculated
+      #
+      # @return [Array] Predecessors of the given vertex
+      def predecessors_of(to)
+        @predecessors[to] ||= recursively_find_vertices(to, :direct_predecessors_of)
+      end
+
+      def props_for(from, to)
+        @edge_props[[from, to]]
+      end
+
+      # @return [Array] The list of all vertices in this graph.
+      def vertices
+        @vertices.keys.sort_by { |v| @vertices[v] }
+      end
+
+      # Returns an array of tuples representing the edges. The result of this
+      # method may take a while to compute and should be cached if possible.
+      #
+      # @return [Array] The list of all edges in this graph.
+      def edges
+        result = []
+        @vertices.each_pair do |v2, i2|
+          direct_predecessors_of(v2).map { |v1| [@vertices[v1], v1] }.each do |i1, v1|
+            result << [i1, i2, @edge_props[[v1, v2]]]
+          end
+        end
+        result
+      end
+
+      private
+
+      # Invalidates cached data. This method should be called when the internal
+      # graph representation is changed.
+      def invalidate_caches
+        @predecessors = {}
+      end
+
+      # Recursively finds vertices, starting at the vertex start, using the
+      # given method, which should be a symbol to a method that takes a vertex
+      # and returns related vertices (e.g. predecessors, successors).
+      def recursively_find_vertices(start, method)
+        all_vertices = Set.new
+
+        processed_vertices   = Set.new
+        unprocessed_vertices = [start]
+
+        until unprocessed_vertices.empty?
+          # Get next unprocessed vertex
+          vertex = unprocessed_vertices.pop
+          next if processed_vertices.include?(vertex)
+
+          processed_vertices << vertex
+
+          # Add predecessors of this vertex
+          send(method, vertex).each do |v|
+            all_vertices << v unless all_vertices.include?(v)
+            unprocessed_vertices << v
+          end
+        end
+
+        all_vertices
+      end
+    end
+  end
+end

data/lib/nanoc/core/document.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class Document
+      include Nanoc::Core::ContractsSupport
+
+      # @return [Nanoc::Core::Content]
+      attr_reader :content
+
+      # @return [Hash]
+      def attributes
+        @attributes.value
+      end
+
+      # @return [Nanoc::Core::Identifier]
+      attr_reader :identifier
+
+      # @return [String, nil]
+      attr_accessor :checksum_data
+
+      # @return [String, nil]
+      attr_accessor :content_checksum_data
+
+      # @return [String, nil]
+      attr_accessor :attributes_checksum_data
+
+      c_content = C::Or[String, Nanoc::Core::Content]
+      c_attributes = C::Or[Hash, Proc]
+      c_identifier = C::Or[String, Nanoc::Core::Identifier]
+      c_checksum_data = C::KeywordArgs[
+        checksum_data: C::Optional[C::Maybe[String]],
+        content_checksum_data: C::Optional[C::Maybe[String]],
+        attributes_checksum_data: C::Optional[C::Maybe[String]],
+      ]
+
+      contract c_content, c_attributes, c_identifier, c_checksum_data => C::Any
+      # @param [String, Nanoc::Core::Content] content
+      #
+      # @param [Hash, Proc] attributes
+      #
+      # @param [String, Nanoc::Core::Identifier] identifier
+      #
+      # @param [String, nil] checksum_data
+      #
+      # @param [String, nil] content_checksum_data
+      #
+      # @param [String, nil] attributes_checksum_data
+      def initialize(content, attributes, identifier, checksum_data: nil, content_checksum_data: nil, attributes_checksum_data: nil)
+        @content = Nanoc::Core::Content.create(content)
+        @attributes = Nanoc::Core::LazyValue.new(attributes).map(&:__nanoc_symbolize_keys_recursively)
+        @identifier = Nanoc::Core::Identifier.from(identifier)
+
+        @checksum_data = checksum_data
+        @content_checksum_data = content_checksum_data
+        @attributes_checksum_data = attributes_checksum_data
+      end
+
+      contract C::None => self
+      # @return [void]
+      def freeze
+        super
+        @content.freeze
+        @attributes.freeze
+        self
+      end
+
+      contract String => self
+      def with_identifier_prefix(prefix)
+        other = dup
+        other.identifier = @identifier.prefix(prefix)
+        other
+      end
+
+      contract C::None => String
+      # @abstract
+      #
+      # @return Unique reference to this object
+      def reference
+        raise NotImplementedError
+      end
+
+      contract C::Or[Nanoc::Core::Identifier, String] => Nanoc::Core::Identifier
+      def identifier=(new_identifier)
+        @identifier = Nanoc::Core::Identifier.from(new_identifier)
+      end
+
+      contract Nanoc::Core::Content => C::Any
+      def content=(new_content)
+        @content = new_content
+
+        @checksum_data = nil
+        @content_checksum_data = nil
+      end
+
+      def set_attribute(key, value)
+        attributes[key] = value
+
+        @checksum_data = nil
+        @attributes_checksum_data = nil
+      end
+
+      contract C::None => String
+      def inspect
+        "<#{self.class} identifier=\"#{identifier}\">"
+      end
+
+      contract C::None => C::Num
+      def hash
+        self.class.hash ^ identifier.hash
+      end
+
+      contract C::Any => C::Bool
+      def ==(other)
+        other.respond_to?(:identifier) && identifier == other.identifier
+      end
+
+      contract C::Any => C::Bool
+      def eql?(other)
+        other.is_a?(self.class) && identifier == other.identifier
+      end
+    end
+  end
+end

data/lib/nanoc/core/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    # Generic error. Superclass for all Nanoc-specific errors.
+    class Error < ::StandardError
+    end
+  end
+end

data/lib/nanoc/core/identifiable_collection.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class IdentifiableCollection
+      DDMemoize.activate(self)
+
+      include Nanoc::Core::ContractsSupport
+      include Enumerable
+
+      extend Forwardable
+
+      def_delegator :@objects, :each
+      def_delegator :@objects, :size
+
+      def initialize(*)
+        raise 'IdentifiableCollection is abstract and cannot be instantiated'
+      end
+
+      contract C::Or[Hash, C::Named['Nanoc::Core::Configuration']], C::IterOf[C::RespondTo[:identifier]], C::Maybe[String] => C::Any
+      def initialize_basic(config, objects = [], name = nil)
+        @config = config
+        @objects = Hamster::Vector.new(objects)
+        @name = name
+      end
+
+      contract C::None => String
+      def inspect
+        "<#{self.class}>"
+      end
+
+      contract C::None => self
+      def freeze
+        @objects.freeze
+        @objects.each(&:freeze)
+        build_mapping
+        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?
+          find_all_memoized(arg)
+        else
+          find_all_unmemoized(arg)
+        end
+      end
+
+      contract C::None => C::ArrayOf[C::RespondTo[:identifier]]
+      def to_a
+        @objects.to_a
+      end
+
+      contract C::None => C::Bool
+      def empty?
+        @objects.empty?
+      end
+
+      contract C::RespondTo[:identifier] => self
+      def add(obj)
+        self.class.new(@config, @objects.add(obj))
+      end
+
+      contract C::Func[C::RespondTo[:identifier] => C::Any] => self
+      def reject(&block)
+        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]
+        else
+          @objects.find { |i| i.identifier == identifier }
+        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
+          @objects.find { |i| i.identifier.to_s =~ arg }
+        else
+          raise ArgumentError, "don’t know how to fetch objects by #{arg.inspect}"
+        end
+      end
+
+      contract C::Any => C::Maybe[C::RespondTo[:identifier]]
+      memoized def get_memoized(arg)
+        get_unmemoized(arg)
+      end
+
+      contract C::Any => C::IterOf[C::RespondTo[:identifier]]
+      def find_all_unmemoized(arg)
+        pat = Nanoc::Core::Pattern.from(arg)
+        select { |i| pat.match?(i.identifier) }
+      end
+
+      contract C::Any => C::IterOf[C::RespondTo[:identifier]]
+      memoized def find_all_memoized(arg)
+        find_all_unmemoized(arg)
+      end
+
+      def object_matching_glob(glob)
+        if use_globs?
+          pat = Nanoc::Core::Pattern.from(glob)
+          @objects.find { |i| pat.match?(i.identifier) }
+        else
+          nil
+        end
+      end
+
+      def build_mapping
+        @mapping = {}
+        @objects.each do |object|
+          @mapping[object.identifier.to_s] = object
+        end
+        @mapping.freeze
+      end
+
+      contract C::None => C::Bool
+      def use_globs?
+        @config[:string_pattern_type] == 'glob'
+      end
+    end
+  end
+end

data/lib/nanoc/core/identifier.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class Identifier
+      include Comparable
+      include Nanoc::Core::ContractsSupport
+
+      class InvalidIdentifierError < ::Nanoc::Core::Error
+        def initialize(string)
+          super("Invalid identifier (does not start with a slash): #{string.inspect}")
+        end
+      end
+
+      class InvalidFullIdentifierError < ::Nanoc::Core::Error
+        def initialize(string)
+          super("Invalid full identifier (ends with a slash): #{string.inspect}")
+        end
+      end
+
+      class InvalidTypeError < ::Nanoc::Core::Error
+        def initialize(type)
+          super("Invalid type for identifier: #{type.inspect} (can be :full or :legacy)")
+        end
+      end
+
+      class InvalidPrefixError < ::Nanoc::Core::Error
+        def initialize(string)
+          super("Invalid prefix (does not start with a slash): #{string.inspect}")
+        end
+      end
+
+      class UnsupportedLegacyOperationError < ::Nanoc::Core::Error
+        def initialize
+          super('Cannot use this method on legacy identifiers')
+        end
+      end
+
+      class NonCoercibleObjectError < ::Nanoc::Core::Error
+        def initialize(obj)
+          super("#{obj.inspect} cannot be converted into a Nanoc::Core::Identifier")
+        end
+      end
+
+      contract C::Any => self
+      def self.from(obj)
+        case obj
+        when Nanoc::Core::Identifier
+          obj
+        when String
+          Nanoc::Core::Identifier.new(obj)
+        else
+          raise NonCoercibleObjectError.new(obj)
+        end
+      end
+
+      contract String, C::KeywordArgs[type: C::Optional[Symbol]] => C::Any
+      def initialize(string, type: :full)
+        @type = type
+
+        case @type
+        when :legacy
+          @string = "/#{string}/".gsub(/^\/+|\/+$/, '/').freeze
+        when :full
+          raise InvalidIdentifierError.new(string) if string !~ /\A\//
+          raise InvalidFullIdentifierError.new(string) if string =~ /\/\z/
+
+          @string = string.dup.freeze
+        else
+          raise InvalidTypeError.new(@type)
+        end
+      end
+
+      contract C::Any => C::Bool
+      def ==(other)
+        case other
+        when Nanoc::Core::Identifier, String
+          to_s == other.to_s
+        else
+          false
+        end
+      end
+
+      contract C::Any => C::Bool
+      def eql?(other)
+        other.is_a?(self.class) && to_s == other.to_s
+      end
+
+      contract C::None => C::Num
+      def hash
+        self.class.hash ^ to_s.hash
+      end
+
+      contract C::Any => C::Maybe[C::Num]
+      def =~(other)
+        Nanoc::Core::Pattern.from(other).match?(to_s) ? 0 : nil
+      end
+
+      contract C::Any => C::Bool
+      def match?(other)
+        Nanoc::Core::Pattern.from(other).match?(to_s)
+      end
+
+      contract C::Any => C::Num
+      def <=>(other)
+        to_s <=> other.to_s
+      end
+
+      contract C::None => C::Bool
+      # Whether or not this is a full identifier (i.e.includes the extension).
+      def full?
+        @type == :full
+      end
+
+      contract C::None => C::Bool
+      # Whether or not this is a legacy identifier (i.e. does not include the extension).
+      def legacy?
+        @type == :legacy
+      end
+
+      contract C::None => String
+      # @return [String]
+      def chop
+        to_s.chop
+      end
+
+      contract String => String
+      # @return [String]
+      def +(other)
+        to_s + other
+      end
+
+      contract String => self
+      # @return [Nanoc::Core::Identifier]
+      def prefix(string)
+        unless /\A\//.match?(string)
+          raise InvalidPrefixError.new(string)
+        end
+
+        Nanoc::Core::Identifier.new(string.sub(/\/+\z/, '') + @string, type: @type)
+      end
+
+      contract C::None => String
+      # The identifier, as string, with the last extension removed
+      def without_ext
+        unless full?
+          raise UnsupportedLegacyOperationError
+        end
+
+        extname = File.extname(@string)
+
+        if !extname.empty?
+          @string[0..-extname.size - 1]
+        else
+          @string
+        end
+      end
+
+      contract C::None => C::Maybe[String]
+      # The extension, without a leading dot
+      def ext
+        unless full?
+          raise UnsupportedLegacyOperationError
+        end
+
+        s = File.extname(@string)
+        s && s[1..-1]
+      end
+
+      contract C::None => String
+      # The identifier, as string, with all extensions removed
+      def without_exts
+        extname = exts.join('.')
+        if !extname.empty?
+          @string[0..-extname.size - 2]
+        else
+          @string
+        end
+      end
+
+      contract C::None => C::ArrayOf[String]
+      # The list of extensions, without a leading dot
+      def exts
+        unless full?
+          raise UnsupportedLegacyOperationError
+        end
+
+        s = File.basename(@string)
+        s ? s.split('.', -1).drop(1) : []
+      end
+
+      contract C::None => C::ArrayOf[String]
+      def components
+        res = to_s.split('/')
+        if res.empty?
+          []
+        else
+          res[1..-1]
+        end
+      end
+
+      contract C::None => String
+      def to_s
+        @string
+      end
+
+      contract C::None => String
+      def to_str
+        @string
+      end
+
+      contract C::None => String
+      def inspect
+        "<Nanoc::Core::Identifier type=#{@type} #{to_s.inspect}>"
+      end
+    end
+  end
+end

data/lib/nanoc/core/item.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class Item < ::Nanoc::Core::Document
+      def reference
+        "item:#{identifier}"
+      end
+    end
+  end
+end

data/lib/nanoc/core/item_collection.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module Core
+    class ItemCollection < IdentifiableCollection
+      def initialize(config, objects = [])
+        initialize_basic(config, objects, 'items')
+      end
+
+      def reference
+        'items'
+      end
+    end
+  end
+end