molinillo 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5b31401d705c0bd1b9839f3b560996af5339a632
-  data.tar.gz: daabc784cc8a0385da64f2befa949887c70e3502
+SHA256:
+  metadata.gz: e6828b175f84c2dae7fadfaf7c614a3a6198089a11f0e2c20defc697b1108e2b
+  data.tar.gz: b4e8a71693257b7726be5c21fee26571197b0cd69b1445bb51107aad984b0e89
 SHA512:
-  metadata.gz: 139afb59678e775ae0e93214dfa78e13f1da4b4e73a42b514ab696818cfa00947e57b16a01b4582dbbc2563c222166c3779e032e899244cebf95f4573259ee7b
-  data.tar.gz: 708818cffc500e0f686a51e6025d254150408e206d48e176b5fa97d6466bd8efcf3897ab6fc4f21602197e5c1ac56b5f623b796617741451be77f5d182126ca0
+  metadata.gz: 67df28dfe97c6a0b66d96df61e543fa917de1bd63e2ffa169d8499f62940722a72629b37fe1c7a8db4408d7dfbfc8d718ceac09956a5160c875d74db23ab15cf
+  data.tar.gz: d750b24f9a1dd5a4a2a846f00c1ef0f6e05fdff166266a9427c9918254ff991c8bc0fb7fae861ec172ac0a305942981d0c991932a282522e2bb0eb7c981a1b13

data/ARCHITECTURE.md

@@ -33,7 +33,7 @@ This stack-based approach is used because backtracking (also known as *unwinding
 13. If there is an existing, `activated` vertex for the dependency, `attempt_to_filter_existing_spec`
   - This filters the contents of the existing vertex's `PossibilitySet` by the current state's `requirement`
   - If any possibilities remain within the `PossibilitySet`, it updates the activated vertex's payload with the new, filtered state and pushes a new `DependencyState`
-  - If no possibilities remain within the `PossibilitySet` after filtering, or if the current state's `PossibilitySet` had a different set of sub-dependecy requirements to the existing vertex's `PossibilitySet`, `create_conflict` and `unwind_for_conflict`, back to the last `DependencyState` that has a chance to not generate a conflict. Go to #6
+  - If no possibilities remain within the `PossibilitySet` after filtering, or if the current state's `PossibilitySet` had a different set of sub-dependency requirements to the existing vertex's `PossibilitySet`, `create_conflict` and `unwind_for_conflict`, back to the last `DependencyState` that has a chance to not generate a conflict. Go to #6
 15. Terminate with the topmost state's dependency graph when there are no more requirements left
 16. For each vertex with a payload of allowable versions for this resolution (i.e., a `PossibilitySet`), pick a single specific version.
 
@@ -52,7 +52,7 @@ the previous unwinds that have determined our current state.
 1. First, consider the current conflict as follows:
   - Find the earliest (lowest index) set of requirements which combine to cause
   the conflict. Any non-binding requirements can be ignored, as removing them
-  would not resolve the current onflict
+  would not resolve the current conflict
   - For each binding requirement, find all the alternative possibilities that
   would relax the requirement:
     - the requirement's DependencyState might have alternative possibilities
@@ -79,7 +79,7 @@ different, smaller unwind was chosen instead):
 error as resolution is not possible.
 3b. Filter the state that we're unwinding to, in order to remove any
 possibilities we know will result in a conflict. Consider all possible unwinds
-to the chosen state (there may be several, amasssed from previous unused
+to the chosen state (there may be several, amassed from previous unused
 unwinds for different conflicts) when doing this filtering - only
 possibilities that will certainly result in *all* of those conflicts can be
 filtered out as having no chance of resolution

data/CHANGELOG.md

@@ -1,5 +1,83 @@
 # Molinillo Changelog
 
+## 0.7.0 (2020-10-21)
+
+##### Breaking
+
+* Support for Ruby 1.8.7 and 1.9.3 has been dropped, the minimum supported
+  Ruby version is now 2.0.  
+  [Samuel Giddins](https://github.com/segiddins)
+
+##### Enhancements
+
+* Circular dependency errors include the full (shortest) path between the
+  circularly-dependent vertices.  
+  [Samuel Giddins](https://github.com/segiddins)
+
+##### Bug Fixes
+
+* None.  
+
+
+## 0.6.6 (2018-08-07)
+
+##### Enhancements
+
+* Improve performance of `Vertex#path_to?`.  
+  [Samuel Giddins](https://github.com/segiddins)
+
+* Allow customization of string used to say that a version conflict has occurred
+  for a particular name by passing in the `:incompatible_version_message_for_conflict` 
+  key when constructing a version conflict message with trees.  
+  [Samuel Giddins](https://github.com/segiddins)
+
+##### Bug Fixes
+
+* None.  
+
+
+## 0.6.5 (2018-03-22)
+
+##### Enhancements
+
+* Improve performance of recursive vertex methods.  
+  [Samuel Giddins](https://github.com/segiddins)
+
+##### Bug Fixes
+
+* None.  
+
+
+## 0.6.4 (2017-10-29)
+
+##### Enhancements
+
+* Reduce memory usage during resolution by making the `Vertex#requirements`
+  array unique.  
+  [Grey Baker](https://github.com/greysteil)
+  [Jan Krutisch](https://github.com/halfbyte)
+
+##### Bug Fixes
+
+* None.  
+
+
+## 0.6.3 (2017-09-06)
+
+##### Enhancements
+
+* None.  
+
+##### Bug Fixes
+
+* Handle the case where an unwind occurs to a requirement that directly caused
+  the current conflict but could also have been unwound to directly from
+  previous conflicts. In this case, filtering must not remove any possibilities
+  that could have avoided the previous conflicts (even if they would not avoid
+  the current one).  
+  [Grey Baker](https://github.com/greysteil)
+
+
 ## 0.6.2 (2017-08-25)
 
 ##### Enhancements

data/README.md

@@ -28,8 +28,7 @@ $ gem install molinillo
 
 ## Usage
 
-See the [ARCHITECTURE](ARCHITECTURE.md) file for an overview and look at the test suite for example usage. Better documentation and examples are
-forthcoming.
+See the [ARCHITECTURE](ARCHITECTURE.md) file for an overview and look at the test suite for example usage.
 
 ## Contributing
 

data/lib/molinillo.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'molinillo/compatibility'
-require 'molinillo/gem_metadata'
-require 'molinillo/errors'
-require 'molinillo/resolver'
-require 'molinillo/modules/ui'
-require 'molinillo/modules/specification_provider'
+require_relative 'molinillo/gem_metadata'
+require_relative 'molinillo/errors'
+require_relative 'molinillo/resolver'
+require_relative 'molinillo/modules/ui'
+require_relative 'molinillo/modules/specification_provider'
 
 # Molinillo is a generic dependency resolution algorithm.
 module Molinillo

data/lib/molinillo/dependency_graph.rb

@@ -3,8 +3,8 @@
 require 'set'
 require 'tsort'
 
-require 'molinillo/dependency_graph/log'
-require 'molinillo/dependency_graph/vertex'
+require_relative 'dependency_graph/log'
+require_relative 'dependency_graph/vertex'
 
 module Molinillo
   # A directed acyclic graph that is tuned to hold named dependencies
@@ -124,6 +124,7 @@ module Molinillo
       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}
@@ -190,7 +191,7 @@ module Molinillo
     # @return [Edge] the added edge
     def add_edge(origin, destination, requirement)
       if destination.path_to?(origin)
-        raise CircularDependencyError.new([origin, destination])
+        raise CircularDependencyError.new(path(destination, origin))
       end
       add_edge_no_circular(origin, destination, requirement)
     end
@@ -219,5 +220,37 @@ module Molinillo
     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/lib/molinillo/dependency_graph/add_edge_no_circular.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'molinillo/dependency_graph/action'
+require_relative 'action'
 module Molinillo
   class DependencyGraph
     # @!visibility private

data/lib/molinillo/dependency_graph/add_vertex.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'molinillo/dependency_graph/action'
+require_relative 'action'
 module Molinillo
   class DependencyGraph
     # @!visibility private

data/lib/molinillo/dependency_graph/delete_edge.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'molinillo/dependency_graph/action'
+require_relative 'action'
 module Molinillo
   class DependencyGraph
     # @!visibility private

data/lib/molinillo/dependency_graph/detach_vertex_named.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'molinillo/dependency_graph/action'
+require_relative 'action'
 module Molinillo
   class DependencyGraph
     # @!visibility private

data/lib/molinillo/dependency_graph/log.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'molinillo/dependency_graph/add_edge_no_circular'
-require 'molinillo/dependency_graph/add_vertex'
-require 'molinillo/dependency_graph/delete_edge'
-require 'molinillo/dependency_graph/detach_vertex_named'
-require 'molinillo/dependency_graph/set_payload'
-require 'molinillo/dependency_graph/tag'
+require_relative 'add_edge_no_circular'
+require_relative 'add_vertex'
+require_relative 'delete_edge'
+require_relative 'detach_vertex_named'
+require_relative 'set_payload'
+require_relative 'tag'
 
 module Molinillo
   class DependencyGraph

data/lib/molinillo/dependency_graph/set_payload.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'molinillo/dependency_graph/action'
+require_relative 'action'
 module Molinillo
   class DependencyGraph
     # @!visibility private

data/lib/molinillo/dependency_graph/tag.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'molinillo/dependency_graph/action'
+require_relative 'action'
 module Molinillo
   class DependencyGraph
     # @!visibility private
@@ -14,11 +14,11 @@ module Molinillo
       end
 
       # (see Action#up)
-      def up(_graph)
+      def up(graph)
       end
 
       # (see Action#down)
-      def down(_graph)
+      def down(graph)
       end
 
       # @!group Tag

data/lib/molinillo/dependency_graph/vertex.rb

@@ -33,7 +33,7 @@ module Molinillo
       # @return [Array<Object>] all of the requirements that required
       #   this vertex
       def requirements
-        incoming_edges.map(&:requirement) + explicit_requirements
+        (incoming_edges.map(&:requirement) + explicit_requirements).uniq
       end
 
       # @return [Array<Edge>] the edges of {#graph} that have `self` as their
@@ -50,14 +50,25 @@ module Molinillo
         incoming_edges.map(&:origin)
       end
 
-      # @return [Array<Vertex>] the vertices of {#graph} where `self` is a
+      # @return [Set<Vertex>] the vertices of {#graph} where `self` is a
       #   {#descendent?}
       def recursive_predecessors
-        vertices = predecessors
-        vertices += Compatibility.flat_map(vertices, &:recursive_predecessors)
-        vertices.uniq!
+        _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 = Set.new)
+        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}
@@ -65,14 +76,25 @@ module Molinillo
         outgoing_edges.map(&:destination)
       end
 
-      # @return [Array<Vertex>] the vertices of {#graph} where `self` is an
+      # @return [Set<Vertex>] the vertices of {#graph} where `self` is an
       #   {#ancestor?}
       def recursive_successors
-        vertices = successors
-        vertices += Compatibility.flat_map(vertices, &:recursive_successors)
-        vertices.uniq!
+        _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 = Set.new)
+        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
@@ -108,11 +130,21 @@ module Molinillo
       # 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) }
+        _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 = Set.new)
+        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 true iff there is a path following edges within this {#graph}

data/lib/molinillo/errors.rb

@@ -18,7 +18,7 @@ module Molinillo
     # @param [Array<Object>] required_by @see {#required_by}
     def initialize(dependency, required_by = [])
       @dependency = dependency
-      @required_by = required_by
+      @required_by = required_by.uniq
       super()
     end
 
@@ -65,7 +65,7 @@ module Molinillo
     # @param [SpecificationProvider] specification_provider see {#specification_provider}
     def initialize(conflicts, specification_provider)
       pairs = []
-      Compatibility.flat_map(conflicts.values.flatten, &:requirements).each do |conflicting|
+      conflicts.values.flat_map(&:requirements).each do |conflicting|
         conflicting.each do |source, conflict_requirements|
           conflict_requirements.each do |c|
             pairs << [c, source]
@@ -80,7 +80,7 @@ module Molinillo
       @specification_provider = specification_provider
     end
 
-    require 'molinillo/delegates/specification_provider'
+    require_relative 'delegates/specification_provider'
     include Delegates::SpecificationProvider
 
     # @return [String] An error message that includes requirement trees,
@@ -101,9 +101,14 @@ module Molinillo
       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
 
       conflicts.sort.reduce(''.dup) do |o, (name, conflict)|
-        o << %(\n#{solver_name} could not find compatible versions for #{possibility_type} "#{name}":\n)
+        o << "\n" << 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)

data/lib/molinillo/gem_metadata.rb

@@ -2,5 +2,5 @@
 
 module Molinillo
   # The version of Molinillo.
-  VERSION = '0.6.2'.freeze
+  VERSION = '0.7.0'.freeze
 end

data/lib/molinillo/resolution.rb

@@ -207,7 +207,7 @@ module Molinillo
       def start_resolution
         @started_at = Time.now
 
-        handle_missing_or_push_dependency_state(initial_state)
+        push_initial_state
 
         debug { "Starting resolution (#{@started_at})\nUser-requested dependencies: #{original_requested}" }
         resolver_ui.before_resolution
@@ -218,7 +218,7 @@ module Molinillo
           next unless vertex.payload
 
           latest_version = vertex.payload.possibilities.reverse_each.find do |possibility|
-            vertex.requirements.uniq.all? { |req| requirement_satisfied_by?(req, activated, possibility) }
+            vertex.requirements.all? { |req| requirement_satisfied_by?(req, activated, possibility) }
           end
 
           activated.set_payload(vertex.name, latest_version)
@@ -238,11 +238,11 @@ module Molinillo
         debug { 'Activated: ' + Hash[activated.vertices.select { |_n, v| v.payload }].keys.join(', ') } if state
       end
 
-      require 'molinillo/state'
-      require 'molinillo/modules/specification_provider'
+      require_relative 'state'
+      require_relative 'modules/specification_provider'
 
-      require 'molinillo/delegates/resolution_state'
-      require 'molinillo/delegates/specification_provider'
+      require_relative 'delegates/resolution_state'
+      require_relative 'delegates/specification_provider'
 
       include Molinillo::Delegates::ResolutionState
       include Molinillo::Delegates::SpecificationProvider
@@ -273,10 +273,10 @@ module Molinillo
         states.last
       end
 
-      # Creates the initial state for the resolution, based upon the
+      # Creates and pushes the initial state for the resolution, based upon the
       # {#requested} dependencies
-      # @return [DependencyState] the initial state for the resolution
-      def initial_state
+      # @return [void]
+      def push_initial_state
         graph = DependencyGraph.new.tap do |dg|
           original_requested.each do |requested|
             vertex = dg.add_vertex(name_for(requested), nil, true)
@@ -285,18 +285,7 @@ module Molinillo
           dg.tag(:initial_state)
         end
 
-        requirements = sort_dependencies(original_requested, graph, {})
-        initial_requirement = requirements.shift
-        DependencyState.new(
-          initial_requirement && name_for(initial_requirement),
-          requirements,
-          graph,
-          initial_requirement,
-          possibilities_for_requirement(initial_requirement, graph),
-          0,
-          {},
-          []
-        )
+        push_state_for_requirements(original_requested, true, graph)
       end
 
       # Unwinds the states stack because a conflict has been encountered
@@ -361,7 +350,7 @@ module Molinillo
         current_detail
       end
 
-      # @param [Array<Object>] array of requirements that combine to create a conflict
+      # @param [Array<Object>] binding_requirements array of requirements that combine to create a conflict
       # @return [Array<UnwindDetails>] array of UnwindDetails that have a chance
       #    of resolving the passed requirements
       def unwind_options_for_requirements(binding_requirements)
@@ -429,7 +418,7 @@ module Molinillo
       end
 
       # @param [DependencyState] state
-      # @param [Array] array of requirements
+      # @param [Array] binding_requirements array of requirements
       # @return [Boolean] whether or not the given state has any possibilities
       #    that could satisfy the given requirements
       def conflict_fixing_possibilities?(state, binding_requirements)
@@ -444,7 +433,8 @@ module Molinillo
 
       # Filter's a state's possibilities to remove any that would not fix the
       # conflict we've just rewound from
-      # @param [UnwindDetails] details of the conflict just unwound from
+      # @param [UnwindDetails] unwind_details details of the conflict just
+      #   unwound from
       # @return [void]
       def filter_possibilities_after_unwind(unwind_details)
         return unless state && !state.possibilities.empty?
@@ -458,14 +448,18 @@ module Molinillo
 
       # Filter's a state's possibilities to remove any that would not satisfy
       # the requirements in the conflict we've just rewound from
-      # @param [UnwindDetails] details of the conflict just unwound from
+      # @param [UnwindDetails] unwind_details details of the conflict just unwound from
       # @return [void]
       def filter_possibilities_for_primary_unwind(unwind_details)
-        all_requirements = unwind_details.conflicting_requirements
+        unwinds_to_state = unused_unwind_options.select { |uw| uw.state_index == unwind_details.state_index }
+        unwinds_to_state << unwind_details
+        unwind_requirement_sets = unwinds_to_state.map(&:conflicting_requirements)
 
         state.possibilities.reject! do |possibility_set|
           possibility_set.possibilities.none? do |poss|
-            possibility_satisfies_requirements?(poss, all_requirements)
+            unwind_requirement_sets.any? do |requirements|
+              possibility_satisfies_requirements?(poss, requirements)
+            end
           end
         end
       end
@@ -487,7 +481,7 @@ module Molinillo
 
       # Filter's a state's possibilities to remove any that would (eventually)
       # create a requirement in the conflict we've just rewound from
-      # @param [UnwindDetails] details of the conflict just unwound from
+      # @param [UnwindDetails] unwind_details details of the conflict just unwound from
       # @return [void]
       def filter_possibilities_for_parent_unwind(unwind_details)
         unwinds_to_state = unused_unwind_options.select { |uw| uw.state_index == unwind_details.state_index }
@@ -496,7 +490,7 @@ module Molinillo
         primary_unwinds = unwinds_to_state.select(&:unwinding_to_primary_requirement?).uniq
         parent_unwinds = unwinds_to_state.uniq - primary_unwinds
 
-        allowed_possibility_sets = Compatibility.flat_map(primary_unwinds) do |unwind|
+        allowed_possibility_sets = primary_unwinds.flat_map do |unwind|
           states[unwind.state_index].possibilities.select do |possibility_set|
             possibility_set.possibilities.any? do |poss|
               possibility_satisfies_requirements?(poss, unwind.conflicting_requirements)
@@ -504,7 +498,7 @@ module Molinillo
           end
         end
 
-        requirements_to_avoid = Compatibility.flat_map(parent_unwinds, &:sub_dependencies_to_avoid)
+        requirements_to_avoid = parent_unwinds.flat_map(&:sub_dependencies_to_avoid)
 
         state.possibilities.reject! do |possibility_set|
           !allowed_possibility_sets.include?(possibility_set) &&
@@ -520,12 +514,12 @@ module Molinillo
 
         possible_binding_requirements = conflict.requirements.values.flatten(1).uniq
 
-        # When there’s a `CircularDependency` error the conflicting requirement
-        # (the one causing the circular) won’t be `conflict.requirement`
-        # (which won’t be for the right state, because we won’t have created it,
-        # because it’s circular).
-        # We need to make sure we have that requirement in the conflict’s list,
-        # otherwise we won’t be able to unwind properly, so we just return all
+        # When there's a `CircularDependency` error the conflicting requirement
+        # (the one causing the circular) won't be `conflict.requirement`
+        # (which won't be for the right state, because we won't have created it,
+        # because it's circular).
+        # We need to make sure we have that requirement in the conflict's list,
+        # otherwise we won't be able to unwind properly, so we just return all
         # the requirements for the conflict.
         return possible_binding_requirements if conflict.underlying_error
 
@@ -554,8 +548,8 @@ module Molinillo
       end
 
       # @param [Object] requirement we wish to check
-      # @param [Array] array of requirements
-      # @param [Array] array of possibilities the requirements will be used to filter
+      # @param [Array] possible_binding_requirements array of requirements
+      # @param [Array] possibilities array of possibilities the requirements will be used to filter
       # @return [Boolean] whether or not the given requirement is required to filter
       #    out all elements of the array of possibilities.
       def binding_requirement_in_set?(requirement, possible_binding_requirements, possibilities)
@@ -564,6 +558,7 @@ module Molinillo
         end
       end
 
+      # @param [Object] requirement
       # @return [Object] the requirement that led to `requirement` being added
       #   to the list of requirements.
       def parent_of(requirement)
@@ -573,6 +568,7 @@ module Molinillo
         parent_state.requirement
       end
 
+      # @param [String] name
       # @return [Object] the requirement that led to a version of a possibility
       #   with the given name being activated.
       def requirement_for_existing_name(name)
@@ -581,6 +577,7 @@ module Molinillo
         states.find { |s| s.name == name }.requirement
       end
 
+      # @param [Object] requirement
       # @return [ResolutionState] the state whose `requirement` is the given
       #   `requirement`.
       def find_state_for(requirement)
@@ -588,6 +585,7 @@ module Molinillo
         states.find { |i| requirement == i.requirement }
       end
 
+      # @param [Object] underlying_error
       # @return [Conflict] a {Conflict} that reflects the failure to activate
       #   the {#possibility} in conjunction with the current {#state}
       def create_conflict(underlying_error = nil)
@@ -624,6 +622,7 @@ module Molinillo
         vertex.requirements.map { |r| requirement_tree_for(r) }
       end
 
+      # @param [Object] requirement
       # @return [Array<Object>] the list of requirements that led to
       #   `requirement` being required.
       def requirement_tree_for(requirement)
@@ -669,9 +668,8 @@ module Molinillo
           attempt_to_filter_existing_spec(existing_vertex)
         else
           latest = possibility.latest_version
-          # use reject!(!satisfied) for 1.8.7 compatibility
-          possibility.possibilities.reject! do |possibility|
-            !requirement_satisfied_by?(requirement, activated, possibility)
+          possibility.possibilities.select! do |possibility|
+            requirement_satisfied_by?(requirement, activated, possibility)
           end
           if possibility.latest_version.nil?
             # ensure there's a possibility for better error messages
@@ -701,7 +699,7 @@ module Molinillo
 
       # Generates a filtered version of the existing vertex's `PossibilitySet` using the
       # current state's `requirement`
-      # @param [Object] existing vertex
+      # @param [Object] vertex existing vertex
       # @return [PossibilitySet] filtered possibility set
       def filtered_possibility_set(vertex)
         PossibilitySet.new(vertex.payload.dependencies, vertex.payload.possibilities & possibility.possibilities)
@@ -726,7 +724,7 @@ module Molinillo
       end
 
       # Requires the dependencies that the recently activated spec has
-      # @param [Object] activated_possibility the PossibilitySet that has just been
+      # @param [Object] possibility_set the PossibilitySet that has just been
       #   activated
       # @return [void]
       def require_nested_dependencies_for(possibility_set)
@@ -745,6 +743,8 @@ module Molinillo
       # Pushes a new {DependencyState} that encapsulates both existing and new
       # requirements
       # @param [Array] new_requirements
+      # @param [Boolean] requires_sort
+      # @param [Object] new_activated
       # @return [void]
       def push_state_for_requirements(new_requirements, requires_sort = true, new_activated = activated)
         new_requirements = sort_dependencies(new_requirements.uniq, new_activated, conflicts) if requires_sort
@@ -763,7 +763,8 @@ module Molinillo
 
       # Checks a proposed requirement with any existing locked requirement
       # before generating an array of possibilities for it.
-      # @param [Object] the proposed requirement
+      # @param [Object] requirement the proposed requirement
+      # @param [Object] activated
       # @return [Array] possibilities
       def possibilities_for_requirement(requirement, activated = self.activated)
         return [] unless requirement
@@ -774,7 +775,8 @@ module Molinillo
         group_possibilities(search_for(requirement))
       end
 
-      # @param [Object] the proposed requirement
+      # @param [Object] requirement the proposed requirement
+      # @param [Object] activated
       # @return [Array] possibility set containing only the locked requirement, if any
       def locked_requirement_possibility_set(requirement, activated = self.activated)
         all_possibilities = search_for(requirement)
@@ -793,8 +795,8 @@ module Molinillo
       # Build an array of PossibilitySets, with each element representing a group of
       # dependency versions that all have the same sub-dependency version constraints
       # and are contiguous.
-      # @param [Array] an array of possibilities
-      # @return [Array] an array of possibility sets
+      # @param [Array] possibilities an array of possibilities
+      # @return [Array<PossibilitySet>] an array of possibility sets
       def group_possibilities(possibilities)
         possibility_sets = []
         current_possibility_set = nil

data/lib/molinillo/resolver.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'molinillo/dependency_graph'
+require_relative 'dependency_graph'
 
 module Molinillo
   # This class encapsulates a dependency resolver.
@@ -9,7 +9,7 @@ module Molinillo
   #
   #
   class Resolver
-    require 'molinillo/resolution'
+    require_relative 'resolution'
 
     # @return [SpecificationProvider] the specification provider used
     #   in the resolution process

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: molinillo
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Samuel E. Giddins
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-08-25 00:00:00.000000000 Z
+date: 2020-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,7 +38,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - segiddins@segiddins.me
 executables: []
@@ -50,7 +50,6 @@ files:
 - LICENSE
 - README.md
 - lib/molinillo.rb
-- lib/molinillo/compatibility.rb
 - lib/molinillo/delegates/resolution_state.rb
 - lib/molinillo/delegates/specification_provider.rb
 - lib/molinillo/dependency_graph.rb
@@ -74,7 +73,7 @@ homepage: https://github.com/CocoaPods/Molinillo
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -82,17 +81,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
-signing_key: 
+rubygems_version: 3.1.3
+signing_key:
 specification_version: 4
 summary: Provides support for dependency resolution
 test_files: []
-has_rdoc: 

data/lib/molinillo/compatibility.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Molinillo
-  # Hacks needed for old Ruby versions.
-  module Compatibility
-    module_function
-
-    if [].respond_to?(:flat_map)
-      # Flat map
-      # @param [Enumerable] enum an enumerable object
-      # @block the block to flat-map with
-      # @return The enum, flat-mapped
-      def flat_map(enum, &blk)
-        enum.flat_map(&blk)
-      end
-    else
-      # Flat map
-      # @param [Enumerable] enum an enumerable object
-      # @block the block to flat-map with
-      # @return The enum, flat-mapped
-      def flat_map(enum, &blk)
-        enum.map(&blk).flatten(1)
-      end
-    end
-  end
-end