solve 0.8.2 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0d32f1998f6ba4ceabff84d83a11c7505aa276b
-  data.tar.gz: 0df2526224af83a576fe981eebb44554ce982817
+  metadata.gz: ae30420202e6609e3ee6c924b9bb0be3eff51195
+  data.tar.gz: 253757447932569a84b96aded37c0cba007e5847
 SHA512:
-  metadata.gz: b2333d4f5015046efa4c2513c52ce05d9342430010bd361602797e22f10e2a790c6b69caafbdbab6022f429aeefe374e7d3e3059e7083f5a5619eeefea0fa2c5
-  data.tar.gz: 6d17efaaa7bfec9b40cf6afab111bb93f66fe91479402736ef454c2b3066d10cd41fa07c74defe13c74dcfb562c513b1ec55f0f30dfee6228182e6d4a366398a
+  metadata.gz: d8c10b4a7b18fd20515cf99de348923104746f5297ac56bbd03f9ff56006d05f678d742a039047f065820cea39335dd73c41d0eab6508f8890a2673027abfa3b
+  data.tar.gz: e7fff54c7b0d5801e3ae8885db96cbcd12afd86c30bf84dbdedfa68c06189bf97fcf4964815a164a125ca07b6674aa7975a55dcf0dff578c183555150ecda237

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.ruby-version
+.rspec

data/.travis.yml

@@ -1,3 +1,7 @@
+before_install:
+  - sudo apt-get update
+  - sudo apt-get install libgecode-dev
+
 script: "bundle exec thor spec"
 language: ruby
 bundler_args: --without development

data/README.md

@@ -1,6 +1,9 @@
 # Solve
-[![Gem Version](https://badge.fury.io/rb/solve.png)](http://badge.fury.io/rb/solve)
-[![Build Status](https://secure.travis-ci.org/berkshelf/solve.png?branch=master)](http://travis-ci.org/berkshelf/solve)
+[![Gem Version](http://img.shields.io/gem/v/solve.svg)][gem]
+[![Build Status](http://img.shields.io/travis/berkshelf/solve.svg)][travis]
+
+[gem]: https://rubygems.org/gems/solve
+[travis]: http://travis-ci.org/berkshelf/solve
 
 A Ruby versioning constraint solver implementing [Semantic Versioning 2.0.0](http://semver.org).
 
@@ -16,15 +19,15 @@ Create a new graph
 
 Add an artifact to the graph
 
-    graph.artifacts("nginx", "1.0.0")
+    graph.artifact("nginx", "1.0.0")
 
 Now add another artifact that has a dependency
 
-    graph.artifacts("mysql", "1.2.4-alpha.1").depends("openssl", "~> 1.0.0")
+    graph.artifact("mysql", "1.2.4-alpha.1").depends("openssl", "~> 1.0.0")
 
 Dependencies can be chained, too
 
-    graph.artifacts("ntp", "1.0.0").depends("build-essential").depends("yum")
+    graph.artifact("ntp", "1.0.0").depends("build-essential").depends("yum")
 
 And now solve the graph with some demands
 
@@ -35,12 +38,6 @@ NOTE: This will raise Solve::Errors::UnsortableSolutionError if the solution con
 
     Solve.it!(graph, ['nginx', '>= 0.100.0'], sorted: true)
 
-### Removing an artifact, or dependency from the graph
-
-    graph.artifacts("nginx", "1.0.0").delete
-
-    artifact.dependencies("nginx", "~> 1.0.0").delete
-
 ## Authors
 
 * [Jamie Winsor](https://github.com/reset) (<jamie@vialstudios.com>)

data/lib/solve.rb

@@ -1,14 +1,13 @@
+require 'semverse'
+
 module Solve
   require_relative 'solve/artifact'
-  require_relative 'solve/constraint'
   require_relative 'solve/demand'
   require_relative 'solve/dependency'
   require_relative 'solve/gem_version'
   require_relative 'solve/errors'
   require_relative 'solve/graph'
   require_relative 'solve/solver'
-  require_relative 'solve/version'
-  require_relative 'solve/tracers'
 
   class << self
     # @return [Solve::Formatter]
@@ -24,10 +23,7 @@ module Solve
     # @param [Array<Solve::Demand>, Array<String, String>] demands
     #
     # @option options [#say] :ui (nil)
-    #   a ui object for output, this will be used to output from a Solve::Tracers::HumanReadable if
-    #   no other tracer is provided in options[:tracer]
-    # @option options [AbstractTracer] :tracer (nil)
-    #   a Tracer object that is used to format and output tracing information
+    #   a ui object for output
     # @option options [Boolean] :sorted (false)
     #   should the output be a sorted list rather than a Hash
     #
@@ -35,7 +31,6 @@ module Solve
     #
     # @return [Hash]
     def it!(graph, demands, options = {})
-      @tracer = options[:tracer] || Solve::Tracers.build(options[:ui])
       Solver.new(graph, demands, options[:ui]).resolve(options)
     end
   end

data/lib/solve/artifact.rb

@@ -14,70 +14,72 @@ module Solve
 
     # The version of this artifact
     #
-    # @return [Solve::Version]
+    # @return [Semverse::Version]
     attr_reader :version
 
     # @param [Solve::Graph] graph
     # @param [#to_s] name
-    # @param [Solve::Version, #to_s] version
+    # @param [Semverse::Version, #to_s] version
     def initialize(graph, name, version)
-      @graph = graph
-      @name = name
-      @version = Version.new(version)
-      @dependencies = Hash.new
+      @graph        = graph
+      @name         = name
+      @version      = Semverse::Version.new(version)
+      @dependencies = {}
     end
 
-    # Return the Solve::Dependency from the collection of
-    # dependencies with the given name and constraint.
+    # Check if the artifact has a dependency with the matching name and
+    # constraint
     #
     # @param [#to_s] name
-    # @param [Solve::Constraint, #to_s] constraint
+    # @param [#to_s] constraint
     #
-    # @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 [Boolean]
+    def dependency?(name, constraint)
+      !dependency(name, constraint).nil?
+    end
+    alias_method :has_dependency?, :dependency?
+
+    # Retrieve the dependency from the artifact with the matching name and constraint
     #
-    # @example chaining dependencies
-    #   artifact.depends("nginx").depends("ntp")
+    # @param [#to_s] name
+    # @param [#to_s] constraint
     #
-    # @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)
-
-      self
+    # @return [Solve::Artifact, nil]
+    def dependency(name, constraint)
+      @dependencies["#{name}-#{constraint}"] = Dependency.new(self, name, constraint)
     end
 
     # Return the collection of dependencies on this instance of artifact
     #
     # @return [Array<Solve::Dependency>]
     def dependencies
-      @dependencies.collect { |name, dependency| dependency }
+      @dependencies.values
     end
 
-    # Retrieve the dependency from the artifact with the matching name and constraint
+    # Return the Solve::Dependency from the collection of
+    # dependencies with the given name and constraint.
     #
     # @param [#to_s] name
-    # @param [#to_s] constraint
+    # @param [String] 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
+    # @example Adding dependencies
+    #   artifact.depends('nginx')
+    #     #=> #<Dependency nginx (>= 0.0.0)>
+    #   artifact.depends('ntp', '= 1.0.0')
+    #     #=> #<Dependency ntp (= 1.0.0)>
     #
-    # @return [Solve::Artifact, nil]
-    def delete
-      unless graph.nil?
-        result = graph.remove_artifact(self)
-        @graph = nil
-        result
+    # @example Chaining dependencies
+    #   artifact
+    #     .depends('nginx')
+    #     .depends('ntp', '~> 1.3')
+    #
+    # @return [Solve::Artifact]
+    def depends(name, constraint = '>= 0.0.0')
+      unless dependency?(name, constraint)
+        @dependencies["#{name}-#{constraint}"] = Dependency.new(self, name, constraint)
       end
+
+      self
     end
 
     def to_s
@@ -89,54 +91,16 @@ module Solve
     # @return [Boolean]
     def ==(other)
       other.is_a?(self.class) &&
-        self.name == other.name &&
-        self.version == other.version
+      self.name == other.name &&
+      self.version == other.version
     end
     alias_method :eql?, :==
 
-    # @param [Solve::Version] other
+    # @param [Semverse::Version] other
     #
     # @return [Integer]
     def <=>(other)
       self.version <=> other.version
     end
-
-    private
-
-      # 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,6 +1,19 @@
 module Solve
   class Constraint
     class << self
+      # Coerce the object into a constraint.
+      #
+      # @param [Constraint, String]
+      #
+      # @return [Constraint]
+      def coerce(object)
+        if object.nil?
+          Semverse::DEFAULT_CONSTRAINT
+        else
+          object.is_a?(self) ? object : new(object)
+        end
+      end
+
       # Split a constraint string into an Array of two elements. The first
       # element being the operator and second being the version string.
       #
@@ -50,64 +63,64 @@ module Solve
         [ operator, split_version ].flatten
       end
 
-      # @param [Solve::Constraint] constraint
-      # @param [Solve::Version] target_version
+      # @param [Semverse::Constraint] constraint
+      # @param [Semverse::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
+      # @param [Semverse::Constraint] constraint
+      # @param [Semverse::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
+      # @param [Semverse::Constraint] constraint
+      # @param [Semverse::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
+      # @param [Semverse::Constraint] constraint
+      # @param [Semverse::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
+      # @param [Semverse::Constraint] constraint
+      # @param [Semverse::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
+      # @param [Semverse::Constraint] constraint
+      # @param [Semverse::Version] target_version
       #
       # @return [Boolean]
       def compare_approx(constraint, target_version)
         min = constraint.version
         max = if constraint.patch.nil?
-          Version.new([min.major + 1, 0, 0, 0])
+          Semverse::Version.new([min.major + 1, 0, 0, 0])
         elsif constraint.build
           identifiers = constraint.version.identifiers(:build)
           replace     = identifiers.last.to_i.to_s == identifiers.last.to_s ? "-" : nil
-          Version.new([min.major, min.minor, min.patch, min.pre_release, identifiers.fill(replace, -1).join('.')])
+          Semverse::Version.new([min.major, min.minor, min.patch, min.pre_release, identifiers.fill(replace, -1).join('.')])
         elsif constraint.pre_release
           identifiers = constraint.version.identifiers(:pre_release)
           replace     = identifiers.last.to_i.to_s == identifiers.last.to_s ? "-" : nil
-          Version.new([min.major, min.minor, min.patch, identifiers.fill(replace, -1).join('.')])
+          Semverse::Version.new([min.major, min.minor, min.patch, identifiers.fill(replace, -1).join('.')])
         else
-          Version.new([min.major, min.minor + 1, 0, 0])
+          Semverse::Version.new([min.major, min.minor + 1, 0, 0])
         end
         min <= target_version && target_version < max
       end
@@ -141,10 +154,17 @@ module Solve
     attr_reader :pre_release
     attr_reader :build
 
-    # @param [#to_s] constraint (">= 0.0.0")
+    # Return the Semverse::Version representation of the major, minor, and patch
+    # attributes of this instance
+    #
+    # @return [Semverse::Version]
+    attr_reader :version
+
+    # @param [#to_s] constraint
     def initialize(constraint = nil)
+      constraint = constraint.to_s
       if constraint.nil? || constraint.empty?
-        constraint = ">= 0.0.0"
+        constraint = '>= 0.0.0'
       end
 
       @operator, @major, @minor, @patch, @pre_release, @build = self.class.split(constraint)
@@ -153,22 +173,14 @@ module Solve
         @minor ||= 0
         @patch ||= 0
       end
-    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,
-          self.pre_release,
-          self.build
-        ]
-      )
+      @version = Semverse::Version.new([
+        self.major,
+        self.minor,
+        self.patch,
+        self.pre_release,
+        self.build,
+      ])
     end
 
     # @return [Symbol]
@@ -183,17 +195,21 @@ module Solve
     # Returns true or false if the given version would be satisfied by
     # the version constraint.
     #
-    # @param [#to_s] target_version
+    # @param [Version, #to_s] target
     #
     # @return [Boolean]
-    def satisfies?(target_version)
-      target_version = Version.new(target_version.to_s)
+    def satisfies?(target)
+      target = Version.coerce(target)
 
-      return false if !version.zero? && greedy_match?(target_version)
+      return false if !version.zero? && greedy_match?(target)
 
-      compare(target_version)
+      compare(target)
     end
 
+    # dep-selector uses include? to determine if a version matches the
+    # constriant.
+    alias_method :include?, :satisfies?
+
     # @param [Object] other
     #
     # @return [Boolean]
@@ -209,12 +225,12 @@ module Solve
     end
 
     def to_s
-      str = "#{operator} #{major}"
-      str += ".#{minor}" if minor
-      str += ".#{patch}" if patch
-      str += "-#{pre_release}" if pre_release
-      str += "+#{build}" if build
-      str
+      out =  "#{operator} #{major}"
+      out << ".#{minor}" if minor
+      out << ".#{patch}" if patch
+      out << "-#{pre_release}" if pre_release
+      out << "+#{build}" if build
+      out
     end
 
     private
@@ -223,13 +239,13 @@ module Solve
       # does not include a pre-release and if the operator isn't < or <=.
       # This avoids greedy matches, e.g. 2.0.0.alpha won't satisfy >= 1.0.0.
       #
-      # @param [Solve::Version] target_version
+      # @param [Semverse::Version] target_version
       #
       def greedy_match?(target_version)
         operator_type !~ /less/ && target_version.pre_release? && !version.pre_release?
       end
 
-      # @param [Solve::Version] target
+      # @param [Semverse::Version] target
       #
       # @return [Boolean]
       def compare(target)