rubygems-update 3.3.27 → 3.4.0

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph/vertex.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler::Molinillo
-  class DependencyGraph
-    # A vertex in a {DependencyGraph} that encapsulates a {#name} and a
-    # {#payload}
-    class Vertex
-      # @return [String] the name of the vertex
-      attr_accessor :name
-
-      # @return [Object] the payload the vertex holds
-      attr_accessor :payload
-
-      # @return [Array<Object>] the explicit requirements that required
-      #   this vertex
-      attr_reader :explicit_requirements
-
-      # @return [Boolean] whether the vertex is considered a root vertex
-      attr_accessor :root
-      alias root? root
-
-      # Initializes a vertex with the given name and payload.
-      # @param [String] name see {#name}
-      # @param [Object] payload see {#payload}
-      def initialize(name, payload)
-        @name = name.frozen? ? name : name.dup.freeze
-        @payload = payload
-        @explicit_requirements = []
-        @outgoing_edges = []
-        @incoming_edges = []
-      end
-
-      # @return [Array<Object>] all of the requirements that required
-      #   this vertex
-      def requirements
-        (incoming_edges.map(&:requirement) + explicit_requirements).uniq
-      end
-
-      # @return [Array<Edge>] the edges of {#graph} that have `self` as their
-      #   {Edge#origin}
-      attr_accessor :outgoing_edges
-
-      # @return [Array<Edge>] the edges of {#graph} that have `self` as their
-      #   {Edge#destination}
-      attr_accessor :incoming_edges
-
-      # @return [Array<Vertex>] the vertices of {#graph} that have an edge with
-      #   `self` as their {Edge#destination}
-      def predecessors
-        incoming_edges.map(&:origin)
-      end
-
-      # @return [Set<Vertex>] the vertices of {#graph} where `self` is a
-      #   {#descendent?}
-      def recursive_predecessors
-        _recursive_predecessors
-      end
-
-      # @param [Set<Vertex>] vertices the set to add the predecessors to
-      # @return [Set<Vertex>] the vertices of {#graph} where `self` is a
-      #   {#descendent?}
-      def _recursive_predecessors(vertices = new_vertex_set)
-        incoming_edges.each do |edge|
-          vertex = edge.origin
-          next unless vertices.add?(vertex)
-          vertex._recursive_predecessors(vertices)
-        end
-
-        vertices
-      end
-      protected :_recursive_predecessors
-
-      # @return [Array<Vertex>] the vertices of {#graph} that have an edge with
-      #   `self` as their {Edge#origin}
-      def successors
-        outgoing_edges.map(&:destination)
-      end
-
-      # @return [Set<Vertex>] the vertices of {#graph} where `self` is an
-      #   {#ancestor?}
-      def recursive_successors
-        _recursive_successors
-      end
-
-      # @param [Set<Vertex>] vertices the set to add the successors to
-      # @return [Set<Vertex>] the vertices of {#graph} where `self` is an
-      #   {#ancestor?}
-      def _recursive_successors(vertices = new_vertex_set)
-        outgoing_edges.each do |edge|
-          vertex = edge.destination
-          next unless vertices.add?(vertex)
-          vertex._recursive_successors(vertices)
-        end
-
-        vertices
-      end
-      protected :_recursive_successors
-
-      # @return [String] a string suitable for debugging
-      def inspect
-        "#{self.class}:#{name}(#{payload.inspect})"
-      end
-
-      # @return [Boolean] whether the two vertices are equal, determined
-      #   by a recursive traversal of each {Vertex#successors}
-      def ==(other)
-        return true if equal?(other)
-        shallow_eql?(other) &&
-          successors.to_set == other.successors.to_set
-      end
-
-      # @param  [Vertex] other the other vertex to compare to
-      # @return [Boolean] whether the two vertices are equal, determined
-      #   solely by {#name} and {#payload} equality
-      def shallow_eql?(other)
-        return true if equal?(other)
-        other &&
-          name == other.name &&
-          payload == other.payload
-      end
-
-      alias eql? ==
-
-      # @return [Fixnum] a hash for the vertex based upon its {#name}
-      def hash
-        name.hash
-      end
-
-      # Is there a path from `self` to `other` following edges in the
-      # dependency graph?
-      # @return whether there is a path following edges within this {#graph}
-      def path_to?(other)
-        _path_to?(other)
-      end
-
-      alias descendent? path_to?
-
-      # @param [Vertex] other the vertex to check if there's a path to
-      # @param [Set<Vertex>] visited the vertices of {#graph} that have been visited
-      # @return [Boolean] whether there is a path to `other` from `self`
-      def _path_to?(other, visited = new_vertex_set)
-        return false unless visited.add?(self)
-        return true if equal?(other)
-        successors.any? { |v| v._path_to?(other, visited) }
-      end
-      protected :_path_to?
-
-      # Is there a path from `other` to `self` following edges in the
-      # dependency graph?
-      # @return whether there is a path following edges within this {#graph}
-      def ancestor?(other)
-        other.path_to?(self)
-      end
-
-      alias is_reachable_from? ancestor?
-
-      def new_vertex_set
-        require 'set'
-        Set.new
-      end
-      private :new_vertex_set
-    end
-  end
-end

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/dependency_graph.rb

@@ -1,255 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../../vendored_tsort'
-
-require_relative 'dependency_graph/log'
-require_relative 'dependency_graph/vertex'
-
-module Bundler::Molinillo
-  # A directed acyclic graph that is tuned to hold named dependencies
-  class DependencyGraph
-    include Enumerable
-
-    # Enumerates through the vertices of the graph.
-    # @return [Array<Vertex>] The graph's vertices.
-    def each
-      return vertices.values.each unless block_given?
-      vertices.values.each { |v| yield v }
-    end
-
-    include Bundler::TSort
-
-    # @!visibility private
-    alias tsort_each_node each
-
-    # @!visibility private
-    def tsort_each_child(vertex, &block)
-      vertex.successors.each(&block)
-    end
-
-    # Topologically sorts the given vertices.
-    # @param [Enumerable<Vertex>] vertices the vertices to be sorted, which must
-    #   all belong to the same graph.
-    # @return [Array<Vertex>] The sorted vertices.
-    def self.tsort(vertices)
-      Bundler::TSort.tsort(
-        lambda { |b| vertices.each(&b) },
-        lambda { |v, &b| (v.successors & vertices).each(&b) }
-      )
-    end
-
-    # A directed edge of a {DependencyGraph}
-    # @attr [Vertex] origin The origin of the directed edge
-    # @attr [Vertex] destination The destination of the directed edge
-    # @attr [Object] requirement The requirement the directed edge represents
-    Edge = Struct.new(:origin, :destination, :requirement)
-
-    # @return [{String => Vertex}] the vertices of the dependency graph, keyed
-    #   by {Vertex#name}
-    attr_reader :vertices
-
-    # @return [Log] the op log for this graph
-    attr_reader :log
-
-    # Initializes an empty dependency graph
-    def initialize
-      @vertices = {}
-      @log = Log.new
-    end
-
-    # Tags the current state of the dependency as the given tag
-    # @param  [Object] tag an opaque tag for the current state of the graph
-    # @return [Void]
-    def tag(tag)
-      log.tag(self, tag)
-    end
-
-    # Rewinds the graph to the state tagged as `tag`
-    # @param  [Object] tag the tag to rewind to
-    # @return [Void]
-    def rewind_to(tag)
-      log.rewind_to(self, tag)
-    end
-
-    # Initializes a copy of a {DependencyGraph}, ensuring that all {#vertices}
-    # are properly copied.
-    # @param [DependencyGraph] other the graph to copy.
-    def initialize_copy(other)
-      super
-      @vertices = {}
-      @log = other.log.dup
-      traverse = lambda do |new_v, old_v|
-        return if new_v.outgoing_edges.size == old_v.outgoing_edges.size
-        old_v.outgoing_edges.each do |edge|
-          destination = add_vertex(edge.destination.name, edge.destination.payload)
-          add_edge_no_circular(new_v, destination, edge.requirement)
-          traverse.call(destination, edge.destination)
-        end
-      end
-      other.vertices.each do |name, vertex|
-        new_vertex = add_vertex(name, vertex.payload, vertex.root?)
-        new_vertex.explicit_requirements.replace(vertex.explicit_requirements)
-        traverse.call(new_vertex, vertex)
-      end
-    end
-
-    # @return [String] a string suitable for debugging
-    def inspect
-      "#{self.class}:#{vertices.values.inspect}"
-    end
-
-    # @param [Hash] options options for dot output.
-    # @return [String] Returns a dot format representation of the graph
-    def to_dot(options = {})
-      edge_label = options.delete(:edge_label)
-      raise ArgumentError, "Unknown options: #{options.keys}" unless options.empty?
-
-      dot_vertices = []
-      dot_edges = []
-      vertices.each do |n, v|
-        dot_vertices << "  #{n} [label=\"{#{n}|#{v.payload}}\"]"
-        v.outgoing_edges.each do |e|
-          label = edge_label ? edge_label.call(e) : e.requirement
-          dot_edges << "  #{e.origin.name} -> #{e.destination.name} [label=#{label.to_s.dump}]"
-        end
-      end
-
-      dot_vertices.uniq!
-      dot_vertices.sort!
-      dot_edges.uniq!
-      dot_edges.sort!
-
-      dot = dot_vertices.unshift('digraph G {').push('') + dot_edges.push('}')
-      dot.join("\n")
-    end
-
-    # @param [DependencyGraph] other
-    # @return [Boolean] whether the two dependency graphs are equal, determined
-    #   by a recursive traversal of each {#root_vertices} and its
-    #   {Vertex#successors}
-    def ==(other)
-      return false unless other
-      return true if equal?(other)
-      vertices.each do |name, vertex|
-        other_vertex = other.vertex_named(name)
-        return false unless other_vertex
-        return false unless vertex.payload == other_vertex.payload
-        return false unless other_vertex.successors.to_set == vertex.successors.to_set
-      end
-    end
-
-    # @param [String] name
-    # @param [Object] payload
-    # @param [Array<String>] parent_names
-    # @param [Object] requirement the requirement that is requiring the child
-    # @return [void]
-    def add_child_vertex(name, payload, parent_names, requirement)
-      root = !parent_names.delete(nil) { true }
-      vertex = add_vertex(name, payload, root)
-      vertex.explicit_requirements << requirement if root
-      parent_names.each do |parent_name|
-        parent_vertex = vertex_named(parent_name)
-        add_edge(parent_vertex, vertex, requirement)
-      end
-      vertex
-    end
-
-    # Adds a vertex with the given name, or updates the existing one.
-    # @param [String] name
-    # @param [Object] payload
-    # @return [Vertex] the vertex that was added to `self`
-    def add_vertex(name, payload, root = false)
-      log.add_vertex(self, name, payload, root)
-    end
-
-    # Detaches the {#vertex_named} `name` {Vertex} from the graph, recursively
-    # removing any non-root vertices that were orphaned in the process
-    # @param [String] name
-    # @return [Array<Vertex>] the vertices which have been detached
-    def detach_vertex_named(name)
-      log.detach_vertex_named(self, name)
-    end
-
-    # @param [String] name
-    # @return [Vertex,nil] the vertex with the given name
-    def vertex_named(name)
-      vertices[name]
-    end
-
-    # @param [String] name
-    # @return [Vertex,nil] the root vertex with the given name
-    def root_vertex_named(name)
-      vertex = vertex_named(name)
-      vertex if vertex && vertex.root?
-    end
-
-    # Adds a new {Edge} to the dependency graph
-    # @param [Vertex] origin
-    # @param [Vertex] destination
-    # @param [Object] requirement the requirement that this edge represents
-    # @return [Edge] the added edge
-    def add_edge(origin, destination, requirement)
-      if destination.path_to?(origin)
-        raise CircularDependencyError.new(path(destination, origin))
-      end
-      add_edge_no_circular(origin, destination, requirement)
-    end
-
-    # Deletes an {Edge} from the dependency graph
-    # @param [Edge] edge
-    # @return [Void]
-    def delete_edge(edge)
-      log.delete_edge(self, edge.origin.name, edge.destination.name, edge.requirement)
-    end
-
-    # Sets the payload of the vertex with the given name
-    # @param [String] name the name of the vertex
-    # @param [Object] payload the payload
-    # @return [Void]
-    def set_payload(name, payload)
-      log.set_payload(self, name, payload)
-    end
-
-    private
-
-    # Adds a new {Edge} to the dependency graph without checking for
-    # circularity.
-    # @param (see #add_edge)
-    # @return (see #add_edge)
-    def add_edge_no_circular(origin, destination, requirement)
-      log.add_edge_no_circular(self, origin.name, destination.name, requirement)
-    end
-
-    # Returns the path between two vertices
-    # @raise [ArgumentError] if there is no path between the vertices
-    # @param [Vertex] from
-    # @param [Vertex] to
-    # @return [Array<Vertex>] the shortest path from `from` to `to`
-    def path(from, to)
-      distances = Hash.new(vertices.size + 1)
-      distances[from.name] = 0
-      predecessors = {}
-      each do |vertex|
-        vertex.successors.each do |successor|
-          if distances[successor.name] > distances[vertex.name] + 1
-            distances[successor.name] = distances[vertex.name] + 1
-            predecessors[successor] = vertex
-          end
-        end
-      end
-
-      path = [to]
-      while before = predecessors[to]
-        path << before
-        to = before
-        break if to == from
-      end
-
-      unless path.last.equal?(from)
-        raise ArgumentError, "There is no path from #{from.name} to #{to.name}"
-      end
-
-      path.reverse
-    end
-  end
-end

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/errors.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler::Molinillo
-  # An error that occurred during the resolution process
-  class ResolverError < StandardError; end
-
-  # An error caused by searching for a dependency that is completely unknown,
-  # i.e. has no versions available whatsoever.
-  class NoSuchDependencyError < ResolverError
-    # @return [Object] the dependency that could not be found
-    attr_accessor :dependency
-
-    # @return [Array<Object>] the specifications that depended upon {#dependency}
-    attr_accessor :required_by
-
-    # Initializes a new error with the given missing dependency.
-    # @param [Object] dependency @see {#dependency}
-    # @param [Array<Object>] required_by @see {#required_by}
-    def initialize(dependency, required_by = [])
-      @dependency = dependency
-      @required_by = required_by.uniq
-      super()
-    end
-
-    # The error message for the missing dependency, including the specifications
-    # that had this dependency.
-    def message
-      sources = required_by.map { |r| "`#{r}`" }.join(' and ')
-      message = "Unable to find a specification for `#{dependency}`"
-      message += " depended upon by #{sources}" unless sources.empty?
-      message
-    end
-  end
-
-  # An error caused by attempting to fulfil a dependency that was circular
-  #
-  # @note This exception will be thrown if and only if a {Vertex} is added to a
-  #   {DependencyGraph} that has a {DependencyGraph::Vertex#path_to?} an
-  #   existing {DependencyGraph::Vertex}
-  class CircularDependencyError < ResolverError
-    # [Set<Object>] the dependencies responsible for causing the error
-    attr_reader :dependencies
-
-    # Initializes a new error with the given circular vertices.
-    # @param [Array<DependencyGraph::Vertex>] vertices the vertices in the dependency
-    #   that caused the error
-    def initialize(vertices)
-      super "There is a circular dependency between #{vertices.map(&:name).join(' and ')}"
-      @dependencies = vertices.map { |vertex| vertex.payload.possibilities.last }.to_set
-    end
-  end
-
-  # An error caused by conflicts in version
-  class VersionConflict < ResolverError
-    # @return [{String => Resolution::Conflict}] the conflicts that caused
-    #   resolution to fail
-    attr_reader :conflicts
-
-    # @return [SpecificationProvider] the specification provider used during
-    #   resolution
-    attr_reader :specification_provider
-
-    # Initializes a new error with the given version conflicts.
-    # @param [{String => Resolution::Conflict}] conflicts see {#conflicts}
-    # @param [SpecificationProvider] specification_provider see {#specification_provider}
-    def initialize(conflicts, specification_provider)
-      pairs = []
-      conflicts.values.flat_map(&:requirements).each do |conflicting|
-        conflicting.each do |source, conflict_requirements|
-          conflict_requirements.each do |c|
-            pairs << [c, source]
-          end
-        end
-      end
-
-      super "Unable to satisfy the following requirements:\n\n" \
-        "#{pairs.map { |r, d| "- `#{r}` required by `#{d}`" }.join("\n")}"
-
-      @conflicts = conflicts
-      @specification_provider = specification_provider
-    end
-
-    require_relative 'delegates/specification_provider'
-    include Delegates::SpecificationProvider
-
-    # @return [String] An error message that includes requirement trees,
-    #   which is much more detailed & customizable than the default message
-    # @param [Hash] opts the options to create a message with.
-    # @option opts [String] :solver_name The user-facing name of the solver
-    # @option opts [String] :possibility_type The generic name of a possibility
-    # @option opts [Proc] :reduce_trees A proc that reduced the list of requirement trees
-    # @option opts [Proc] :printable_requirement A proc that pretty-prints requirements
-    # @option opts [Proc] :additional_message_for_conflict A proc that appends additional
-    #   messages for each conflict
-    # @option opts [Proc] :version_for_spec A proc that returns the version number for a
-    #   possibility
-    def message_with_trees(opts = {})
-      solver_name = opts.delete(:solver_name) { self.class.name.split('::').first }
-      possibility_type = opts.delete(:possibility_type) { 'possibility named' }
-      reduce_trees = opts.delete(:reduce_trees) { proc { |trees| trees.uniq.sort_by(&:to_s) } }
-      printable_requirement = opts.delete(:printable_requirement) { proc { |req| req.to_s } }
-      additional_message_for_conflict = opts.delete(:additional_message_for_conflict) { proc {} }
-      version_for_spec = opts.delete(:version_for_spec) { proc(&:to_s) }
-      incompatible_version_message_for_conflict = opts.delete(:incompatible_version_message_for_conflict) do
-        proc do |name, _conflict|
-          %(#{solver_name} could not find compatible versions for #{possibility_type} "#{name}":)
-        end
-      end
-
-      full_message_for_conflict = opts.delete(:full_message_for_conflict) do
-        proc do |name, conflict|
-          o = "\n".dup << incompatible_version_message_for_conflict.call(name, conflict) << "\n"
-          if conflict.locked_requirement
-            o << %(  In snapshot (#{name_for_locking_dependency_source}):\n)
-            o << %(    #{printable_requirement.call(conflict.locked_requirement)}\n)
-            o << %(\n)
-          end
-          o << %(  In #{name_for_explicit_dependency_source}:\n)
-          trees = reduce_trees.call(conflict.requirement_trees)
-
-          o << trees.map do |tree|
-            t = ''.dup
-            depth = 2
-            tree.each do |req|
-              t << '  ' * depth << printable_requirement.call(req)
-              unless tree.last == req
-                if spec = conflict.activated_by_name[name_for(req)]
-                  t << %( was resolved to #{version_for_spec.call(spec)}, which)
-                end
-                t << %( depends on)
-              end
-              t << %(\n)
-              depth += 1
-            end
-            t
-          end.join("\n")
-
-          additional_message_for_conflict.call(o, name, conflict)
-
-          o
-        end
-      end
-
-      conflicts.sort.reduce(''.dup) do |o, (name, conflict)|
-        o << full_message_for_conflict.call(name, conflict)
-      end.strip
-    end
-  end
-end

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/gem_metadata.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler::Molinillo
-  # The version of Bundler::Molinillo.
-  VERSION = '0.8.0'.freeze
-end

data/bundler/lib/bundler/vendor/molinillo/lib/molinillo/modules/specification_provider.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Bundler::Molinillo
-  # Provides information about specifications and dependencies to the resolver,
-  # allowing the {Resolver} class to remain generic while still providing power
-  # and flexibility.
-  #
-  # This module contains the methods that users of Bundler::Molinillo must to implement,
-  # using knowledge of their own model classes.
-  module SpecificationProvider
-    # Search for the specifications that match the given dependency.
-    # The specifications in the returned array will be considered in reverse
-    # order, so the latest version ought to be last.
-    # @note This method should be 'pure', i.e. the return value should depend
-    #   only on the `dependency` parameter.
-    #
-    # @param [Object] dependency
-    # @return [Array<Object>] the specifications that satisfy the given
-    #   `dependency`.
-    def search_for(dependency)
-      []
-    end
-
-    # Returns the dependencies of `specification`.
-    # @note This method should be 'pure', i.e. the return value should depend
-    #   only on the `specification` parameter.
-    #
-    # @param [Object] specification
-    # @return [Array<Object>] the dependencies that are required by the given
-    #   `specification`.
-    def dependencies_for(specification)
-      []
-    end
-
-    # Determines whether the given `requirement` is satisfied by the given
-    # `spec`, in the context of the current `activated` dependency graph.
-    #
-    # @param [Object] requirement
-    # @param [DependencyGraph] activated the current dependency graph in the
-    #   resolution process.
-    # @param [Object] spec
-    # @return [Boolean] whether `requirement` is satisfied by `spec` in the
-    #   context of the current `activated` dependency graph.
-    def requirement_satisfied_by?(requirement, activated, spec)
-      true
-    end
-
-    # Determines whether two arrays of dependencies are equal, and thus can be
-    # grouped.
-    #
-    # @param [Array<Object>] dependencies
-    # @param [Array<Object>] other_dependencies
-    # @return [Boolean] whether `dependencies` and `other_dependencies` should
-    #   be considered equal.
-    def dependencies_equal?(dependencies, other_dependencies)
-      dependencies == other_dependencies
-    end
-
-    # Returns the name for the given `dependency`.
-    # @note This method should be 'pure', i.e. the return value should depend
-    #   only on the `dependency` parameter.
-    #
-    # @param [Object] dependency
-    # @return [String] the name for the given `dependency`.
-    def name_for(dependency)
-      dependency.to_s
-    end
-
-    # @return [String] the name of the source of explicit dependencies, i.e.
-    #   those passed to {Resolver#resolve} directly.
-    def name_for_explicit_dependency_source
-      'user-specified dependency'
-    end
-
-    # @return [String] the name of the source of 'locked' dependencies, i.e.
-    #   those passed to {Resolver#resolve} directly as the `base`
-    def name_for_locking_dependency_source
-      'Lockfile'
-    end
-
-    # Sort dependencies so that the ones that are easiest to resolve are first.
-    # Easiest to resolve is (usually) defined by:
-    #   1) Is this dependency already activated?
-    #   2) How relaxed are the requirements?
-    #   3) Are there any conflicts for this dependency?
-    #   4) How many possibilities are there to satisfy this dependency?
-    #
-    # @param [Array<Object>] dependencies
-    # @param [DependencyGraph] activated the current dependency graph in the
-    #   resolution process.
-    # @param [{String => Array<Conflict>}] conflicts
-    # @return [Array<Object>] a sorted copy of `dependencies`.
-    def sort_dependencies(dependencies, activated, conflicts)
-      dependencies.sort_by do |dependency|
-        name = name_for(dependency)
-        [
-          activated.vertex_named(name).payload ? 0 : 1,
-          conflicts[name] ? 0 : 1,
-        ]
-      end
-    end
-
-    # Returns whether this dependency, which has no possible matching
-    # specifications, can safely be ignored.
-    #
-    # @param [Object] dependency
-    # @return [Boolean] whether this dependency can safely be skipped.
-    def allow_missing?(dependency)
-      false
-    end
-  end
-end