naturalsorter 0.1.0 → 0.2.0

data/README.markdown

@@ -16,19 +16,40 @@ Because the default sort method does not recognize the numbers in the string. Th
 
 ## API
 
-This GEM has just 2 methods
+This GEM has 8 methods
 
 `Naturalsorter::Sorter.sort(array, caseinsesitive)`
 
-And this here for more advanced sorting
+`Naturalsorter::Sorter.sort_desc(array, caseinsesitive)`
+
+And this here for more advanced sorting. Where you can put in a array of objects and the method which should called on every object for comparison. 
 
 `Naturalsorter::Sorter.sort_by_method(array, method, caseinsesitive)`
 
+`Naturalsorter::Sorter.sort_by_method_desc(array, method, caseinsesitive)`
+
+This methods are based on a different algo. spezially optimizied for sorting version strings. 
+
+`Naturalsorter::Sorter.sort_version(array)`
+
+`Naturalsorter::Sorter.sort_version_desc(array)`
+
+This here is again for an array with objects. 
+
+`Naturalsorter::Sorter.sort_version_by_method(array, method)`
+
+`Naturalsorter::Sorter.sort_version_by_method_desc(array)`
+
+Get newest.
+
+`Naturalsorter::Sorter.get_newest_version(first, second)` 
+
+
 ## Installation 
 
 You should add this line to your Gemfile
 
-`gem 'naturalsorter', '0.1.0'`
+`gem 'naturalsorter', '0.2.0'`
 
 and run this command in your app root directory
 
@@ -46,9 +67,16 @@ If you have more advanced objects you want to sort, you should use the second me
 
 `Naturalsorter::Sorter.sort_by_method(users, "firstname", true)`
 
-that's it!
+Isn't that awesome?
+
+The next methods are based on my own implementation, optimized for sorting version strings like "1.1, 1.4, 1.10"
+
+`Naturalsorter::Sorter.sort_version(["1.10", "1.1", "1.2"])`
+
+will return the array ["1.1", "1.2", "1.10"]
+
 
 ## Alan Davies
 
-This project uses internal the natcmp implementation from Alan Davies. All glorry to him for his awesome work. 
+The first 4 methods in this librarie are internal based on the natcmp implementation from Alan Davies. All glorry to him for his awesome work. 
 

data/lib/naturalsorter.rb

@@ -1,5 +1,6 @@
 require "naturalsorter/version"
 require "natcmp"
+require "versioncmp"
 
 # naturalsorter.rb
 #
@@ -35,6 +36,14 @@ module Naturalsorter
       array.sort { |a,b| Natcmp.natcmp(a,b,caseinsesitive) }
     end
     
+    def self.sort_desc(array, caseinsesitive)
+      if (array.nil? || array.empty?)
+        return nil
+      end
+      array.sort { |a, b| Natcmp.natcmp(b,a,caseinsesitive) }
+    end
+    
+    
     # 'Natural order' sort for an array of objects. 
     def self.sort_by_method(array, method, caseinsesitive)
       if (array.nil? || array.empty?)
@@ -42,6 +51,73 @@ module Naturalsorter
       end
       array.sort { |a,b| Natcmp.natcmp(a.send(method),b.send(method),caseinsesitive) }
     end
+    
+    def self.sort_by_method_desc(array, method, caseinsesitive)
+      if (array.nil? || array.empty?)
+        return nil
+      end
+      array.sort { |a, b| Natcmp.natcmp(b.send(method),a.send(method),caseinsesitive) }
+    end    
+    
+    
+    def self.sort_version(array)
+      return nil if (array.nil? || array.empty?)
+      array.sort { |a,b| Versioncmp.compare( a, b ) }
+    end
+    
+    def self.sort_version_desc(array)
+      return nil if (array.nil? || array.empty?)
+      array.sort { |a,b| Versioncmp.compare( b, a ) }
+    end
+    
+    
+    
+    def self.sort_version_by_method(array, method)
+      return nil if (array.nil? || array.empty?)
+      array.sort { |a,b| Versioncmp.compare(a.send(method), b.send(method)) }
+    end
+    
+    def self.sort_version_by_method_desc(array, method)
+      return nil if (array.nil? || array.empty?)
+      array.sort { |a,b| Versioncmp.compare(b.send(method), a.send(method)) }
+    end
+    
+    
+    
+    def self.get_newest_version(first, second)
+      array = [first, second]
+      array = array.sort { |a,b| Versioncmp.compare( a, b ) }
+      array.last
+    end
+    
+    def self.is_version_current?(version, current_version)
+      version = version.gsub("~>", "")
+      versions = version.split(".")
+      currents = current_version.split(".")
+      min_length = versions.size
+      if currents.size < min_length
+        min_length = currents.size
+      end
+      min_length = min_length - 2
+      if min_length < 0
+        min_length = 0
+      end      
+      (0..min_length).each do |z|
+        ver = versions[z]
+        cur = currents[z]
+        if (cur > ver)
+          return false
+        end
+      end
+      if currents.size < versions.size
+        ver = versions[min_length + 1]
+        cur = currents[min_length + 1]
+        if cur > ver
+          return false
+        end
+      end
+      true
+    end
   
   end
   

data/lib/naturalsorter/version.rb

@@ -1,3 +1,3 @@
 module Naturalsorter
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/versioncmp.rb

@@ -0,0 +1,145 @@
+# versioncmp.rb
+#
+# Natural order comparison of two version strings
+# e.g. "1.10.beta" < "1.10" > "1.9"
+# which does not follow alphabetically
+#
+#
+# This implementation is Copyright (C) 2012 by Robert Reiz
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the authors be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+class Versioncmp
+
+  # 'Natural version order' comparison of two version strings
+  def self.compare(a, b)
+
+	  offset1 = 0;
+    offset2 = 0;
+
+    for i in 0..100
+      if offset1 >= a.length() || offset2 >= b.length() 
+        break
+      end
+
+      part1 = Versioncmp.getAPiece(offset1, a);
+      part2 = Versioncmp.getAPiece(offset2, b);
+      offset1 += part1.length() + 1;
+      offset2 += part2.length() + 1;
+
+      if ( part1.match(/^[0-9]+$/) != nil && part2.match(/^[0-9]+$/) != nil )
+        ai = part1;
+        bi = part2;
+        result = Versioncmp.compareInt(ai, bi);
+        if result != 0
+          return result;
+        else
+          next 
+        end
+      elsif ( part1.match(/^[0-9]+$/) == nil && part2.match(/^[0-9]+$/) == nil )
+        result = Versioncmp.compareString(part1, part2)
+        if (result != 0)
+          return result
+        else
+          next
+        end
+      else
+        if (part1.match(/^[0-9]+$/) != nil && part2.match(/^[0-9]+$/) == nil)
+          return 1;
+        else
+          return -1;
+        end
+      end
+	  end
+	  result = Versioncmp.checkForRC(a, b) 
+	  return result
+  end
+  
+  def self.compareInt(ai, bi)
+    return -1 if (ai < bi)
+    return 0 if (ai == bi)
+    return 1
+  end
+  
+  def self.compareString(a, b)
+    return 0 if a.eql? b
+    return -1 if a < b
+    return 1
+  end
+  
+  def self.checkForRC(a, b)
+    big = String.new(a)
+    small = String.new(b)
+    if (a.length() < b.length())
+      big = String.new(b)
+      small = String.new(a)
+    end
+    if (Versioncmp.isRc(big))
+      bigwithoutRc = big.gsub(/\.RC[1-9]*$/, "").gsub(/\.rc[1-9]*$/, "")
+      if (Versioncmp.compareString(bigwithoutRc, small) == 0)
+        return Versioncmp.getRcValue(a, b)
+      end
+    elsif (Versioncmp.isBeta(big))
+      bigwithoutBeta = big.gsub(/\.BETA[1-9]*$/, "").gsub(/\.beta[1-9]*$/, "")
+      if (Versioncmp.compareString(bigwithoutBeta, small) == 0)
+        return Versioncmp.getRcValue(a, b)
+      end
+    elsif (Versioncmp.isPre(big))
+      bigwithoutPre = big.gsub(/\.PRE[1-9]*$/, "").gsub(/\.pre[1-9]*$/, "")
+      if (Versioncmp.compareString(bigwithoutPre, small) == 0)
+        return Versioncmp.getRcValue(a, b)
+      end
+    end
+    return Versioncmp.compareString(big, small);
+  end
+  
+  def self.isRc(a)
+    return a.match(/.*RC[1-9]*$/) != nil || a.match(/.*rc[1-9]*$/) != nil;
+  end
+  
+  def self.isBeta(a)
+    return a.match(/.*BETA[1-9]*$/) != nil || a.match(/.*beta[1-9]*$/) != nil;
+  end
+  
+  def self.isPre(a)
+    return a.match(/.*PRE[1-9]*$/) != nil || a.match(/.*pre[1-9]*$/) != nil;
+  end
+  
+  def self.getAPiece(offset, cake)
+    for z in 0..100
+      offsetz = offset + z
+      if offsetz > cake.length() 
+        break
+      end
+      p = cake[offset..offset + z]
+      if ( p.match(/^[0-9]+$/) == nil )
+        break
+      end
+    end
+    if z > 0
+      z = z - 1
+    end
+    piece = cake[offset..offset + z ]
+    return piece
+  end
+  
+  def self.getRcValue(a, b)    
+    return 1 if (a.length() < b.length())
+    return -1
+  end
+
+end

data/spec/naturalsorter_spec.rb

@@ -2,16 +2,112 @@ require "naturalsorter"
 
 describe Naturalsorter::Sorter do
   
-  it "cba is abc" do
-    Naturalsorter::Sorter.sort(["c", "b", "a"], true).should eql(["a", "b", "c"])
+  describe "sort" do
+    it "cba is abc" do
+      Naturalsorter::Sorter.sort(["c", "b", "a"], true).should eql(["a", "b", "c"])
+    end
+    it "c400b5a1 is a1b5c400" do
+      Naturalsorter::Sorter.sort(["a400", "a5", "a1"], true).should eql(["a1", "a5", "a400"])
+    end
   end
-  
-  it "c400b5a1 is a1b5c400" do
-    Naturalsorter::Sorter.sort(["a400", "a5", "a1"], true).should eql(["a1", "a5", "a400"])
+  describe "sort_desc" do
+    it "cba is abc" do
+      Naturalsorter::Sorter.sort_desc(["c", "b", "a"], true).should eql(["c", "b", "a"])
+    end
+    it "c400b5a1 is a1b5c400" do
+      Naturalsorter::Sorter.sort_desc(["a5", "a400", "a1"], true).should eql(["a400", "a5", "a1"])
+    end
   end
   
-  it "c400b5a1 is a1b5c400" do
-    Naturalsorter::Sorter.sort_by_method(["a400", "a5", "a1"], "to_s", true).should eql(["a1", "a5", "a400"])
+  describe  "sort_by_method" do
+    it "c400b5a1 is a1b5c400" do
+      Naturalsorter::Sorter.sort_by_method(["a400", "a5", "a1"], "to_s", true).should eql(["a1", "a5", "a400"])
+    end
+  end
+  describe  "sort_by_method_desc" do
+    it "a5 a400 a1 is a400 a5 a1" do
+      Naturalsorter::Sorter.sort_by_method_desc(["a5", "a400", "a1"], "to_s", true).should eql(["a400", "a5", "a1"])
+    end
   end
+  
+  
+  describe "sort_version" do
+  
+    it "1.1, 1.0 is 1.0, 1.1" do
+      Naturalsorter::Sorter.sort_version(["1.1", "1.0"]).should eql(["1.0", "1.1"])
+    end
+    
+    it "1.0, 1.1 is 1.0, 1.1" do
+      Naturalsorter::Sorter.sort_version(["1.0", "1.1"]).should eql(["1.0", "1.1"])
+    end
+    
+    it "4.5, 1.0 is 1.0, 4.5" do
+      Naturalsorter::Sorter.sort_version(["4.5", "1.0"]).should eql(["1.0", "4.5"])
+    end
+    
+    it "1.0, 4.5 is 1.0, 4.5" do
+      Naturalsorter::Sorter.sort_version(["1.0", "4.5"]).should eql(["1.0", "4.5"])
+    end
+  
+    it "1.2, 1.1 is 1.1, 1.2" do
+      Naturalsorter::Sorter.sort_version(["0.4", "0.1", "1.1", "1.2", "1.0"]).should eql(["0.1", "0.4", "1.0", "1.1", "1.2"])
+    end
+
+    it "1.2, 1.1 is 1.1, 1.2" do
+      Naturalsorter::Sorter.sort_version(     ["0.4", "0.1", "1.1", "1.2", "1.0", "1.0.RC1"]).should eql(["0.1", "0.4", "1.0.RC1", "1.0", "1.1", "1.2"])
+    end
+
+    it "1.2, 1.1 is 1.1, 1.2" do
+      Naturalsorter::Sorter.sort_version_desc(["0.4", "0.1", "1.1", "1.2", "1.0", "1.0.RC1"]).should eql(["1.2", "1.1", "1.0", "1.0.RC1", "0.4", "0.1"])
+    end
+
+    it "1.2, 1.1 is 1.1, 1.2" do
+      Naturalsorter::Sorter.sort_version(["1.1", "1.2", "1.0"]).should eql(["1.0", "1.1", "1.2"])
+    end
 
+    it "sort with RC" do
+      Naturalsorter::Sorter.sort_version(["1.1", "1.1.RC1"]).should eql(["1.1.RC1", "1.1"])
+    end
+
+    it "sort with RC" do
+      Naturalsorter::Sorter.sort_version(["1.1.RC1", "1.1", "1.0"]).should eql(["1.0", "1.1.RC1", "1.1"])
+    end
+
+  end
+  
+  describe "is_version_current?" do 
+    it "returns true" do 
+      Naturalsorter::Sorter.is_version_current?("1.1.1", "1.1.9").should be_true
+    end
+    it "returns false" do 
+      Naturalsorter::Sorter.is_version_current?("1.1.1", "1.2.0").should be_false
+    end
+    it "returns false" do 
+      Naturalsorter::Sorter.is_version_current?("1.1.1", "1.2").should be_false
+    end
+    it "returns false" do 
+      Naturalsorter::Sorter.is_version_current?("1.1.1", "2.0").should be_false
+    end
+    it "returns false" do 
+      Naturalsorter::Sorter.is_version_current?("1.1.1", "2").should be_false
+    end
+  end
+  
+  describe "get_newest_version" do 
+    
+    it "returns 2.0" do
+      Naturalsorter::Sorter.get_newest_version("1.1", "2.0").should eql("2.0")
+    end
+    it "returns 1.1" do
+      Naturalsorter::Sorter.get_newest_version("1.1", "1.0").should eql("1.1")
+    end
+    it "returns 4.5" do
+      Naturalsorter::Sorter.get_newest_version("4.5", "1.0").should eql("4.5")
+    end
+    it "returns 1.0" do
+      Naturalsorter::Sorter.get_newest_version("1.0", "1.0").should eql("1.0")
+    end
+  
+  end
+  
 end

data/spec/versioncmp_spec.rb

@@ -0,0 +1,41 @@
+require "naturalsorter"
+
+describe Versioncmp do
+  
+  it "smaler" do
+    Versioncmp.compare("1.1", "1.2").should eql(-1)
+  end
+  
+  it "bigger" do
+    Versioncmp.compare("1.1", "1.0").should eql(1)
+  end
+  
+  it "equal" do
+    Versioncmp.compare("1.1", "1.1").should eql(0)
+  end
+  
+  it "equal RC" do
+    Versioncmp.compare("1.1.RC1", "1.1.RC1").should eql(0)
+  end
+  
+  it "smaller RC" do
+    Versioncmp.compare("1.1.RC1", "1.1").should eql(-1)
+  end
+  
+  it "smaller RC" do
+    Versioncmp.compare("1.1.rc1", "1.1").should eql(-1)
+  end
+  
+  it "bigger RC" do
+    Versioncmp.compare("1.1.rc3", "1.1.rc2").should eql(1)
+  end
+  
+  it "bigger RC than 1.0" do
+    Versioncmp.compare("1.1.RC1", "1.0").should eql(1)
+  end
+  
+  it "bigger RC than 1.0" do
+    Versioncmp.compare("1.1.RC1", "1.1").should eql(-1)
+  end
+
+end

metadata

@@ -1,45 +1,34 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: naturalsorter
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - reiz
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-01-08 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-04-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
+  requirement: &70285480167460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 6
-        version: "2.6"
+      - !ruby/object:Gem::Version
+        version: '2.6'
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: *70285480167460
 description: This GEM is sorting Arrays in a natural order. a2 < a10
-email: 
+email:
 - robert.reiz@gmx.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - README.markdown
@@ -47,37 +36,34 @@ files:
 - lib/natcmp.rb
 - lib/naturalsorter.rb
 - lib/naturalsorter/version.rb
+- lib/versioncmp.rb
 - naturalsorter.gemspec
 - spec/naturalsorter_spec.rb
-has_rdoc: true
+- spec/versioncmp_spec.rb
 homepage: https://github.com/reiz/naturalsorter
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: naturalsorter
-rubygems_version: 1.3.6
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Sorting arrays in natural order
-test_files: 
+test_files:
 - spec/naturalsorter_spec.rb
+- spec/versioncmp_spec.rb