solve 0.2.1 → 0.3.0

data/lib/solve/demand.rb

@@ -1,38 +1,47 @@
 module Solve
+  # @author Jamie Winsor <jamie@vialstudios.com>
   class Demand
-    attr_reader :graph
+    # A reference to the solver this demand belongs to
+    #
+    # @return [Solve::Solver]
+    attr_reader :solver
+
+    # The name of the artifact this demand is for
+    #
+    # @return [String]
     attr_reader :name
+
+    # The acceptable constraint of the artifact this demand is for
+    #
+    # @return [Solve::Constraint]
     attr_reader :constraint
 
-    # @param [Solve::Graph] graph
+    # @param [Solve::Solver] solver
     # @param [#to_s] name
     # @param [Solve::Constraint, #to_s] constraint
-    def initialize(graph, name, constraint = nil)
-      @graph = graph
+    def initialize(solver, name, constraint = ">= 0.0.0")
+      @solver = solver
       @name = name
-
-      if constraint
-        @constraint = if constraint.is_a?(Solve::Constraint)
-          constraint
-        else
-          Constraint.new(constraint.to_s)
-        end
+      @constraint = if constraint.is_a?(Solve::Constraint)
+        constraint
+      else
+        Constraint.new(constraint.to_s)
       end
     end
 
+    # Remove this demand from the solver it belongs to
+    #
     # @return [Solve::Demand, nil]
     def delete
-      unless graph.nil?
-        result = graph.remove_demand(self)
-        @graph = nil
+      unless solver.nil?
+        result = solver.remove_demand(self)
+        @solver = nil
         result
       end
     end
 
     def to_s
-      s = "#{name}"
-      s << "(#{constraint})" if constraint
-      s
+      "#{name} (#{constraint})"
     end
   end
 end

data/lib/solve/dependency.rb

@@ -1,13 +1,25 @@
 module Solve
+  # @author Jamie Winsor <jamie@vialstudios.com>
   class Dependency
+    # A reference to the artifact this dependency belongs to
+    #
+    # @return [Solve::Artifact]
     attr_reader :artifact
+
+    # The name of the artifact this dependency represents
+    #
+    # @return [String]
     attr_reader :name
+
+    # The constraint requirement of this dependency
+    #
+    # @return [Solve::Constraint]
     attr_reader :constraint
 
     # @param [Solve::Artifact] artifact
     # @param [#to_s] name
     # @param [Solve::Constraint, #to_s] constraint
-    def initialize(artifact, name, constraint)
+    def initialize(artifact, name, constraint = ">= 0.0.0")
       @artifact = artifact
       @name = name
       @constraint = case constraint
@@ -18,6 +30,8 @@ module Solve
       end
     end
 
+    # Remove this dependency from the artifact it belongs to
+    #
     # @return [Solve::Dependency, nil]
     def delete
       unless artifact.nil?

data/lib/solve/errors.rb

@@ -1,31 +1,34 @@
 module Solve
-  class SolveError < StandardError; end
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  module Errors
+    class SolveError < StandardError; end
 
-  class InvalidVersionFormat < SolveError
-    attr_reader :version
+    class InvalidVersionFormat < SolveError
+      attr_reader :version
 
-    # @param [#to_s] version
-    def initialize(version)
-      @version = version
-    end
+      # @param [#to_s] version
+      def initialize(version)
+        @version = version
+      end
 
-    def message
-      "'#{version}' did not contain a valid version string: 'x.y.z' or 'x.y'."
+      def message
+        "'#{version}' did not contain a valid version string: 'x.y.z' or 'x.y'."
+      end
     end
-  end
 
-  class InvalidConstraintFormat < SolveError
-    attr_reader :constraint
+    class InvalidConstraintFormat < SolveError
+      attr_reader :constraint
 
-    # @param [#to_s] constraint
-    def initialize(constraint)
-      @constraint = constraint
-    end
+      # @param [#to_s] constraint
+      def initialize(constraint)
+        @constraint = constraint
+      end
 
-    def message
-      "'#{constraint}' did not contain a valid operator or a valid version string."
+      def message
+        "'#{constraint}' did not contain a valid operator or a valid version string."
+      end
     end
-  end
 
-  class NoSolutionError < SolveError; end
+    class NoSolutionError < SolveError; end
+  end
 end

data/lib/solve/gem_version.rb

@@ -1,3 +1,3 @@
 module Solve
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/solve/graph.rb

@@ -1,9 +1,48 @@
 module Solve
+  # @author Jamie Winsor <jamie@vialstudios.com>
   class Graph
+    class << self
+      # Create a key for a graph from an instance of an Artifact or Dependency
+      #
+      # @param [Solve::Artifact, Solve::Dependency] object
+      #
+      # @raise [ArgumentError] if an instance of an object of an unknown type is given
+      #
+      # @return [Symbol]
+      def key_for(object)
+        case object
+        when Solve::Artifact
+          artifact_key(object.name, object.version)
+        when Solve::Dependency
+          dependency_key(object.name, object.constraint)
+        else
+          raise ArgumentError, "Could not generate graph key for Class: #{object.class}"
+        end
+      end
+
+      # Create a key representing an artifact for an instance of Graph
+      #
+      # @param [#to_s] name
+      # @param [#to_s] version
+      #
+      # @return [Symbol]
+      def artifact_key(name, version)
+        "#{name}-#{version}".to_sym
+      end
+
+      # Create a key representing an dependency for an instance of Graph
+      #
+      # @param [#to_s] name
+      # @param [#to_s] constraint
+      #
+      # @return [Symbol]
+      def dependency_key(name, constraint)
+        "#{name}-#{constraint}".to_sym
+      end
+    end
+
     def initialize
       @artifacts = Hash.new
-      @demands = Hash.new
-      @dep_graph = DepSelector::DependencyGraph.new
     end
 
     # @overload artifacts(name, version)
@@ -36,6 +75,20 @@ module Solve
       add_artifact(artifact)
     end
 
+    # Return all the artifacts from the collection of artifacts
+    # with the given name.
+    #
+    # @param [String] name
+    #
+    # @return [Array<Solve::Artifact>]
+    def versions(name, constraint = ">= 0.0.0")
+      constraint = constraint.is_a?(Constraint) ? constraint : Constraint.new(constraint)
+
+      artifacts.select do |art|
+        art.name == name && constraint.satisfies?(art.version)
+      end
+    end
+
     # Add a Solve::Artifact to the collection of artifacts and
     # return the added Solve::Artifact. No change will be made
     # if the artifact is already a member of the collection.
@@ -44,109 +97,48 @@ module Solve
     #
     # @return [Solve::Artifact]
     def add_artifact(artifact)
-      unless has_artifact?(artifact)
-        @dep_graph.package(artifact.name).add_version(DepSelector::Version.new(artifact.version.to_s))
-        @artifacts[artifact.to_s] = artifact
+      unless has_artifact?(artifact.name, artifact.version)
+        @artifacts[self.class.key_for(artifact)] = artifact
       end
 
-      artifact
-    end
-
-    # @param [Solve::Artifact, nil] artifact
-    def remove_artifact(artifact)
-      if has_artifact?(artifact)
-        @dep_graph.packages.delete(artifact.to_s)
-        @artifacts.delete(artifact.to_s)
-      end
-    end
-
-    # @param [Solve::Artifact] artifact
-    #
-    # @return [Boolean]
-    def has_artifact?(artifact)
-      @artifacts.has_key?(artifact.to_s)
+      get_artifact(artifact.name, artifact.version)
     end
 
-    # @overload demands(name, constraint)
-    #   Return the Solve::Demand from the collection of demands
-    #   with the given name and constraint.
+    # Retrieve the artifact from the graph with the matching name and version
     #
-    #   @param [#to_s]
-    #   @param [Solve::Constraint, #to_s]
-    #
-    #   @return [Solve::Demand]
-    # @overload demands(name)
-    #   Return the Solve::Demand from the collection of demands
-    #   with the given name.
-    #
-    #   @param [#to_s]
-    #
-    #   @return [Solve::Demand]
-    # @overload demands
-    #   Return the collection of demands
+    # @param [String] name
+    # @param [Solve::Version, #to_s] version
     #
-    #   @return [Array<Solve::Demand>]
-    def demands(*args)
-      if args.empty?
-        return demand_collection
-      end
-      if args.length > 2
-        raise ArgumentError, "Unexpected number of arguments. You gave: #{args.length}. Expected: 2 or less."
-      end
-
-      name, constraint = args
-      constraint ||= ">= 0.0.0"
-
-      if name.nil?
-        raise ArgumentError, "A name must be specified. You gave: #{args}."
-      end
-
-      demand = Demand.new(self, name, constraint)
-      add_demand(demand)
+    # @return [Solve::Artifact, nil]
+    def get_artifact(name, version)
+      @artifacts.fetch(self.class.artifact_key(name, version.to_s), nil)
     end
 
-    # Add a Solve::Demand to the collection of demands and
-    # return the added Solve::Demand. No change will be made
-    # if the demand is already a member of the collection.
+    # Remove the given instance of artifact from the graph
     #
-    # @param [Solve::Demand] demand
-    #
-    # @return [Solve::Demand]
-    def add_demand(demand)
-      unless has_demand?(demand)
-        @demands[demand.to_s] = demand
-      end
-
-      demand
-    end
-    alias_method :demand, :add_demand
-
-    # @param [Solve::Demand, nil] demand
-    def remove_demand(demand)
-      if has_demand?(demand)
-        @demands.delete(demand.to_s)
+    # @param [Solve::Artifact, nil] artifact
+    def remove_artifact(artifact)
+      if has_artifact?(artifact.name, artifact.version)
+        @artifacts.delete(self.class.key_for(artifact))
       end
     end
 
-    # @param [Solve::Demand] demand
+    # Check if an artifact with a matching name and version is a member of this instance
+    # of graph
+    #
+    # @param [String] name
+    # @param [Solve::Version, #to_s] version
     #
     # @return [Boolean]
-    def has_demand?(demand)
-      @demands.has_key?(demand.to_s)
+    def has_artifact?(name, version)
+      !get_artifact(name, version).nil?
     end
 
     private
 
-      attr_reader :dep_graph
-
       # @return [Array<Solve::Artifact>]
       def artifact_collection
         @artifacts.collect { |name, artifact| artifact }
       end
-
-      # @return [Array<Solve::Demand>]
-      def demand_collection
-        @demands.collect { |name, demand| demand }
-      end
   end
 end

data/lib/solve/solver.rb

@@ -0,0 +1,246 @@
+module Solve
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class Solver
+    autoload :VariableTable, 'solve/solver/variable_table'
+    autoload :Variable, 'solve/solver/variable'
+    autoload :ConstraintTable, 'solve/solver/constraint_table'
+    autoload :ConstraintRow, 'solve/solver/constraint_row'
+
+    class << self
+      # Create a key to identify a demand on a Solver.
+      #
+      # @param [Solve::Demand] demand
+      #
+      # @raise [NoSolutionError]
+      #
+      # @return [Symbol]
+      def demand_key(demand)
+        "#{demand.name}-#{demand.constraint}".to_sym
+      end
+
+      # Returns all of the versions which satisfy all of the given constraints
+      #
+      # @param [Array<Solve::Constraint>, Array<String>] constraints
+      # @param [Array<Solve::Version>, Array<String>] versions
+      #
+      # @return [Array<Solve::Version>]
+      def satisfy_all(constraints, versions)
+        constraints = Array(constraints).collect do |con|
+          con.is_a?(Constraint) ? con : Constraint.new(con.to_s)
+        end.uniq
+
+        versions = Array(versions).collect do |ver|
+          ver.is_a?(Version) ? ver : Version.new(ver.to_s)
+        end.uniq
+
+        versions.select do |ver|
+          constraints.all? { |constraint| constraint.satisfies?(ver) }
+        end
+      end
+
+      # Return the best version from the given list of versions for the given list of constraints
+      #
+      # @param [Array<Solve::Constraint>, Array<String>] constraints
+      # @param [Array<Solve::Version>, Array<String>] versions
+      #
+      # @raise [NoSolutionError] if version matches the given constraints
+      #
+      # @return [Solve::Version]
+      def satisfy_best(constraints, versions)
+        solution = satisfy_all(constraints, versions)
+
+        if solution.empty?
+          raise Errors::NoSolutionError
+        end
+
+        solution.sort.last
+      end
+    end
+
+    # The world as we know it
+    #
+    # @return [Solve::Graph]
+    attr_reader :graph
+
+    attr_reader :domain
+    attr_reader :variable_table
+    attr_reader :constraint_table
+    attr_reader :possible_values
+
+    # @param [Solve::Graph] graph
+    # @param [Array<String>, Array<Array<String, String>>] demands
+    def initialize(graph, demands = Array.new)
+      @graph = graph
+      @domain = Hash.new
+      @demands = Hash.new
+      @possible_values = Hash.new
+      @constraint_table = ConstraintTable.new
+      @variable_table = VariableTable.new
+
+      Array(demands).each do |l_demand|
+        demands(*l_demand)
+      end
+    end
+
+    # @return [Hash]
+    def resolve
+      seed_demand_dependencies
+
+      while unbound_variable = variable_table.first_unbound
+        possible_values_for_unbound = possible_values_for(unbound_variable)
+        
+        while possible_value = possible_values_for_unbound.shift
+          possible_artifact = graph.get_artifact(unbound_variable.package, possible_value.version)
+          possible_dependencies = possible_artifact.dependencies
+          all_ok = possible_dependencies.all? { |dependency| can_add_new_constraint?(dependency) }
+          if all_ok
+            add_dependencies(possible_dependencies, possible_artifact) 
+            unbound_variable.bind(possible_value)
+            break
+          end
+        end
+
+        unless unbound_variable.bound?
+          backtrack(unbound_variable) 
+        end
+      end
+
+      {}.tap do |solution|
+        variable_table.rows.each do |variable|
+          solution[variable.package] = variable.value.version.to_s
+        end
+      end
+    end
+
+    # @overload demands(name, constraint)
+    #   Return the Solve::Demand from the collection of demands
+    #   with the given name and constraint.
+    #
+    #   @param [#to_s]
+    #   @param [Solve::Constraint, #to_s]
+    #
+    #   @return [Solve::Demand]
+    # @overload demands(name)
+    #   Return the Solve::Demand from the collection of demands
+    #   with the given name.
+    #
+    #   @param [#to_s]
+    #
+    #   @return [Solve::Demand]
+    # @overload demands
+    #   Return the collection of demands
+    #
+    #   @return [Array<Solve::Demand>]
+    def demands(*args)
+      if args.empty?
+        return demand_collection
+      end
+      if args.length > 2
+        raise ArgumentError, "Unexpected number of arguments. You gave: #{args.length}. Expected: 2 or less."
+      end
+
+      name, constraint = args
+      constraint ||= ">= 0.0.0"
+
+      if name.nil?
+        raise ArgumentError, "A name must be specified. You gave: #{args}."
+      end
+
+      demand = Demand.new(self, name, constraint)
+      add_demand(demand)
+    end
+
+    # Add a Solve::Demand to the collection of demands and
+    # return the added Solve::Demand. No change will be made
+    # if the demand is already a member of the collection.
+    #
+    # @param [Solve::Demand] demand
+    #
+    # @return [Solve::Demand]
+    def add_demand(demand)
+      unless has_demand?(demand)
+        @demands[self.class.demand_key(demand)] = demand
+      end
+
+      demand
+    end
+    alias_method :demand, :add_demand
+
+    # @param [Solve::Demand, nil] demand
+    def remove_demand(demand)
+      if has_demand?(demand)
+        @demands.delete(self.class.demand_key(demand))
+      end
+    end
+
+    # @param [Solve::Demand] demand
+    #
+    # @return [Boolean]
+    def has_demand?(demand)
+      @demands.has_key?(self.class.demand_key(demand))
+    end
+
+    private
+
+      # @return [Array<Solve::Demand>]
+      def demand_collection
+        @demands.collect { |name, demand| demand }
+      end
+
+      def seed_demand_dependencies
+        add_dependencies(demands, :root)
+      end
+
+      def can_add_new_constraint?(dependency)
+        current_binding = variable_table.find_package(dependency.name)
+        #haven't seen it before, haven't bound it yet or the binding is ok
+        current_binding.nil? || current_binding.value.nil? || dependency.constraint.satisfies?(current_binding.value.version)
+      end
+
+      def possible_values_for(variable)
+        possible_values_for_variable = possible_values[variable.package]
+        if possible_values_for_variable.nil?
+          constraints_for_variable = constraint_table.constraints_on_package(variable.package)
+          all_values_for_variable = domain[variable.package]
+          possible_values_for_variable = constraints_for_variable.inject(all_values_for_variable) do |remaining_values, constraint|
+            remaining_values.reject { |value| !constraint.satisfies?(value.version) }
+          end
+          possible_values[variable.package] = possible_values_for_variable
+        end
+        possible_values_for_variable
+      end
+
+      def add_dependencies(dependencies, source)
+        dependencies.each do |dependency|
+          variable_table.add(dependency.name, source)
+          constraint_table.add(dependency.name, dependency.constraint, source)
+          dependency_domain = graph.versions(dependency.name, dependency.constraint)
+          domain[dependency.name] = [(domain[dependency.name] || []), dependency_domain]
+            .flatten
+            .uniq
+            .sort { |left, right| right.version <=> left.version }
+        end
+      end
+
+      def reset_possible_values_for(variable)
+        possible_values[variable.package] = nil
+        possible_values_for(variable)
+      end
+
+      def backtrack(unbound_variable)
+        previous_variable = variable_table.before(unbound_variable.package)
+
+        if previous_variable.nil?
+          raise Errors::NoSolutionError
+        end
+
+        source = previous_variable.value
+        variable_table.remove_all_with_only_this_source!(source)
+        constraint_table.remove_constraints_from_source!(source)
+        previous_variable.unbind
+        variable_table.all_after(previous_variable.package).each do |variable| 
+          new_possibles = reset_possible_values_for(variable)
+        end
+      end
+  end
+end