semver_stringer 0.1.1 → 0.2.0

data/README.md

@@ -19,7 +19,19 @@ Gives you a little help with your [semver](http://semver.org/) strings.
 		semver = SemverStringer::Semver.new version_info
 		semver.to_s 	# => "2.1.13-alpha.1+2134"
 
+### SemVer comparisons
+
+`Semver` implements the comparable module, so it's easy to compare 
+one Semver with another. The rules for comparisons are taken from
+the spec at semver.org.  Example:
+
+    version1 = SemverStringer::Semver.new :major=>1, :minor=>0, :patch=>0
+    version2alpha = SemverStringer::Semver.new :major=>2, :minor=0, :patch=>0, :pre=>"alpha"
+    version2 = SemverStringer::Semver.new :major=>2, :minor=0, :patch=>0
+
+    version1 < version2alpha  #=> true
+    version2alpha < version2  #=> true
+
 ## TODO
 
-* Comparison operators to implement the ordering as laid out in the semver spec.
 * Constructor taking string parameter for parsing and initialization

data/lib/semver_stringer/semver.rb

@@ -1,5 +1,56 @@
 module SemverStringer
-	class Semver
+
+  class Semver
+    include Comparable
+
+    class Substring
+      include Comparable
+
+      def initialize(s) 
+        @str = s
+      end
+
+      def <=>(other)
+        other_str = other.instance_variable_get('@str')
+        return Substring::compareVersionStrings @str, other_str
+      end
+
+      def self.compareVersionStrings(first, second)
+        first_components = first.split('.')
+        second_components = second.split('.')
+
+        first_head = first_components.shift
+        second_head = second_components.shift
+
+        head_comparison = compare_version_atoms first_head, second_head
+        if head_comparison == 0
+          if first_components.length > 0 or second_components.length > 0 
+            return Substring::compareVersionStrings first_components.join('.'), second_components.join('.')
+          else
+            return 0
+          end
+        else 
+          return head_comparison
+        end
+      end
+
+      def self.compare_version_atoms(first, second)
+        if first == nil and second == nil
+          return nil
+        elsif first != nil and second == nil
+          return 1
+        elsif first == nil and second != nil
+          return -1 
+        else
+          unless first.match /[^0-9]/ or second.match /[^0-9]/
+            return first.to_i <=> second.to_i
+          else
+            return first <=> second
+          end
+        end
+      end
+
+    end
 
     # Creates a new Semver instance.
     #
@@ -9,11 +60,53 @@ module SemverStringer
     # @option params [Integer] :patch Patch version number
     # @option params [String, Integer, Array<String, Integer>] :pre Pre-release identifier(s)
     # @option params [String, Integer, Array<String, Integer>] :build Build number identifier(s)
-		def initialize(params={})
-			@major, @minor, @patch = get_version_numbers_from params
-			@build = get_build_string_from params
-			@pre = get_pre_string_from params
-		end
+    def initialize(params={})
+      @major, @minor, @patch = get_version_numbers_from params
+      @build = get_build_string_from params
+      @pre = get_pre_string_from params
+    end
+
+
+    # All the semver.org comparison rules are expressed by this operator
+    def <=>(other) 
+
+      versionComparison = Substring.new(get_version_string) <=> Substring.new(other.get_version_string)
+      (return versionComparison) if versionComparison != 0
+
+      other_pre = other.instance_variable_get('@pre')
+      if @pre != nil and other_pre == nil
+        return -1
+      elsif @pre == nil and other_pre != nil
+        return 1
+      elsif @pre != nil and other_pre != nil
+        pre_comparison = Substring.new(@pre) <=> Substring.new(other_pre)
+        (return pre_comparison) if pre_comparison != 0
+      end
+
+      other_build = other.instance_variable_get('@build')
+      if @build == nil and other_build != nil
+        return -1
+      elsif @build != nil and other_build == nil
+        return 1
+      elsif @build != nil and other_build != nil
+        build_comparison = Substring.new(@build) <=> Substring.new(other_build)
+        (return build_comparison) if build_comparison != 0
+      end
+
+      return 0
+    end
+
+    def get_version_string
+      "#{@major}.#{@minor}.#{@patch}"
+    end
+
+    def get_pre_string
+      @pre
+    end
+
+    def get_build_string
+      @build
+    end
 
     # Returns a string representation of the SemVer
     #
@@ -21,72 +114,65 @@ module SemverStringer
     #   SemverStringer::Semver.new(:major=>2, :pre=>"alpha").to_s  #=> "2.0.0-alpha"
     #
     # @return [String]
-		def to_s
-			version = "#{@major}.#{@minor}.#{@patch}"
-			version << "-#{@pre}" unless @pre == nil
-			version << "+#{@build}" unless @build == nil
-			version
-		end
-
-		private
-		def raise_if_invalid_version_number(hash, key)
-			if hash.has_key? key
-				raise ArgumentError.new("Positive integers only") if hash[key] < 0
-				raise ArgumentError.new("Integral numbers only") if ! hash[key].integer? 
-			end
-		end
-
-		private
-		def get_valid_version_number(hash, key) 
-			raise_if_invalid_version_number(hash, key)
-			(hash.has_key? key) ? hash[key] : 0
-		end
-
-		private
-		def get_version_numbers_from(params)
-			if (params.has_key? :major) || (params.has_key? :minor) || (params.has_key? :patch)
-				major = get_valid_version_number(params, :major)
-				minor = get_valid_version_number(params, :minor)
-				patch = get_valid_version_number(params, :patch)
-			else
-				major = minor = 0
-				patch = 1
-			end
-
-			[major, minor, patch]
-		end
-
-		private
-		def get_pre_string_from(params) 
-			return get_optional_string_from params, :pre
-		end
-
-		private
-		def get_build_string_from(params) 
-			return get_optional_string_from params, :build
-		end
-
-		private
-		def get_optional_string_from(params, type)
-			disallowed_chars = /[^0-9A-Za-z-]/
-
-			if params.has_key? type
-				identifiers = scalar_to_array params[type]
-					
-				identifiers.each do |param|
-					raise ArgumentError.new("Characters in #{type} ID are not allowed") if disallowed_chars.match param.to_s
-				end
-
-				return identifiers.join "."
-			else
-				return nil
-			end
-		end
-	
-		private 
-		def scalar_to_array(scalar)
-			(scalar.is_a? Array) ? scalar : Array.new(1, scalar)
-		end
-	end
-end
+    def to_s
+      version = get_version_string
+      version << "-#{get_pre_string}" unless @pre == nil
+      version << "+#{get_build_string}" unless @build == nil
+      version
+    end
+
+    private
+    def raise_if_invalid_version_number(hash, key)
+      if hash.has_key? key
+        raise ArgumentError.new("Positive integers only") if hash[key] < 0
+        raise ArgumentError.new("Integral numbers only") if ! hash[key].integer? 
+      end
+    end
+
+    def get_valid_version_number(hash, key) 
+      raise_if_invalid_version_number(hash, key)
+      (hash.has_key? key) ? hash[key] : 0
+    end
+
+    def get_version_numbers_from(params)
+      if (params.has_key? :major) || (params.has_key? :minor) || (params.has_key? :patch)
+        major = get_valid_version_number(params, :major)
+        minor = get_valid_version_number(params, :minor)
+        patch = get_valid_version_number(params, :patch)
+      else
+        major = minor = 0
+        patch = 1
+      end
+
+      [major, minor, patch]
+    end
 
+    def get_pre_string_from(params) 
+      return get_optional_string_from params, :pre
+    end
+
+    def get_build_string_from(params) 
+      return get_optional_string_from params, :build
+    end
+
+    def get_optional_string_from(params, type)
+      disallowed_chars = /[^0-9A-Za-z-]/
+
+        if params.has_key? type
+          identifiers = scalar_to_array params[type]
+
+          identifiers.each do |param|
+            raise ArgumentError.new("Characters in #{type} ID are not allowed") if disallowed_chars.match param.to_s
+          end
+
+          return identifiers.join "."
+        else
+          return nil
+        end
+    end
+
+    def scalar_to_array(scalar)
+      (scalar.is_a? Array) ? scalar : Array.new(1, scalar)
+    end
+  end
+end

data/lib/semver_stringer/version.rb

@@ -1,3 +1,3 @@
 module SemverStringer
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/spec/semver_spec.rb

@@ -103,4 +103,147 @@ describe SemverStringer::Semver do
 			semver.to_s.should == "1.2.303-beta+build.1234"
 		end
 	end
+
+  describe "semver comparson operator" do
+
+    RSpec::Matchers.define :be_higher_than do |lower|
+      match do |higher|
+        (higher <=> lower) == 1 and 
+        (higher < lower) == false and
+        (higher == lower) == false and
+        (higher > lower) == true and
+        (lower <=> higher) == -1 and
+        (lower < higher) == true and
+        (lower == higher) == false and
+        (lower > higher) == false
+      end
+
+      failure_message_for_should do |higher|
+        "expected that #{higher} would be higher than #{lower} (<=> got #{higher<=>lower})"
+      end
+
+      failure_message_for_should_not do |higher|
+        "expected that #{higher} would not be higher than #{lower} (<=> got #{higher<=>lower})"
+      end
+
+      description do
+        "be higher than #{lower}"
+      end
+    end
+
+    it "is equal if version numbers are all identical" do
+      semver1 = SemverStringer::Semver.new :major=>2, :minor=>5, :patch=>9
+      semver2 = SemverStringer::Semver.new :major=>2, :minor=>5, :patch=>9
+
+      (semver1 <=> semver2).should == 0
+      (semver1 < semver2).should == false
+      (semver1 == semver2).should == true
+      (semver1 > semver2).should == false
+
+      (semver2 <=> semver1).should == 0
+      (semver2 < semver1).should == false
+      (semver2 == semver1).should == true
+      (semver2 > semver1).should == false
+    end    
+
+    it "gives highest precedence to major" do
+      higher = SemverStringer::Semver.new :major=>3, :minor=>1, :patch=>1
+      lower = SemverStringer::Semver.new :major=>2, :minor=>50, :patch=>50
+
+      higher.should be_higher_than lower
+    end
+
+    it "gives second precedence to minor" do
+      higher = SemverStringer::Semver.new :major=>2, :minor=>6, :patch=>1
+      lower = SemverStringer::Semver.new :major=>2, :minor=>2, :patch=>900
+
+      higher.should be_higher_than lower
+    end
+
+    it "considers pre-release semvers lower than non-pre-release semvers" do
+      higher = SemverStringer::Semver.new
+      lower = SemverStringer::Semver.new :pre=>1
+
+      higher.should be_higher_than lower
+    end
+
+    it "compares pre numbers as integers" do
+      higher = SemverStringer::Semver.new :pre=>11
+      lower = SemverStringer::Semver.new :pre=>"2"
+
+      higher.should be_higher_than lower
+    end
+
+    it "compares pre numbers with chars or - as strings" do
+      higher = SemverStringer::Semver.new :pre=>"a"
+      lower = SemverStringer::Semver.new :pre=>1
+
+      higher.should be_higher_than lower
+    end
+
+    it "considers build-numbered semvers higher than non-build numbered semvers" do
+      higher = SemverStringer::Semver.new :build=>1
+      lower = SemverStringer::Semver.new 
+
+      higher.should be_higher_than lower
+    end
+
+    it "ignores build numbers if the main versions are different" do
+      higher = SemverStringer::Semver.new :major=>2, :minor=>6, :patch=>1
+      lower = SemverStringer::Semver.new :major=>2, :minor=>5, :patch=>1, :build=>9
+
+      higher.should be_higher_than lower
+    end
+
+    it "compares integer build numbers as integers" do
+      higher = SemverStringer::Semver.new :build=>11
+      lower = SemverStringer::Semver.new :build=>"2"
+
+      higher.should be_higher_than lower
+    end
+
+    it "compares build numbers with chars or - as strings" do
+      higher = SemverStringer::Semver.new :build=>"a"
+      lower = SemverStringer::Semver.new :build=>1
+
+      higher.should be_higher_than lower
+    end
+
+    describe "Semver::Substring comparator" do
+      it "compares equal numbers as integers" do
+        first = SemverStringer::Semver::Substring.new "4"
+        second = SemverStringer::Semver::Substring.new "4"
+
+        (first <=> second).should be 0
+      end
+
+      it "compares numbers as integers" do
+        higher = SemverStringer::Semver::Substring.new "12"
+        lower = SemverStringer::Semver::Substring.new "4"
+
+        higher.should be_higher_than lower
+      end
+
+      it "compares period-delimeted sub-numbers with each other" do
+        first = SemverStringer::Semver::Substring.new "a.b.2"
+        second = SemverStringer::Semver::Substring.new "a.b.2"
+        (first <=> second).should be 0
+
+        higher = SemverStringer::Semver::Substring.new "4.beta"
+        lower = SemverStringer::Semver::Substring.new "4.alpha"
+        higher.should be_higher_than lower
+
+        higher = SemverStringer::Semver::Substring.new "alpha.11"
+        lower = SemverStringer::Semver::Substring.new "alpha.2"
+        higher.should be_higher_than lower
+      end
+
+      it "compares a number with an extra segment higher than one without" do
+        higher = SemverStringer::Semver::Substring.new "alpha.2.a"
+        lower = SemverStringer::Semver::Substring.new "alpha.2"
+        higher.should be_higher_than lower
+      end
+
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: semver_stringer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-29 00:00:00.000000000 Z
+date: 2012-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70278852677040 !ruby/object:Gem::Requirement
+  requirement: &70277379840900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: '2.8'
   type: :development
   prerelease: false
-  version_requirements: *70278852677040
+  version_requirements: *70277379840900
 description: See semver.org for the rules, or https://github.com/iantruslove/SemverStringer#readme
   for a little documentation.
 email: