solve 3.1.1 → 4.0.0

data/lib/solve/graph.rb

@@ -67,7 +67,7 @@ module Solve
       return false unless other.is_a?(Graph)
       return false unless artifacts.size == other.artifacts.size
 
-      self_artifacts = self.artifacts
+      self_artifacts = artifacts
       other_artifacts = other.artifacts
 
       self_dependencies = self_artifacts.inject([]) do |list, artifact|
@@ -79,8 +79,8 @@ module Solve
       end.flatten
 
       self_dependencies.size == other_dependencies.size &&
-      self_artifacts.all? { |artifact| other_artifacts.include?(artifact) } &&
-      self_dependencies.all? { |dependency| other_dependencies.include?(dependency) }
+        self_artifacts.all? { |artifact| other_artifacts.include?(artifact) } &&
+        self_dependencies.all? { |dependency| other_dependencies.include?(dependency) }
     end
     alias_method :eql?, :==
   end

data/lib/solve/ruby_solver.rb

@@ -1,6 +1,7 @@
-require 'set'
-require 'molinillo'
-require_relative 'solver/serializer'
+require "set"
+require "molinillo"
+require "molinillo/modules/specification_provider"
+require_relative "solver/serializer"
 
 module Solve
   class RubySolver
@@ -14,7 +15,7 @@ module Solve
         seconds.to_i * 1_000
       end
 
-      # For optinal solver engines, this attempts to load depenencies. The
+      # For optional solver engines, this attempts to load depenencies. The
       # RubySolver is a non-optional component, so this is a no-op
       def activate
         true
@@ -45,7 +46,7 @@ module Solve
       @timeout_ms    = self.class.timeout
 
       @ui = options[:ui] # could be nil, but that's okay
-      @dependency_source = options[:dependency_source] || 'user-specified dependency'
+      @dependency_source = options[:dependency_source] || "user-specified dependency"
 
       @molinillo_graph = Molinillo::DependencyGraph.new
       @resolver = Molinillo::Resolver.new(self, self)
@@ -74,10 +75,10 @@ module Solve
 
       solved_graph = resolve_with_error_wrapping
 
-      solution =  solved_graph.map(&:payload)
+      solution = solved_graph.map(&:payload)
 
       unsorted_solution = solution.inject({}) do |stringified_soln, artifact|
-        stringified_soln[artifact.name] = artifact.version.to_s if artifact
+        stringified_soln[artifact.name] = artifact.version.to_s
         stringified_soln
       end
 
@@ -106,13 +107,13 @@ module Solve
     # Callback required by Molinillo, called when the solve starts
     # @return nil
     def before_resolution
-      @ui.say('Starting dependency resolution') if @ui
+      @ui.say("Starting dependency resolution") if @ui
     end
 
     # Callback required by Molinillo, called when the solve is complete.
     # @return nil
     def after_resolution
-      @ui.say('Finished dependency resolution') if @ui
+      @ui.say("Finished dependency resolution") if @ui
     end
 
     # Callback required by Molinillo, called when resolving every progress_rate
@@ -123,32 +124,22 @@ module Solve
 
     # Callback required by Molinillo, gives debug information about the solution
     # @return nil
-    def debug(current_resolver_depth)
+    def debug(current_resolver_depth = 0)
       # debug info will be returned if you call yield here, but it seems to be
       # broken in current Molinillo
       @ui.say(yield) if @ui
     end
 
-    # Callback required by Molinillo
-    # @return [String] the dependency's name
-    def name_for(dependency)
-      dependency.name
-    end
-
-    # Callback required by Molinillo
-    # @return [Array<Solve::Dependency>] the dependencies sorted by preference.
-    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,
-          activated.vertex_named(name).payload ? 0 : graph.versions(dependency.name).count,
-        ]
-      end
-    end
+    include Molinillo::SpecificationProvider
 
     # Callback required by Molinillo
+    # 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<Solve::Artifact>] the artifacts that match the dependency.
     def search_for(dependency)
       # This array gets mutated by Molinillo; it's okay because sort returns a
@@ -157,29 +148,101 @@ module Solve
     end
 
     # Callback required by Molinillo
-    # @return [Boolean]
+    # 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<Solve::Dependency>] the dependencies of the given artifact
+    def dependencies_for(specification)
+      specification.dependencies
+    end
+
+    # Callback required by Molinillo
+    # 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)
-      requirement.constraint.satisfies?(spec.version)
+      version = spec.version
+      return false unless requirement.constraint.satisfies?(version)
+      shared_possibility_versions = possibility_versions(requirement, activated)
+      return false if !shared_possibility_versions.empty? && !shared_possibility_versions.include?(version)
+      true
+    end
+
+    # Searches the current dependency graph to find previously activated
+    # requirements for the current artifact.
+    #
+    # @param [Object] requirement
+    # @param [DependencyGraph] activated the current dependency graph in the
+    #   resolution process.
+    # @return [Array<Semverse::Version> the list of currently activated versions
+    # of this requirement
+    def possibility_versions(requirement, activated)
+      activated.vertices.values.flat_map do |vertex|
+
+        next unless vertex.payload
+
+        next unless vertex.name == requirement.name
+
+        if vertex.payload.respond_to?(:possibilities)
+          vertex.payload.possibilities.map(&:version)
+        else
+          vertex.payload.version
+        end
+      end.compact
     end
+    private :possibility_versions
 
     # Callback required by Molinillo
-    # @return [Array<Solve::Dependency>] the dependencies of the given artifact
-    def dependencies_for(specification)
-      specification.dependencies
+    # 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.name
     end
 
+    # Callback required by Molinillo
     # @return [String] the name of the source of explicit dependencies, i.e.
     #   those passed to {Resolver#resolve} directly.
     def name_for_explicit_dependency_source
       @dependency_source
     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'
+    # Callback required by Molinillo
+    # 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<Solve::Dependency>] the dependencies sorted by preference.
+    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,
+          search_for(dependency).count,
+        ]
+      end
     end
 
+    # Callback required by Molinillo
     # Returns whether this dependency, which has no possible matching
     # specifications, can safely be ignored.
     #
@@ -191,35 +254,35 @@ module Solve
 
     private
 
-      def resolve_with_error_wrapping
-        @resolver.resolve(demands, @molinillo_graph)
-      rescue Molinillo::VersionConflict, Molinillo::CircularDependencyError => e
-        raise Solve::Errors::NoSolutionError.new(e.message)
-      end
+    def resolve_with_error_wrapping
+      @resolver.resolve(demands, @molinillo_graph)
+    rescue Molinillo::VersionConflict, Molinillo::CircularDependencyError => e
+      raise Solve::Errors::NoSolutionError.new(e.message)
+    end
 
-      def build_sorted_solution(unsorted_solution)
-        nodes = Hash.new
-        unsorted_solution.each do |name, version|
-          nodes[name] = @graph.artifact(name, version).dependencies.map(&:name)
-        end
+    def build_sorted_solution(unsorted_solution)
+      nodes = Hash.new
+      unsorted_solution.each do |name, version|
+        nodes[name] = @graph.artifact(name, version).dependencies.map(&:name)
+      end
 
-        # Modified from http://ruby-doc.org/stdlib-1.9.3/libdoc/tsort/rdoc/TSort.html
-        class << nodes
-          include TSort
-          alias tsort_each_node each_key
-          def tsort_each_child(node, &block)
-            fetch(node).each(&block)
-          end
-        end
-        begin
-          sorted_names = nodes.tsort
-        rescue TSort::Cyclic => e
-          raise Solve::Errors::UnsortableSolutionError.new(e, unsorted_solution)
+      # Modified from http://ruby-doc.org/stdlib-1.9.3/libdoc/tsort/rdoc/TSort.html
+      class << nodes
+        include TSort
+        alias tsort_each_node each_key
+        def tsort_each_child(node, &block)
+          fetch(node).each(&block)
         end
+      end
+      begin
+        sorted_names = nodes.tsort
+      rescue TSort::Cyclic => e
+        raise Solve::Errors::UnsortableSolutionError.new(e, unsorted_solution)
+      end
 
-        sorted_names.map do |artifact|
-          [artifact, unsorted_solution[artifact]]
-        end
+      sorted_names.map do |artifact|
+        [artifact, unsorted_solution[artifact]]
       end
+    end
   end
 end

data/lib/solve/solver/serializer.rb

@@ -1,5 +1,5 @@
-require 'json'
-require 'solve/graph'
+require "json"
+require "solve/graph"
 
 module Solve
 
@@ -58,71 +58,71 @@ module Solve
 
       private
 
-        def format_graph(graph)
-          artifacts = graph.artifacts.inject([]) do |list, artifact|
-            list << format_artifact(artifact)
-          end
-          { "graph" => artifacts }
+      def format_graph(graph)
+        artifacts = graph.artifacts.inject([]) do |list, artifact|
+          list << format_artifact(artifact)
         end
+        { "graph" => artifacts }
+      end
 
-        def format_artifact(artifact)
-          dependencies = artifact.dependencies.inject([]) do |list, dependency|
-            list << format_dependency(dependency)
-          end
-
-          {
-            "name" => artifact.name,
-            "version" => artifact.version.to_s,
-            "dependencies" => dependencies
-          }
+      def format_artifact(artifact)
+        dependencies = artifact.dependencies.inject([]) do |list, dependency|
+          list << format_dependency(dependency)
         end
 
-        def format_dependency(dependency)
-          {
-            "name" => dependency.name,
-            "constraint" => dependency.constraint.to_s
-          }
-        end
+        {
+          "name" => artifact.name,
+          "version" => artifact.version.to_s,
+          "dependencies" => dependencies,
+        }
+      end
 
-        def format_demands(demands)
-          demands_list = demands.inject([]) do |list, demand|
-            list << format_demand(demand)
-          end
-          { "demands" => demands_list }
-        end
+      def format_dependency(dependency)
+        {
+          "name" => dependency.name,
+          "constraint" => dependency.constraint.to_s,
+        }
+      end
 
-        def format_demand(demand)
-          {
-            "name" => demand[0],
-            "constraint" => demand[1]
-          }
+      def format_demands(demands)
+        demands_list = demands.inject([]) do |list, demand|
+          list << format_demand(demand)
         end
+        { "demands" => demands_list }
+      end
 
-        def load_graph(artifacts_list)
-          graph = Solve::Graph.new
-          artifacts_list.each do |artifact_spec|
-            load_artifact(graph, artifact_spec)
-          end
-          graph
-        end
+      def format_demand(demand)
+        {
+          "name" => demand[0],
+          "constraint" => demand[1],
+        }
+      end
 
-        def load_artifact(graph, artifact_spec)
-          artifact = graph.artifact(artifact_spec["name"], artifact_spec["version"])
-          artifact_spec["dependencies"].each do |dependency_spec|
-            load_dependency(artifact, dependency_spec)
-          end
-          artifact
+      def load_graph(artifacts_list)
+        graph = Solve::Graph.new
+        artifacts_list.each do |artifact_spec|
+          load_artifact(graph, artifact_spec)
         end
+        graph
+      end
 
-        def load_dependency(artifact, dependency_spec)
-          artifact.depends(dependency_spec["name"], dependency_spec["constraint"])
+      def load_artifact(graph, artifact_spec)
+        artifact = graph.artifact(artifact_spec["name"], artifact_spec["version"])
+        artifact_spec["dependencies"].each do |dependency_spec|
+          load_dependency(artifact, dependency_spec)
         end
+        artifact
+      end
 
-        def load_demands(demand_specs)
-          demand_specs.inject([]) do |list, demand_spec|
-            list << [demand_spec["name"], demand_spec["constraint"]]
-          end
+      def load_dependency(artifact, dependency_spec)
+        artifact.depends(dependency_spec["name"], dependency_spec["constraint"])
+      end
+
+      def load_demands(demand_specs)
+        demand_specs.inject([]) do |list, demand_spec|
+          list << [demand_spec["name"], demand_spec["constraint"]]
         end
+      end
     end
   end
 end

data/lib/solve/version.rb

@@ -1,3 +1,3 @@
 module Solve
-  VERSION = "3.1.1"
+  VERSION = "4.0.0"
 end

data/solve.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/solve/version', __FILE__)
+require File.expand_path("../lib/solve/version", __FILE__)
 
 Gem::Specification.new do |s|
   s.authors               = ["Jamie Winsor", "Andrew Garson", "Thibaud Guillaume-Gentil"]
@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.homepage              = "https://github.com/berkshelf/solve"
   s.license               = "Apache 2.0"
   s.files                 = `git ls-files`.split($\)
-  s.executables           = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.executables           = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   s.test_files            = s.files.grep(%r{^spec/})
   s.name                  = "solve"
   s.require_paths         = ["lib"]
@@ -17,10 +17,10 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 2.1.0"
 
   s.add_dependency "semverse",     ">= 1.1", "< 3.0"
-  s.add_dependency "molinillo",    ">= 0.5"
+  s.add_dependency "molinillo",    "~> 0.6"
 
-  s.add_development_dependency 'thor'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'spork'
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency "thor"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "spork"
+  s.add_development_dependency "rspec"
 end