solve 0.8.2 → 1.0.0.rc1

data/.ruby-version

@@ -1 +0,0 @@
-2.0.0-p247

data/lib/solve/solver/constraint_row.rb

@@ -1,25 +0,0 @@
-require 'forwardable'
-
-module Solve
-  class Solver
-    class ConstraintRow
-      extend Forwardable
-
-      attr_reader :source
-
-      def_delegator :dependency, :name
-      def_delegator :dependency, :constraint
-
-      # @param [Solve::Dependency] dependency
-      # @param [String, Symbol] source
-      def initialize(dependency, source)
-        @dependency = dependency
-        @source = source
-      end
-
-      private
-
-        attr_reader :dependency
-    end
-  end
-end

data/lib/solve/solver/constraint_table.rb

@@ -1,31 +0,0 @@
-module Solve
-  class Solver
-    class ConstraintTable
-      attr_reader :rows
-
-      def initialize
-        @rows = Array.new
-      end
-
-      # @param [Solve::Dependency] dependency
-      # @param [String, Symbol] source
-      #
-      # @return [Array<ConstraintRow>]
-      def add(dependency, source)
-        @rows << ConstraintRow.new(dependency, source)
-      end
-
-      def constraints_on_artifact(name)
-        @rows.select do |row|
-          row.name == name
-        end.map { |row| row.constraint }
-      end
-
-      def remove_constraints_from_source!(source)
-        from_source, others = @rows.partition { |row| row.source == source }
-        @rows = others
-        from_source
-      end
-    end
-  end
-end

data/lib/solve/solver/variable_row.rb

@@ -1,43 +0,0 @@
-module Solve
-  class Solver
-    class VariableRow
-      attr_reader :artifact
-      attr_reader :value
-      attr_reader :sources
-
-      # @param [String] artifact
-      # @param [String, Symbol] source
-      def initialize(artifact, source)
-        @artifact = artifact
-        @value = nil
-        @sources = Array(source)
-      end
-
-      # @param [String, Symbol] source
-      def add_source(source)
-        @sources << source
-      end
-
-      def last_source
-        @sources.last
-      end
-
-      def bind(value)
-        @value = value
-      end
-
-      def unbind
-        @value = nil
-      end
-
-      def bound?
-        !@value.nil?
-      end
-
-      # @param [String, Symbol] source
-      def remove_source(source)
-        @sources.delete(source)
-      end
-    end
-  end
-end

data/lib/solve/solver/variable_table.rb

@@ -1,55 +0,0 @@
-module Solve
-  class Solver
-    class VariableTable
-      attr_reader :rows
-
-      def initialize
-        @rows = Array.new
-      end
-
-      # @param [String] artifact
-      # @param [String] source
-      def add(artifact, source)
-        row = rows.detect { |row| row.artifact == artifact }
-        if row.nil?
-          @rows << VariableRow.new(artifact, source)
-        else
-          row.add_source(source)
-        end
-      end
-
-      def first_unbound
-        @rows.detect { |row| row.bound? == false }
-      end
-
-      # @param [String] artifact
-      def find_artifact(artifact)
-        @rows.detect { |row| row.artifact == artifact }
-      end
-
-      # @param [String] source
-      def remove_all_with_only_this_source!(source)
-        with_only_this_source, others = @rows.partition { |row| row.sources == [source] }
-        @rows = others
-        with_only_this_source
-      end
-
-      # @param [String] source
-      def all_from_source(source)
-        @rows.select { |row| row.sources.include?(source) }
-      end
-
-      # @param [String] artifact
-      def before(artifact)
-        artifact_index = @rows.index { |row| row.artifact == artifact }
-        (artifact_index == 0) ? nil : @rows[artifact_index - 1]
-      end
-
-      # @param [String] artifact
-      def all_after(artifact)
-        artifact_index = @rows.index { |row| row.artifact == artifact }
-        @rows[(artifact_index+1)..-1]
-      end
-    end
-  end
-end

data/lib/solve/tracers.rb

@@ -1,50 +0,0 @@
-module Solve
-  module Tracers
-    class << self
-      # @param [#say] ui
-      #
-      # @returns [AbstractTracer]
-      def build(ui)
-        unless ui.respond_to?(:say)
-          Solve::Tracers::Silent.new
-        else
-          Solve::Tracers::HumanReadable.new(ui)
-        end
-      end
-    end
-
-    class AbstractTracer
-      class << self
-        private
-
-          def must_define(*args)
-            args.each do |method|
-              define_method(method.to_sym) do |*args|
-                raise AbstractFunction, "##{method} must be defined on #{self.class}"
-              end
-            end
-          end
-      end
-
-      TRACER_METHODS = [
-        :start,
-        :searching_for,
-        :add_constraint,
-        :possible_values,
-        :trying,
-        :backtrack,
-        :cannot_backtrack,
-        :solution,
-        :reset_domain,
-        :unbind,
-        :remove_variable,
-        :remove_constraint,
-      ]
-
-      must_define *TRACER_METHODS
-    end
-  end
-end
-
-require_relative 'tracers/human_readable'
-require_relative 'tracers/silent'

data/lib/solve/tracers/human_readable.rb

@@ -1,67 +0,0 @@
-module Solve
-  module Tracers
-    class HumanReadable < AbstractTracer
-      extend Forwardable
-
-      attr_reader :ui
-
-      def_delegator :ui, :say
-
-      # @param [#say] ui
-      def initialize(ui)
-        @ui = ui
-      end
-
-      def start
-        say("Attempting to find a solution")
-      end
-
-      def searching_for(unbound_variable, constraints, possible_values)
-        say("Searching for a value for #{unbound_variable.artifact}")
-        say("Constraints are #{constraints.join("\n\t")}")
-        possible_values(possible_values)
-      end
-
-      def possible_values(possible_values)
-        say("Possible values are #{possible_values.map(&:to_s).join("\n\t")}")
-      end
-
-      def trying(artifact)
-        say("Attempting to use #{artifact.to_s}")
-      end
-
-      def backtrack(unbound_variable)
-        say("Could not find an acceptable value for #{unbound_variable.artifact.to_s}")
-      end
-
-      def cannot_backtrack
-        say("Cannot backtrack any further")
-      end
-
-      def solution(solution)
-        say("Found Solution")
-        say(solution.inspect)
-      end
-
-      def add_constraint(dependency, source)
-        say("Adding constraint #{dependency.name} #{dependency.constraint} from #{source.to_s}")
-      end
-
-      def reset_domain(variable)
-        say("Resetting possible values for #{variable.artifact.to_s}")
-      end
-
-      def unbind(variable)
-        say("Unbinding #{variable.artifact.to_s}")
-      end
-
-      def remove_variable(variable)
-        say("Removed variable #{variable.artifact.to_s}")
-      end
-
-      def remove_constraint(constraint)
-        say("Removed constraint #{constraint.name} #{constraint.constraint}")
-      end
-    end
-  end
-end

data/lib/solve/tracers/silent.rb

@@ -1,17 +0,0 @@
-module Solve
-  module Tracers
-    class Silent < AbstractTracer
-      class << self
-        def empty_method(*args)
-          args.each do |method|
-            define_method(method.to_sym) do |*args|
-            end
-          end
-        end
-      end
-
-      empty_method *AbstractTracer::TRACER_METHODS
-    end
-  end
-end
-

data/lib/solve/version.rb

@@ -1,140 +0,0 @@
-module Solve
-  class Version
-    class << self
-      # @param [#to_s] version_string
-      #
-      # @raise [InvalidVersionFormat]
-      #
-      # @return [Array]
-      def split(version_string)
-        case version_string.to_s
-        when /^(\d+)\.(\d+)\.(\d+)(-([0-9a-z\-\.]+))?(\+([0-9a-z\-\.]+))?$/i
-          [ $1.to_i, $2.to_i, $3.to_i, $5, $7 ]
-        when /^(\d+)\.(\d+)\.(\d+)?$/
-          [ $1.to_i, $2.to_i, $3.to_i ]
-        when /^(\d+)\.(\d+)?$/
-          [ $1.to_i, $2.to_i, 0 ]
-        when /^(\d+)$/
-          [ $1.to_i, 0, 0 ]
-        else
-          raise Errors::InvalidVersionFormat.new(version_string)
-        end
-      end
-    end
-
-    include Comparable
-
-    attr_reader :major
-    attr_reader :minor
-    attr_reader :patch
-    attr_reader :pre_release
-    attr_reader :build
-
-    # @overload initialize(version_array)
-    #   @param [Array] version_array
-    #
-    #   @example
-    #     Version.new([1, 2, 3, 'rc.1', 'build.1']) => #<Version: @major=1, @minor=2, @patch=3, @pre_release='rc.1', @build='build.1'>
-    #
-    # @overload initialize(version_string)
-    #   @param [#to_s] version_string
-    #
-    #   @example
-    #     Version.new("1.2.3-rc.1+build.1") => #<Version: @major=1, @minor=2, @patch=3, @pre_release='rc.1', @build='build.1'>
-    #
-    # @overload initialize(version)
-    #   @param [Solve::Version] version
-    #
-    #   @example
-    #     Version.new(Version.new("1.2.3-rc.1+build.1")) => #<Version: @major=1, @minor=2, @pre_release='rc.1', @build='build.1'>
-    #
-    def initialize(*args)
-      if args.first.is_a?(Array)
-        @major, @minor, @patch, @pre_release, @build = args.first
-      else
-        @major, @minor, @patch, @pre_release, @build = self.class.split(args.first.to_s)
-      end
-
-      @major       ||= 0
-      @minor       ||= 0
-      @patch       ||= 0
-      @pre_release ||= nil
-      @build       ||= nil
-    end
-
-    # @param [Solve::Version] other
-    #
-    # @return [Integer]
-    def <=>(other)
-      [:major, :minor, :patch].each do |release|
-        ans = self.send(release) <=> other.send(release)
-        return ans if ans != 0
-      end
-      ans = pre_release_and_build_presence_score <=> other.pre_release_and_build_presence_score
-      return ans if ans != 0
-      ans = identifiers_comparaison(other, :pre_release)
-      return ans if ans != 0
-      if build && other.build
-        return identifiers_comparaison(other, :build)
-      else
-        return build.to_s <=> other.build.to_s
-      end
-      0
-    end
-
-    # @return [Array]
-    def identifiers(release)
-      send(release).to_s.split('.').map do |str|
-        str.to_i.to_s == str ? str.to_i : str
-      end
-    end
-
-    def pre_release?
-      !!pre_release
-    end
-
-    def zero?
-      [major, minor, patch].all? { |n| n == 0 }
-    end
-
-    # @return [Integer]
-    def pre_release_and_build_presence_score
-      pre_release ? 0 : (build.nil? ? 1 : 2)
-    end
-
-    # @param [Solve::Version] other
-    #
-    # @return [Integer]
-    def identifiers_comparaison(other, release)
-      [identifiers(release).length, other.identifiers(release).length].max.times do |i|
-        if identifiers(release)[i].class == other.identifiers(release)[i].class
-          ans = identifiers(release)[i] <=> other.identifiers(release)[i]
-          return ans if ans != 0
-        elsif identifiers(release)[i] && other.identifiers(release)[i]
-          return identifiers(release)[i].class.to_s <=> other.identifiers(release)[i].class.to_s
-        elsif identifiers(release)[i] || other.identifiers(release)[i]
-          return other.identifiers(release)[i].class.to_s <=> identifiers(release)[i].class.to_s
-        end
-      end
-      0
-    end
-
-    # @param [Solve::Version] other
-    #
-    # @return [Boolean]
-    def eql?(other)
-      other.is_a?(Version) && self == other
-    end
-
-    def inspect
-      "#<#{self.class.to_s} #{to_s}>"
-    end
-
-    def to_s
-      str = "#{major}.#{minor}.#{patch}"
-      str += "-#{pre_release}" if pre_release
-      str += "+#{build}" if build
-      str
-    end
-  end
-end

data/spec/unit/solve/constraint_spec.rb

@@ -1,708 +0,0 @@
-require 'spec_helper'
-
-RSpec::Matchers.define :satisfies do |*args|
-  match do |constraint|
-    constraint.satisfies?(*args).should be_true
-  end
-end
-
-describe Solve::Constraint do
-  let(:valid_string) { ">= 0.0.0" }
-  let(:invalid_string) { "x23u7089213.*" }
-
-  describe "ClassMethods" do
-    subject { Solve::Constraint }
-
-    describe "::new" do
-      it "returns a new instance of Constraint" do
-        subject.new(valid_string).should be_a(Solve::Constraint)
-      end
-
-      it "assigns the parsed operator to the operator attribute" do
-        subject.new(valid_string).operator.should eql(">=")
-      end
-
-      it "assigns the parsed operator to the operator attribute with no separation between operator and version" do
-        subject.new(">=0.0.0").operator.should eql(">=")
-      end
-
-      it "assigns the parsed version string as an instance of Version to the version attribute" do
-        result = subject.new(valid_string)
-
-        result.version.should be_a(Solve::Version)
-        result.version.to_s.should eql("0.0.0")
-      end
-
-      it "sets a default of '>= 0.0.0' if given a nil value" do
-        subject.new(nil).to_s.should eql(">= 0.0.0")
-      end
-
-      it "sets a default of '>= 0.0.0' if given a blank string" do
-        subject.new('').to_s.should eql(">= 0.0.0")
-      end
-
-      context "given a string that does not match the Constraint REGEXP" do
-        it "raises an InvalidConstraintFormat error" do
-          lambda {
-            subject.new(invalid_string)
-          }.should raise_error(Solve::Errors::InvalidConstraintFormat)
-        end
-      end
-
-      context "given a constraint that does not include a minor version (~>)" do
-        it "has a nil value for minor" do
-          expect(subject.new("~> 1").minor).to be_nil
-        end
-
-        it "has a nil value for patch" do
-          expect(subject.new("~> 1").patch).to be_nil
-        end
-      end
-
-      context "given a constraint that does not include a minor version (=)" do
-        it "has a 0 for minor" do
-          subject.new("= 1").minor.should eq(0)
-        end
-      end
-
-      context "given a constraint that does not include a patch version (~>)" do
-        it "has a nil value for patch" do
-          subject.new("~> 1.2").patch.should be_nil
-        end
-      end
-
-      context "given a constraint that does not include a patch version (=)" do
-        it "has a 0 for patch" do
-          subject.new("= 1.2").patch.should eq(0)
-        end
-      end
-
-      context "given a constraint that does not include a build version" do
-        it "has a nil value for build" do
-          subject.new(">= 1.2.3-alpha").build.should be_nil
-        end
-      end
-
-      context "given a constraint that does not include a pre release version" do
-        it "has a nil value for pre release" do
-          subject.new(">= 1.2.3+build").pre_release.should be_nil
-        end
-      end
-    end
-
-    describe "::split" do
-      let(:constraint_string) { nil }
-
-      subject { described_class.split(constraint_string) }
-
-      context "given a constraint containing the elements (operator, major, minor, patch, pre_release, build)" do
-        let(:constraint_string) { ">= 1.2.3-alpha+build" }
-
-        it "returns an array with the constraint operator at index 0" do
-          subject[0].should eql(">=")
-        end
-
-        it "returns an array with the major version in index 1" do
-          subject[1].should eql(1)
-        end
-
-        it "returns an array with the minor version at index 2" do
-          subject[2].should eql(2)
-        end
-
-        it "returns an array with the patch version at index 3" do
-          subject[3].should eql(3)
-        end
-
-        it "returns an array with the pre release version at index 4" do
-          subject[4].should eql("alpha")
-        end
-
-        it "returns an array with the build version at index 5" do
-          subject[5].should eql("build")
-        end
-      end
-
-      context "given a constraint containing the elements (operator, major, minor, patch, pre_release)" do
-        let(:constraint_string) { ">= 1.2.3-alpha" }
-
-        it "returns an array with the constraint operator at index 0" do
-          subject[0].should eql(">=")
-        end
-
-        it "returns an array with the major version in index 1" do
-          subject[1].should eql(1)
-        end
-
-        it "returns an array with the minor version at index 2" do
-          subject[2].should eql(2)
-        end
-
-        it "returns an array with the patch version at index 3" do
-          subject[3].should eql(3)
-        end
-
-        it "returns an array with the pre release version at index 4" do
-          subject[4].should eql("alpha")
-        end
-
-        it "returns an array with a nil value at index 5" do
-          subject[5].should be_nil
-        end
-      end
-
-      context "given a constraint containing the elements (operator, major, minor, patch)" do
-        let(:constraint_string) { ">= 1.2.3" }
-
-        it "returns an array with the constraint operator at index 0" do
-          subject[0].should eql(">=")
-        end
-
-        it "returns an array with the major version in index 1" do
-          subject[1].should eql(1)
-        end
-
-        it "returns an array with the minor version at index 2" do
-          subject[2].should eql(2)
-        end
-
-        it "returns an array with the patch version at index 3" do
-          subject[3].should eql(3)
-        end
-
-        it "returns an array with a nil value at index 4" do
-          subject[4].should be_nil
-        end
-
-        it "returns an array with a nil value at index 5" do
-          subject[5].should be_nil
-        end
-      end
-
-      context "given a constraint containing the elements (operator, major, minor)" do
-        let(:constraint_string) { ">= 1.2" }
-
-        it "returns an array with the constraint operator at index 0" do
-          subject[0].should eql(">=")
-        end
-
-        it "returns an array with the major version in index 1" do
-          subject[1].should eql(1)
-        end
-
-        it "returns an array with the minor version at index 2" do
-          subject[2].should eql(2)
-        end
-
-        it "returns an array with a nil value at index 3" do
-          subject[3].should be_nil
-        end
-
-        it "returns an array with a nil value at index 4" do
-          subject[4].should be_nil
-        end
-
-        it "returns an array with a nil value at index 5" do
-          subject[5].should be_nil
-        end
-      end
-
-      context "given a constraint containing the elements (operator, major)" do
-        let(:constraint_string) { ">= 1" }
-
-        it "returns an array with the constraint operator at index 0" do
-          subject[0].should eql(">=")
-        end
-
-        it "returns an array with the major version in index 1" do
-          subject[1].should eql(1)
-        end
-
-        it "returns an array with a nil value at index 2" do
-          subject[2].should be_nil
-        end
-
-        it "returns an array with a nil value at index 3" do
-          subject[3].should be_nil
-        end
-
-        it "returns an array with a nil value at index 4" do
-          subject[4].should be_nil
-        end
-
-        it "returns an array with a nil value at index 5" do
-          subject[5].should be_nil
-        end
-      end
-
-      context "given a constraint which is missing an operator" do
-        let(:constraint_string) { "1.2.3" }
-
-        it "returns an equality operator at index 0" do
-          subject[0].should eql("=")
-        end
-      end
-
-      context "given a string that does not match the Constraint REGEXP" do
-        let(:constraint_string) { "x23u7089213.*" }
-
-        it "raises an InvalidConstraintFormat error" do
-          expect {
-            subject.split(invalid_string)
-          }.to raise_error(Solve::Errors::InvalidConstraintFormat)
-        end
-      end
-
-      context "given a string that does not contain an operator" do
-        let(:constraint_string) { "1.2.3" }
-
-        it "returns a constraint constraint with a default operator (=)" do
-          subject[0].should eql("=")
-        end
-      end
-    end
-  end
-
-  describe "#satisfies?" do
-    subject { Solve::Constraint.new("= 1.0.0") }
-
-    it { should satisfies("1.0.0") }
-
-    it "accepts a Version for version" do
-      should satisfies(Solve::Version.new("1.0.0"))
-    end
-
-    context "strictly greater than (>) pre-release constraint" do
-      subject { Solve::Constraint.new("> 1.0.0-alpha") }
-
-      it { should_not satisfies("0.9.9+build") }
-      it { should_not satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "strictly greater than (>)" do
-      subject { Solve::Constraint.new("> 1.0.0") }
-
-      it { should_not satisfies("0.9.9+build") }
-      it { should_not satisfies("1.0.0-alpha") }
-      it { should_not satisfies("1.0.0-alpha.2") }
-      it { should_not satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "strictly greater than (>) build constraint" do
-      subject { Solve::Constraint.new("> 1.0.0+build") }
-
-      it { should_not satisfies("0.9.9+build") }
-      it { should_not satisfies("1.0.0-alpha") }
-      it { should_not satisfies("1.0.0-alpha.2") }
-      it { should_not satisfies("1.0.0") }
-      it { should_not satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "greater than or equal to (>) zero pre-release constraint" do
-      subject { Solve::Constraint.new("> 0.0.0-alpha") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "greater than or equal to (>) zero constraint" do
-      subject { Solve::Constraint.new("> 0.0.0") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "greater than or equal to (>) zero build constraint" do
-      subject { Solve::Constraint.new("> 0.0.0+build") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "strictly less than (<) pre-release constraint" do
-      subject { Solve::Constraint.new("< 1.0.0-alpha.3") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should_not satisfies("1.0.0") }
-      it { should_not satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should_not satisfies("1.0.1") }
-      it { should_not satisfies("1.0.1+build.2") }
-      it { should_not satisfies("2.0.0") }
-    end
-
-    context "strictly less than (<)" do
-      subject { Solve::Constraint.new("< 1.0.0") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should_not satisfies("1.0.0") }
-      it { should_not satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should_not satisfies("1.0.1") }
-      it { should_not satisfies("1.0.1+build.2") }
-      it { should_not satisfies("2.0.0") }
-    end
-
-    context "strictly less than (<) build constraint" do
-      subject { Solve::Constraint.new("< 1.0.0+build.20") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should_not satisfies("1.0.1") }
-      it { should_not satisfies("1.0.1+build.2") }
-      it { should_not satisfies("2.0.0") }
-    end
-
-    context "strictly equal to (=)" do
-      subject { Solve::Constraint.new("= 1.0.0") }
-
-      it { should_not satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0") }
-      it { should_not satisfies("1.0.1") }
-      it { should_not satisfies("1.0.0-alpha") }
-    end
-
-    context "greater than or equal to (>=) pre-release constraint" do
-      subject { Solve::Constraint.new(">= 1.0.0-alpha") }
-
-      it { should_not satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "greater than or equal to (>=)" do
-      subject { Solve::Constraint.new(">= 1.0.0") }
-
-      it { should_not satisfies("0.9.9+build") }
-      it { should_not satisfies("1.0.0-alpha") }
-      it { should_not satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "greater than or equal to (>=) build constraint" do
-      subject { Solve::Constraint.new(">= 1.0.0+build") }
-
-      it { should_not satisfies("0.9.9+build") }
-      it { should_not satisfies("1.0.0-alpha") }
-      it { should_not satisfies("1.0.0-alpha.2") }
-      it { should_not satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "greater than or equal to (>=) zero pre-release constraint" do
-      subject { Solve::Constraint.new(">= 0.0.0-alpha") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "greater than or equal to (>=) zero constraint" do
-      subject { Solve::Constraint.new(">= 0.0.0") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "greater than or equal to (>=) zero build constraint" do
-      subject { Solve::Constraint.new(">= 0.0.0+build") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should satisfies("1.0.1-beta") }
-      it { should satisfies("1.0.1") }
-      it { should satisfies("1.0.1+build.2") }
-      it { should satisfies("2.0.0") }
-    end
-
-    context "lower than or equal to (<=) pre-release constraint" do
-      subject { Solve::Constraint.new("<= 1.0.0") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should_not satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should_not satisfies("1.0.1") }
-      it { should_not satisfies("1.0.1+build.2") }
-      it { should_not satisfies("2.0.0") }
-    end
-
-    context "lower than or equal to (<=)" do
-      subject { Solve::Constraint.new("<= 1.0.0-alpha") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should_not satisfies("1.0.0-alpha.2") }
-      it { should_not satisfies("1.0.0") }
-      it { should_not satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should_not satisfies("1.0.1") }
-      it { should_not satisfies("1.0.1+build.2") }
-      it { should_not satisfies("2.0.0") }
-    end
-
-    context "lower than or equal to (<=) build constraint" do
-      subject { Solve::Constraint.new("<= 1.0.0+build") }
-
-      it { should satisfies("0.9.9+build") }
-      it { should satisfies("1.0.0-alpha") }
-      it { should satisfies("1.0.0-alpha.2") }
-      it { should satisfies("1.0.0") }
-      it { should satisfies("1.0.0+build") }
-      it { should_not satisfies("1.0.1-beta") }
-      it { should_not satisfies("1.0.1") }
-      it { should_not satisfies("1.0.1+build.2") }
-      it { should_not satisfies("2.0.0") }
-    end
-
-    %w[~> ~].each do |operator|
-      describe "aproximately (#{operator})" do
-        context "when the last value in the constraint is for minor" do
-          subject { Solve::Constraint.new("#{operator} 1.2") }
-
-          it { should_not satisfies("1.1.0") }
-          it { should_not satisfies("1.2.0-alpha") }
-          it { should satisfies("1.2.0") }
-          it { should satisfies("1.2.3") }
-          it { should satisfies("1.2.3+build") }
-          it { should satisfies("1.3") }
-          it { should satisfies("1.3.0") }
-          it { should_not satisfies("2.0.0-0") }
-          it { should_not satisfies("2.0.0") }
-        end
-
-        context "when the last value in the constraint is for patch" do
-          subject { Solve::Constraint.new("#{operator} 1.2.0") }
-
-          it { should_not satisfies("1.1.0") }
-          it { should_not satisfies("1.2.3-alpha") }
-          it { should satisfies("1.2.2") }
-          it { should satisfies("1.2.3") }
-          it { should satisfies("1.2.5+build") }
-          it { should_not satisfies("1.3.0-0") }
-          it { should_not satisfies("1.3.0") }
-        end
-
-        context "when the last value in the constraint is for pre_release with a last numeric identifier" do
-          subject { Solve::Constraint.new("#{operator} 1.2.3-4") }
-
-          it { should_not satisfies("1.2.3") }
-          it { should satisfies("1.2.3-4") }
-          it { should satisfies("1.2.3-10") }
-          it { should satisfies("1.2.3-10.5+build.33") }
-          it { should_not satisfies("1.2.3--") }
-          it { should_not satisfies("1.2.3-alpha") }
-          it { should_not satisfies("1.2.3") }
-          it { should_not satisfies("1.2.4") }
-          it { should_not satisfies("1.3.0") }
-        end
-
-        context "when the last value in the constraint is for pre_release with a last non-numeric identifier" do
-          subject { Solve::Constraint.new("#{operator} 1.2.3-alpha") }
-
-          it { should_not satisfies("1.2.3-4") }
-          it { should_not satisfies("1.2.3--") }
-          it { should satisfies("1.2.3-alpha") }
-          it { should satisfies("1.2.3-alpha.0") }
-          it { should satisfies("1.2.3-beta") }
-          it { should satisfies("1.2.3-omega") }
-          it { should satisfies("1.2.3-omega.4") }
-          it { should_not satisfies("1.2.3") }
-          it { should_not satisfies("1.3.0") }
-        end
-
-        context "when the last value in the constraint is for build with a last numeric identifier and a pre-release" do
-          subject { Solve::Constraint.new("#{operator} 1.2.3-alpha+5") }
-
-          it { should_not satisfies("1.2.3-alpha") }
-          it { should_not satisfies("1.2.3-alpha.4") }
-          it { should_not satisfies("1.2.3-alpha.4+4") }
-          it { should satisfies("1.2.3-alpha+5") }
-          it { should satisfies("1.2.3-alpha+5.5") }
-          it { should satisfies("1.2.3-alpha+10") }
-          it { should_not satisfies("1.2.3-alpha+-") }
-          it { should_not satisfies("1.2.3-alpha+build") }
-          it { should_not satisfies("1.2.3-beta") }
-          it { should_not satisfies("1.2.3") }
-          it { should_not satisfies("1.3.0") }
-        end
-
-        context "when the last value in the constraint is for build with a last non-numeric identifier and a pre-release" do
-          subject { Solve::Constraint.new("#{operator} 1.2.3-alpha+build") }
-
-          it { should_not satisfies("1.2.3-alpha") }
-          it { should_not satisfies("1.2.3-alpha.4") }
-          it { should_not satisfies("1.2.3-alpha.4+4") }
-          it { should satisfies("1.2.3-alpha+build") }
-          it { should satisfies("1.2.3-alpha+build.5") }
-          it { should satisfies("1.2.3-alpha+preview") }
-          it { should satisfies("1.2.3-alpha+zzz") }
-          it { should_not satisfies("1.2.3-alphb") }
-          it { should_not satisfies("1.2.3-beta") }
-          it { should_not satisfies("1.2.3") }
-          it { should_not satisfies("1.3.0") }
-        end
-
-        context "when the last value in the constraint is for build with a last numeric identifier" do
-          subject { Solve::Constraint.new("#{operator} 1.2.3+5") }
-
-          it { should_not satisfies("1.2.3") }
-          it { should_not satisfies("1.2.3-alpha") }
-          it { should_not satisfies("1.2.3+4") }
-          it { should satisfies("1.2.3+5") }
-          it { should satisfies("1.2.3+99") }
-          it { should_not satisfies("1.2.3+5.build") }
-          it { should_not satisfies("1.2.3+-") }
-          it { should_not satisfies("1.2.3+build") }
-          it { should_not satisfies("1.2.4") }
-          it { should_not satisfies("1.3.0") }
-        end
-
-        context "when the last value in the constraint is for build with a last non-numeric identifier" do
-          subject { Solve::Constraint.new("#{operator} 1.2.3+build") }
-
-          it { should_not satisfies("1.2.3-alpha") }
-          it { should_not satisfies("1.2.3") }
-          it { should_not satisfies("1.2.3+5") }
-          it { should satisfies("1.2.3+build") }
-          it { should satisfies("1.2.3+build.5") }
-          it { should satisfies("1.2.3+preview") }
-          it { should satisfies("1.2.3+zzz") }
-          it { should_not satisfies("1.2.4-0") }
-          it { should_not satisfies("1.2.4") }
-          it { should_not satisfies("1.2.5") }
-          it { should_not satisfies("1.3.0") }
-        end
-      end
-    end
-  end
-
-  describe "#eql?" do
-    subject { Solve::Constraint.new("= 1.0.0") }
-
-    it "returns true if the other object is a Solve::Constraint with the same operator and version" do
-      other = Solve::Constraint.new("= 1.0.0")
-      subject.should eql(other)
-    end
-
-    it "returns false if the other object is a Solve::Constraint with the same operator and different version" do
-      other = Solve::Constraint.new("= 9.9.9")
-      subject.should_not eql(other)
-    end
-
-    it "returns false if the other object is a Solve::Constraint with the same version and different operator" do
-      other = Solve::Constraint.new("> 1.0.0")
-      subject.should_not eql(other)
-    end
-
-    it "returns false if the other object is not a Solve::Constraint" do
-      other = "chicken"
-      subject.should_not eql(other)
-    end
-  end
-
-  describe "#to_s" do
-    let(:constraint_string) { ">= 1.2.3-alpha+123" }
-    subject { described_class.new(constraint_string).to_s }
-
-    it { should eq(constraint_string) }
-
-    context "when the constraint does not contain a minor or patch value" do
-      let(:constraint_string) { "~> 1" }
-      it { should eq(constraint_string) }
-    end
-
-    context "when the constraint does not contain a patch value" do
-      let(:constraint_string) { "~> 1.2" }
-      it { should eq(constraint_string) }
-    end
-
-    context "when the constraint does not contain a build value" do
-      let(:constraint_string) { ">= 1.2.0-alpha"}
-      it { should eq(constraint_string) }
-    end
-
-    context "when the constraint contains a pre_release value" do
-      let(:constraint_string) { ">= 1.2.0+123"}
-      it { should eq(constraint_string) }
-    end
-  end
-end