nanoc 4.11.0 → 4.11.1

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

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Int
-  # @api private
-  class IdentifiableCollection
-    DDMemoize.activate(self)
-
-    include Nanoc::Int::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::Int::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::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::Int::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::Int::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

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

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc
-  class Identifier
-    include Comparable
-    include Nanoc::Int::ContractsSupport
-
-    # @api private
-    class InvalidIdentifierError < ::Nanoc::Error
-      def initialize(string)
-        super("Invalid identifier (does not start with a slash): #{string.inspect}")
-      end
-    end
-
-    # @api private
-    class InvalidFullIdentifierError < ::Nanoc::Error
-      def initialize(string)
-        super("Invalid full identifier (ends with a slash): #{string.inspect}")
-      end
-    end
-
-    # @api private
-    class InvalidTypeError < ::Nanoc::Error
-      def initialize(type)
-        super("Invalid type for identifier: #{type.inspect} (can be :full or :legacy)")
-      end
-    end
-
-    # @api private
-    class InvalidPrefixError < ::Nanoc::Error
-      def initialize(string)
-        super("Invalid prefix (does not start with a slash): #{string.inspect}")
-      end
-    end
-
-    # @api private
-    class UnsupportedLegacyOperationError < ::Nanoc::Error
-      def initialize
-        super('Cannot use this method on legacy identifiers')
-      end
-    end
-
-    # @api private
-    class NonCoercibleObjectError < ::Nanoc::Error
-      def initialize(obj)
-        super("#{obj.inspect} cannot be converted into a Nanoc::Identifier")
-      end
-    end
-
-    contract C::Any => self
-    def self.from(obj)
-      case obj
-      when Nanoc::Identifier
-        obj
-      when String
-        Nanoc::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::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::Int::Pattern.from(other).match?(to_s) ? 0 : nil
-    end
-
-    contract C::Any => C::Bool
-    def match?(other)
-      Nanoc::Int::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::Identifier]
-    def prefix(string)
-      unless /\A\//.match?(string)
-        raise InvalidPrefixError.new(string)
-      end
-
-      Nanoc::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::Identifier type=#{@type} #{to_s.inspect}>"
-    end
-  end
-end

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

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

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

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

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Nanoc::Int
-  # @api private
-  class ItemRep
-    include Nanoc::Int::ContractsSupport
-
-    contract C::None => C::Bool
-    attr_accessor :compiled
-    alias compiled? compiled
-
-    contract C::None => C::HashOf[Symbol => C::IterOf[String]]
-    attr_reader :raw_paths
-
-    contract C::None => C::HashOf[Symbol => C::IterOf[String]]
-    attr_reader :paths
-
-    contract C::None => Nanoc::Int::Item
-    attr_reader :item
-
-    contract C::None => Symbol
-    attr_reader :name
-
-    contract C::None => C::IterOf[C::Named['Nanoc::Int::SnapshotDef']]
-    attr_accessor :snapshot_defs
-
-    contract C::None => C::Bool
-    attr_accessor :modified
-    alias modified? modified
-
-    contract Nanoc::Int::Item, Symbol => C::Any
-    def initialize(item, name)
-      # Set primary attributes
-      @item   = item
-      @name   = name
-
-      # Set default attributes
-      @raw_paths  = {}
-      @paths      = {}
-      @snapshot_defs = []
-
-      # Reset flags
-      @compiled = false
-      @modified = false
-    end
-
-    contract C::HashOf[Symbol => C::IterOf[C::AbsolutePathString]] => C::HashOf[Symbol => C::IterOf[C::AbsolutePathString]]
-    def raw_paths=(val)
-      @raw_paths = val
-    end
-
-    contract C::HashOf[Symbol => C::IterOf[String]] => C::HashOf[Symbol => C::IterOf[String]]
-    def paths=(val)
-      @paths = val
-    end
-
-    contract Symbol => C::Bool
-    def snapshot?(name)
-      snapshot_defs.any? { |sd| sd.name == name }
-    end
-
-    contract C::KeywordArgs[snapshot: C::Optional[Symbol]] => C::Maybe[String]
-    # Returns the item rep’s raw path. It includes the path to the output
-    # directory and the full filename.
-    def raw_path(snapshot: :last)
-      @raw_paths.fetch(snapshot, []).first
-    end
-
-    contract C::KeywordArgs[snapshot: C::Optional[Symbol]] => C::Maybe[String]
-    # Returns the item rep’s path, as used when being linked to. It starts
-    # with a slash and it is relative to the output directory. It does not
-    # include the path to the output directory. It will not include the
-    # filename if the filename is an index filename.
-    def path(snapshot: :last)
-      @paths.fetch(snapshot, []).first
-    end
-
-    # Returns an object that can be used for uniquely identifying objects.
-    def reference
-      "item_rep:#{item.identifier}:#{name}"
-    end
-
-    def to_s
-      "#{item.identifier} (rep name #{name.inspect})"
-    end
-
-    def inspect
-      "<#{self.class} name=\"#{name}\" raw_path=\"#{raw_path}\" item.identifier=\"#{item.identifier}\">"
-    end
-  end
-end