solve 0.2.1 → 0.3.0

data/.travis.yml

@@ -0,0 +1,5 @@
+script: "bundle exec thor spec"
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3

data/README.md

@@ -1,4 +1,7 @@
 # Solve
+[![Build Status](https://secure.travis-ci.org/reset/solve.png?branch=master)](http://travis-ci.org/reset/solve)
+[![Dependency Status](https://gemnasium.com/reset/solve.png?travis)](https://gemnasium.com/reset/solve)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/reset/solve)
 
 A Ruby constraint solver
 
@@ -20,20 +23,18 @@ Now add another artifact that has a dependency
 
     graph.artifacts("mysql", "1.2.4").depends("openssl", "~> 1.0.0")
 
-Setup some demands
+Dependencies can be chained, too
 
-    graph.demands('nginx', '>= 0.100.0')
+    graph.artifacts("ntp", "1.0.0").depends("build-essential").depends("yum")
 
-And now solve the graph
+And now solve the graph with some demands
 
-    Solve.it!(graph)
+    Solve.it!(graph, ['nginx', '>= 0.100.0'])
 
-### Removing an artifact, demand, or dependency
+### Removing an artifact, or dependency from the graph
 
     graph.artifacts("nginx", "1.0.0").delete
 
-    graph.demands('nginx', '>= 0.100.0').delete
-
     artifact.dependencies("nginx", "~> 1.0.0").delete
 
 ## Authors

data/lib/solve.rb

@@ -1,7 +1,6 @@
 require 'solve/errors'
-require 'solve/core_ext'
-require 'dep_selector'
 
+# @author Jamie Winsor <jamie@vialstudios.com>
 module Solve
   autoload :Version, 'solve/version'
   autoload :Artifact, 'solve/artifact'
@@ -9,39 +8,21 @@ module Solve
   autoload :Dependency, 'solve/dependency'
   autoload :Graph, 'solve/graph'
   autoload :Demand, 'solve/demand'
+  autoload :Solver, 'solve/solver'
 
   class << self
-    include DepSelector
-
-    # @param [Solve::Graph] graph
+    # A quick solve. Given the "world" as we know it (the graph) and a list of
+    # requirements (demands) which must be met. Return me the best solution of
+    # artifacts and verisons that I should use.
     #
-    # @return [Hash]
-    def it(graph)
-      it!(graph)
-    rescue NoSolutionError
-      nil
-    end
-
     # @param [Solve::Graph] graph
+    # @param [Array<Solve::Demand>, Array<String, String>] demands
+    #
+    # @raise [NoSolutionError]
     #
     # @return [Hash]
-    def it!(graph)
-      dep_graph = graph.send(:dep_graph)
-      selector = Selector.new(dep_graph)
-
-      solution_constraints = graph.demands.collect do |demand|
-        SolutionConstraint.new(dep_graph.package(demand.name), DepSelector::VersionConstraint.new(demand.constraint.to_s))
-      end
-
-      solution = quietly { selector.find_solution(solution_constraints) }
-
-      {}.tap do |artifacts|
-        solution.each do |name, constraint|
-          artifacts[name] = constraint.to_s
-        end
-      end
-    rescue DepSelector::Exceptions::InvalidSolutionConstraints
-      raise NoSolutionError
+    def it!(graph, demands)
+      Solver.new(graph, demands).resolve
     end
   end
 end

data/lib/solve/artifact.rb

@@ -1,7 +1,21 @@
 module Solve
+  # @author Jamie Winsor <jamie@vialstudios.com>
   class Artifact
+    include Comparable
+
+    # A reference to the graph this artifact belongs to
+    #
+    # @return [Solve::Graph]
     attr_reader :graph
+
+    # The name of the artifact
+    #
+    # @return [String]
     attr_reader :name
+
+    # The version of this artifact
+    #
+    # @return [Solve::Version]
     attr_reader :version
 
     # @param [Solve::Graph] graph
@@ -14,73 +28,50 @@ module Solve
       @dependencies = Hash.new
     end
 
-    # @overload dependencies(name, constraint)
-    #   Return the Solve::Dependency from the collection of
-    #   dependencies with the given name and constraint.
+    # Return the Solve::Dependency from the collection of
+    # dependencies with the given name and constraint.
     #
-    #   @param [#to_s]
-    #   @param [Solve::Constraint, #to_s]
+    # @param [#to_s] name
+    # @param [Solve::Constraint, #to_s] constraint
     #
-    #   @return [Solve::Dependency]
-    # @overload dependencies
-    #   Return the collection of dependencies
+    # @example adding dependencies
+    #   artifact.depends("nginx") => <#Dependency: @name="nginx", @constraint=">= 0.0.0">
+    #   artifact.depends("ntp", "= 1.0.0") => <#Dependency: @name="ntp", @constraint="= 1.0.0">
     #
-    #   @return [Array<Solve::Dependency>]
-    def dependencies(*args)
-      if args.empty?
-        return dependency_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"
-
+    # @example chaining dependencies
+    #   artifact.depends("nginx").depends("ntp")
+    #
+    # @return [Solve::Artifact]
+    def depends(name, constraint = ">= 0.0.0")
       if name.nil?
         raise ArgumentError, "A name must be specified. You gave: #{args}."
       end
 
       dependency = Dependency.new(self, name, constraint)
       add_dependency(dependency)
-    end
-    alias_method :depends, :dependencies
 
-    # Add a Solve::Dependency to the collection of dependencies 
-    # and return the added Solve::Dependency. No change will be
-    # made if the dependency is already a member of the collection.
-    #
-    # @param [Solve::Dependency] dependency
-    #
-    # @return [Solve::Dependency]
-    def add_dependency(dependency)
-      unless has_dependency?(dependency)
-        dep_graph = graph.send(:dep_graph)
-        a = dep_graph.package(self.name).add_version(DepSelector::Version.new(self.version.to_s))
-        dep_pack = dep_graph.package(dependency.name)
-        a.dependencies << DepSelector::Dependency.new(dep_pack, DepSelector::VersionConstraint.new(dependency.constraint.to_s))
-        @dependencies[dependency.to_s] = dependency
-      end
-
-      dependency
+      self
     end
 
-    # @param [Solve::Dependency] dependency
+    # Return the collection of dependencies on this instance of artifact
     #
-    # @return [Solve::Dependency, nil]
-    def remove_dependency(dependency)
-      if has_dependency?(dependency)
-        @dependencies.delete(dependency.to_s)
-      end
+    # @return [Array<Solve::Dependency>]
+    def dependencies
+      @dependencies.collect { |name, dependency| dependency }
     end
 
-    # @param [Solve::Dependency] dependency
+    # Retrieve the dependency from the artifact with the matching name and constraint
     #
-    # @return [Boolean]
-    def has_dependency?(dependency)
-      @dependencies.has_key?(dependency.to_s)
+    # @param [#to_s] name
+    # @param [#to_s] constraint
+    #
+    # @return [Solve::Artifact, nil]
+    def get_dependency(name, constraint)
+      @dependencies.fetch(Graph.dependency_key(name, constraint), nil)
     end
 
+    # Remove this artifact from the graph it belongs to
+    #
     # @return [Solve::Artifact, nil]
     def delete
       unless graph.nil?
@@ -94,11 +85,59 @@ module Solve
       "#{name}-#{version}"
     end
 
+    # @param [Object] other
+    #
+    # @return [Boolean]
+    def ==(other)
+      other.is_a?(self.class) &&
+        self.name == other.name &&
+        self.version == other.version
+    end
+    alias_method :eql?, :==
+
+    # @param [Solve::Version] other
+    #
+    # @return [Integer]
+    def <=>(other)
+      self.version <=> other.version
+    end
+
     private
 
-      # @return [Array<Solve::Dependency>]
-      def dependency_collection
-        @dependencies.collect { |name, dependency| dependency }
+      # Add a Solve::Dependency to the collection of dependencies 
+      # and return the added Solve::Dependency. No change will be
+      # made if the dependency is already a member of the collection.
+      #
+      # @param [Solve::Dependency] dependency
+      #
+      # @return [Solve::Dependency]
+      def add_dependency(dependency)
+        unless has_dependency?(dependency.name, dependency.constraint)
+          @dependencies[Graph.key_for(dependency)] = dependency
+        end
+
+        get_dependency(dependency.name, dependency.constraint)
+      end
+
+      # Remove the matching dependency from the artifact
+      #
+      # @param [Solve::Dependency] dependency
+      #
+      # @return [Solve::Dependency, nil]
+      def remove_dependency(dependency)
+        if has_dependency?(dependency)
+          @dependencies.delete(Graph.key_for(dependency))
+        end
+      end
+
+      # Check if the artifact has a dependency with the matching name and constraint
+      #
+      # @param [#to_s] name
+      # @param [#to_s] constraint
+      #
+      # @return [Boolean]
+      def has_dependency?(name, constraint)
+        @dependencies.has_key?(Graph.dependency_key(name, constraint))
       end
   end
 end

data/lib/solve/constraint.rb

@@ -1,10 +1,29 @@
 module Solve
+  # @author Jamie Winsor <jamie@vialstudios.com>
   class Constraint
     class << self
+      # Split a constraint string into an Array of two elements. The first
+      # element being the operator and second being the version string.
+      #
+      # If the given string does not contain a constraint operator then (=)
+      # will be used.
+      #
+      # If the given string does not contain a valid version string then
+      # nil will be returned.
+      #
       # @param [#to_s] string
       #
+      # @example splitting a string with a constraint operator and valid version string
+      #   Constraint.split(">= 1.0.0") => [ ">=", "1.0.0" ]
+      #
+      # @example splitting a string without a constraint operator
+      #   Constraint.split("0.0.0") => [ "=", "1.0.0" ]
+      #
+      # @example splitting a string without a valid version string
+      #   Constraint.split("hello") => nil
+      #
       # @return [Array, nil]
-      def parse(string)
+      def split(string)
         if string =~ /^[0-9]/
           op = "="
           ver = string
@@ -16,40 +35,108 @@ module Solve
 
         [ op, ver ]
       end
+
+      # @param [Solve::Constraint] constraint
+      # @param [Solve::Version] target_version
+      #
+      # @return [Boolean]
+      def compare_equal(constraint, target_version)
+        target_version == constraint.version
+      end
+
+      # @param [Solve::Constraint] constraint
+      # @param [Solve::Version] target_version
+      #
+      # @return [Boolean]
+      def compare_gt(constraint, target_version)
+        target_version > constraint.version
+      end
+
+      # @param [Solve::Constraint] constraint
+      # @param [Solve::Version] target_version
+      #
+      # @return [Boolean]
+      def compare_lt(constraint, target_version)
+        target_version < constraint.version
+      end
+
+      # @param [Solve::Constraint] constraint
+      # @param [Solve::Version] target_version
+      #
+      # @return [Boolean]
+      def compare_gte(constraint, target_version)
+        target_version >= constraint.version
+      end
+
+      # @param [Solve::Constraint] constraint
+      # @param [Solve::Version] target_version
+      #
+      # @return [Boolean]
+      def compare_lte(constraint, target_version)
+        target_version <= constraint.version
+      end
+
+      # @param [Solve::Constraint] constraint
+      # @param [Solve::Version] target_version
+      #
+      # @return [Boolean]
+      def compare_aprox(constraint, target_version)
+        unless constraint.patch.nil?
+          target_version.patch >= constraint.patch &&
+            target_version.minor == constraint.minor &&
+            target_version.major == constraint.major
+        else
+          target_version.minor >= constraint.minor &&
+            target_version.major == constraint.major
+        end
+      end
     end
 
-    OPERATORS = [
-      "=",
-      ">",
-      "<",
-      ">=",
-      "<=",
-      "~>"
-    ]
-    REGEXP = /^(#{OPERATORS.join('|')}) (.+)$/
+    OPERATORS = {
+      "=" => method(:compare_equal),
+      ">" => method(:compare_gt),
+      "<" => method(:compare_lt),
+      ">=" => method(:compare_gte),
+      "<=" => method(:compare_lte),
+      "~>" => method(:compare_aprox)
+    }.freeze
+
+    REGEXP = /^(#{OPERATORS.keys.join('|')}) (.+)$/
 
     attr_reader :operator
-    attr_reader :version
+    attr_reader :major
+    attr_reader :minor
+    attr_reader :patch
 
     # @param [#to_s] constraint
     def initialize(constraint = ">= 0.0.0")
-      @operator, ver_str = self.class.parse(constraint)
+      @operator, ver_str = self.class.split(constraint)
       if @operator.nil? || ver_str.nil?
-        raise InvalidConstraintFormat.new(constraint)
+        raise Errors::InvalidConstraintFormat.new(constraint)
       end
 
-      @version = Version.new(ver_str)
-      @dep_constraint = DepSelector::VersionConstraint.new(constraint)
+      @major, @minor, @patch = Version.split(ver_str)
+      @compare_fun = OPERATORS.fetch(self.operator)
+    end
+
+    # Return the Solve::Version representation of the major, minor, and patch
+    # attributes of this instance
+    #
+    # @return [Solve::Version]
+    def version
+      @version ||= Version.new([self.major, self.minor, self.patch])
     end
 
     # Returns true or false if the given version would be satisfied by
     # the version constraint.
     #
-    # @param [Version, String] version
+    # @param [#to_s] target_version
     #
     # @return [Boolean]
-    def satisfies?(version)
-      dep_constraint.include?(version)
+    def satisfies?(target_version)
+      target_version = Version.new(target_version.to_s)
+
+      @compare_fun.call(self, target_version)
     end
 
     # @param [Object] other
@@ -58,16 +145,14 @@ module Solve
     def ==(other)
       other.is_a?(self.class) &&
         self.operator == other.operator &&
-        self.version == other.version
+        self.major == other.minor &&
+        self.minor == other.minor &&
+        self.patch == other.patch
     end
     alias_method :eql?, :==
 
     def to_s
-      "#{operator} #{version}"
+      "#{operator} #{major}.#{minor}.#{patch}"
     end
-
-    private
-
-      attr_reader :dep_constraint
   end
 end