bundler 1.12.6 → 1.13.0.pre.1

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module Bundler::Molinillo
+  module Delegates
+    # Delegates all {Bundler::Molinillo::SpecificationProvider} methods to a
+    # `#specification_provider` property.
+    module SpecificationProvider
+      # (see Bundler::Molinillo::SpecificationProvider#search_for)
+      def search_for(dependency)
+        with_no_such_dependency_error_handling do
+          specification_provider.search_for(dependency)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#dependencies_for)
+      def dependencies_for(specification)
+        with_no_such_dependency_error_handling do
+          specification_provider.dependencies_for(specification)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#requirement_satisfied_by?)
+      def requirement_satisfied_by?(requirement, activated, spec)
+        with_no_such_dependency_error_handling do
+          specification_provider.requirement_satisfied_by?(requirement, activated, spec)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#name_for)
+      def name_for(dependency)
+        with_no_such_dependency_error_handling do
+          specification_provider.name_for(dependency)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#name_for_explicit_dependency_source)
+      def name_for_explicit_dependency_source
+        with_no_such_dependency_error_handling do
+          specification_provider.name_for_explicit_dependency_source
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#name_for_locking_dependency_source)
+      def name_for_locking_dependency_source
+        with_no_such_dependency_error_handling do
+          specification_provider.name_for_locking_dependency_source
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#sort_dependencies)
+      def sort_dependencies(dependencies, activated, conflicts)
+        with_no_such_dependency_error_handling do
+          specification_provider.sort_dependencies(dependencies, activated, conflicts)
+        end
+      end
+
+      # (see Bundler::Molinillo::SpecificationProvider#allow_missing?)
+      def allow_missing?(dependency)
+        with_no_such_dependency_error_handling do
+          specification_provider.allow_missing?(dependency)
+        end
+      end
+
+      private
+
+      # Ensures any raised {NoSuchDependencyError} has its
+      # {NoSuchDependencyError#required_by} set.
+      # @yield
+      def with_no_such_dependency_error_handling
+        yield
+      rescue NoSuchDependencyError => error
+        if state
+          vertex = activated.vertex_named(name_for(error.dependency))
+          error.required_by += vertex.incoming_edges.map { |e| e.origin.name }
+          error.required_by << name_for_explicit_dependency_source unless vertex.explicit_requirements.empty?
+        end
+        raise
+      end
+    end
+  end
+end

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

@@ -2,6 +2,9 @@
 require 'set'
 require 'tsort'
 
+require 'bundler/vendor/molinillo/lib/molinillo/dependency_graph/log'
+require 'bundler/vendor/molinillo/lib/molinillo/dependency_graph/vertex'
+
 module Bundler::Molinillo
   # A directed acyclic graph that is tuned to hold named dependencies
   class DependencyGraph
@@ -10,15 +13,16 @@ module Bundler::Molinillo
     # 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 TSort
 
-    # @visibility private
+    # @!visibility private
     alias tsort_each_node each
 
-    # @visibility private
+    # @!visibility private
     def tsort_each_child(vertex, &block)
       vertex.successors.each(&block)
     end
@@ -44,9 +48,27 @@ module Bundler::Molinillo
     #   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}
@@ -55,6 +77,7 @@ module Bundler::Molinillo
     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|
@@ -75,6 +98,22 @@ module Bundler::Molinillo
       "#{self.class}:#{vertices.values.inspect}"
     end
 
+    # @return [String] Returns a dot format representation of the graph
+    def to_dot
+      dot_vertices = []
+      dot_edges = []
+      vertices.each do |n, v|
+        dot_vertices << "  #{n} [label=\"{#{n}|#{v.payload}}\"]"
+        v.outgoing_edges.each do |e|
+          dot_edges << "  #{e.origin.name} -> #{e.destination.name} [label=\"#{e.requirement}\"]"
+        end
+      end
+      dot_vertices.sort!
+      dot_edges.sort!
+      dot = dot_vertices.unshift('digraph G {').push('') + dot_edges.push('}')
+      dot.join("\n")
+    end
+
     # @return [Boolean] whether the two dependency graphs are equal, determined
     #   by a recursive traversal of each {#root_vertices} and its
     #   {Vertex#successors}
@@ -93,12 +132,9 @@ module Bundler::Molinillo
     # @param [Object] requirement the requirement that is requiring the child
     # @return [void]
     def add_child_vertex(name, payload, parent_names, requirement)
-      vertex = add_vertex(name, payload)
+      root = !parent_names.delete(nil) { true }
+      vertex = add_vertex(name, payload, root)
       parent_names.each do |parent_name|
-        unless parent_name
-          vertex.root = true
-          next
-        end
         parent_node = vertex_named(parent_name)
         add_edge(parent_node, vertex, requirement)
       end
@@ -110,10 +146,7 @@ module Bundler::Molinillo
     # @param [Object] payload
     # @return [Vertex] the vertex that was added to `self`
     def add_vertex(name, payload, root = false)
-      vertex = vertices[name] ||= Vertex.new(name, payload)
-      vertex.payload ||= payload
-      vertex.root ||= root
-      vertex
+      log.add_vertex(self, name, payload, root)
     end
 
     # Detaches the {#vertex_named} `name` {Vertex} from the graph, recursively
@@ -121,16 +154,7 @@ module Bundler::Molinillo
     # @param [String] name
     # @return [void]
     def detach_vertex_named(name)
-      return unless vertex = vertices.delete(name)
-      vertex.outgoing_edges.each do |e|
-        v = e.destination
-        v.incoming_edges.delete(e)
-        detach_vertex_named(v.name) unless v.root? || v.predecessors.any?
-      end
-      vertex.incoming_edges.each do |e|
-        v = e.origin
-        v.outgoing_edges.delete(e)
-      end
+      log.detach_vertex_named(self, name)
     end
 
     # @param [String] name
@@ -158,134 +182,22 @@ module Bundler::Molinillo
       add_edge_no_circular(origin, destination, 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)
-      edge = Edge.new(origin, destination, requirement)
-      origin.outgoing_edges << edge
-      destination.incoming_edges << edge
-      edge
-    end
-
-    # 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 [Arrary<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
-        @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
-      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 [Array<Vertex>] the vertices of {#graph} where `self` is a
-      #   {#descendent?}
-      def recursive_predecessors
-        vertices = predecessors
-        vertices += vertices.map(&:recursive_predecessors).flatten(1)
-        vertices.uniq!
-        vertices
-      end
-
-      # @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 [Array<Vertex>] the vertices of {#graph} where `self` is an
-      #   {#ancestor?}
-      def recursive_successors
-        vertices = successors
-        vertices += vertices.map(&:recursive_successors).flatten(1)
-        vertices.uniq!
-        vertices
-      end
-
-      # @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)
-        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)
-        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 true iff there is a path following edges within this {#graph}
-      def path_to?(other)
-        equal?(other) || successors.any? { |v| v.path_to?(other) }
-      end
-
-      alias descendent? path_to?
-
-      # Is there a path from `other` to `self` following edges in the
-      # dependency graph?
-      # @return true iff there is a path following edges within this {#graph}
-      def ancestor?(other)
-        other.path_to?(self)
-      end
-
-      alias is_reachable_from? ancestor?
+      log.add_edge_no_circular(self, origin.name, destination.name, requirement)
     end
   end
 end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Bundler::Molinillo
+  class DependencyGraph
+    # An action that modifies a {DependencyGraph} that is reversible.
+    # @abstract
+    class Action
+      # rubocop:disable Lint/UnusedMethodArgument
+
+      # @return [Symbol] The name of the action.
+      def self.name
+        raise 'Abstract'
+      end
+
+      # Performs the action on the given graph.
+      # @param  [DependencyGraph] graph the graph to perform the action on.
+      # @return [Void]
+      def up(graph)
+        raise 'Abstract'
+      end
+
+      # Reverses the action on the given graph.
+      # @param  [DependencyGraph] graph the graph to reverse the action on.
+      # @return [Void]
+      def down(graph)
+        raise 'Abstract'
+      end
+
+      # @return [Action,Nil] The previous action
+      attr_accessor :previous
+
+      # @return [Action,Nil] The next action
+      attr_accessor :next
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'bundler/vendor/molinillo/lib/molinillo/dependency_graph/action'
+module Bundler::Molinillo
+  class DependencyGraph
+    # @!visibility private
+    # (see DependencyGraph#add_edge_no_circular)
+    class AddEdgeNoCircular < Action
+      # @!group Action
+
+      # (see Action.name)
+      def self.name
+        :add_vertex
+      end
+
+      # (see Action#up)
+      def up(graph)
+        edge = make_edge(graph)
+        edge.origin.outgoing_edges << edge
+        edge.destination.incoming_edges << edge
+        edge
+      end
+
+      # (see Action#down)
+      def down(graph)
+        edge = make_edge(graph)
+        edge.origin.outgoing_edges.delete(edge)
+        edge.destination.incoming_edges.delete(edge)
+      end
+
+      # @!group AddEdgeNoCircular
+
+      # @return [String] the name of the origin of the edge
+      attr_reader :origin
+
+      # @return [String] the name of the destination of the edge
+      attr_reader :destination
+
+      # @return [Object] the requirement that the edge represents
+      attr_reader :requirement
+
+      # @param  [DependencyGraph] graph the graph to find vertices from
+      # @return [Edge] The edge this action adds
+      def make_edge(graph)
+        Edge.new(graph.vertex_named(origin), graph.vertex_named(destination), requirement)
+      end
+
+      # Initialize an action to add an edge to a dependency graph
+      # @param [String] origin the name of the origin of the edge
+      # @param [String] destination the name of the destination of the edge
+      # @param [Object] requirement the requirement that the edge represents
+      def initialize(origin, destination, requirement)
+        @origin = origin
+        @destination = destination
+        @requirement = requirement
+      end
+    end
+  end
+end