nanoc 4.11.0 → 4.11.1

data/lib/nanoc/base/entities/content.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # Abstract content.
-    #
-    # The filename is the full filename on the default filesystem. It can be
-    # nil. It is used by filters such as Sass, which look up items on the
-    # filesystem.
-    #
-    # @abstract
-    #
-    # @api private
-    class Content
-      include Nanoc::Int::ContractsSupport
-
-      # @return [String, nil]
-      attr_reader :filename
-
-      contract C::Maybe[String] => C::Any
-      # @param [String, nil] filename
-      def initialize(filename)
-        if filename && Pathname.new(filename).relative?
-          raise ArgumentError, 'Content filename is not absolute'
-        end
-
-        @filename = filename
-      end
-
-      contract C::None => self
-      def freeze
-        super
-        @filename.freeze
-        self
-      end
-
-      contract C::Or[Nanoc::Int::Content, String, Proc], C::KeywordArgs[binary: C::Optional[C::Bool], filename: C::Optional[C::Maybe[String]]] => self
-      # @param [Nanoc::Int::Content, String, Proc] content The uncompiled item
-      #   content (if it is textual content) or the path to the filename
-      #   containing the content (if this is binary content).
-      #
-      # @param [Boolean] binary Whether or not this item is binary
-      #
-      # @param [String] filename Absolute path to the file containing this
-      #   content (if any)
-      def self.create(content, binary: false, filename: nil)
-        if content.nil?
-          raise ArgumentError, 'Cannot create nil content'
-        elsif content.is_a?(Nanoc::Int::Content)
-          content
-        elsif binary
-          Nanoc::Int::BinaryContent.new(content)
-        else
-          Nanoc::Int::TextualContent.new(content, filename: filename)
-        end
-      end
-
-      # @abstract
-      #
-      # @return [Boolean]
-      def binary?
-        raise NotImplementedError
-      end
-    end
-
-    # @api private
-    class TextualContent < Content
-      contract C::None => String
-      # @return [String]
-      def string
-        @string.value
-      end
-
-      contract C::Or[String, Proc], C::KeywordArgs[filename: C::Optional[C::Maybe[String]]] => C::Any
-      def initialize(string, filename: nil)
-        super(filename)
-        @string = Nanoc::Int::LazyValue.new(string)
-      end
-
-      contract C::None => self
-      def freeze
-        super
-        @string.freeze
-        self
-      end
-
-      contract C::None => C::Bool
-      def binary?
-        false
-      end
-
-      contract C::None => Array
-      def marshal_dump
-        [filename, string]
-      end
-
-      contract Array => C::Any
-      def marshal_load(array)
-        @filename = array[0]
-        @string = Nanoc::Int::LazyValue.new(array[1])
-      end
-    end
-
-    # @api private
-    class BinaryContent < Content
-      contract C::None => C::Bool
-      def binary?
-        true
-      end
-    end
-  end
-end

data/lib/nanoc/base/entities/context.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Int
-  # Provides a context and a binding for use in filters such as the ERB and
-  # Haml ones.
-  #
-  # @api private
-  class Context
-    # Creates a new context based off the contents of the hash.
-    #
-    # Each pair in the hash will be converted to an instance variable and an
-    # instance method. For example, passing the hash `{ :foo => 'bar' }` will
-    # cause `@foo` to have the value `"bar"`, and the instance method `#foo`
-    # to return the same value `"bar"`.
-    #
-    # @param [Hash] hash A list of key-value pairs to make available
-    #
-    # @example Defining a context and accessing values
-    #
-    #     context = Nanoc::Int::Context.new(
-    #       :name     => 'Max Payne',
-    #       :location => 'in a cheap motel'
-    #     )
-    #     context.instance_eval do
-    #       "I am #{name} and I am hiding #{@location}."
-    #     end
-    #     # => "I am Max Payne and I am hiding in a cheap motel."
-    def initialize(hash)
-      hash.each_pair do |key, value|
-        instance_variable_set('@' + key.to_s, value)
-      end
-    end
-
-    # Returns a binding for this instance.
-    #
-    # @return [Binding] A binding for this instance
-    # rubocop:disable Naming/AccessorMethodName
-    def get_binding
-      binding
-    end
-    # rubocop:enable Naming/AccessorMethodName
-
-    def method_missing(method, *args, &blk)
-      ivar_name = '@' + method.to_s
-      if instance_variable_defined?(ivar_name)
-        instance_variable_get(ivar_name)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method, include_all)
-      ivar_name = '@' + method.to_s
-
-      valid_ivar_name =
-        if defined?(Contracts)
-          ivar_name =~ /\A@[A-Za-z_]+\z/
-        else
-          true # probably good enough
-        end
-
-      (valid_ivar_name && instance_variable_defined?(ivar_name)) || super
-    end
-
-    def include(mod)
-      metaclass = class << self; self; end
-      metaclass.instance_eval { include(mod) }
-    end
-  end
-end

data/lib/nanoc/base/entities/directed_graph.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Int
-  # 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::Int::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 )
-  #
-  # @api private
-  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

data/lib/nanoc/base/entities/document.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  module Int
-    # @api private
-    class Document
-      include Nanoc::Int::ContractsSupport
-
-      # @return [Nanoc::Int::Content]
-      attr_reader :content
-
-      # @return [Hash]
-      def attributes
-        @attributes.value
-      end
-
-      # @return [Nanoc::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::Int::Content]
-      c_attributes = C::Or[Hash, Proc]
-      c_identifier = C::Or[String, Nanoc::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::Int::Content] content
-      #
-      # @param [Hash, Proc] attributes
-      #
-      # @param [String, Nanoc::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::Int::Content.create(content)
-        @attributes = Nanoc::Int::LazyValue.new(attributes).map(&:__nanoc_symbolize_keys_recursively)
-        @identifier = Nanoc::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::Identifier, String] => Nanoc::Identifier
-      def identifier=(new_identifier)
-        @identifier = Nanoc::Identifier.from(new_identifier)
-      end
-
-      contract Nanoc::Int::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