naturalsort 1.1.1 → 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 587a1c0cf0b42077845643ce2ad013bead1f21bb57418446bf222195385dab37
+  data.tar.gz: 9cc750189f4fc09d05e2c660fa1e6cfc25a4c098d5c9517880766e72e3e9b1a3
+SHA512:
+  metadata.gz: c24a24d6dac5e791157df9c868aebcfd1b8134480b197bd66a14536c9d14a2ae5174d22852346ab1c2c8c5938ace451913fc5c37d7c7af4b5ed613db1f740292
+  data.tar.gz: 0fb932df47946a2799e3defaeae455ffcf72dcc08b66f6589dbcb62c0b656b6990c822b4d05f0014853f0d2a642f31469172d506951053ec8b030570230ec604

data/CHANGELOG.md

@@ -0,0 +1,56 @@
+# Changelog
+
+## 1.3.0 - 2024-10-20
+
+* Remove `NaturalSort::Kernel` module.
+* Drop support for Ruby 2.7 and prior.
+* Add Github Actions and remove Travis CI.
+* Fixes issue where blank string breaks sorting.
+
+## 1.2.0 - 2013-10-10
+
+* DEPRECATION: deprecate `NaturalSort.naturalsort` and replace with `NaturalSort.sort`
+* Use `Array(object)` instead of `object.to_a` for implicit Array conversion
+* Remove unused private instance methods which were aliased to class methods
+* Make regexp objects as module constants
+* Reorganize directory/require structure to match conventions used in other gems. Core sorting functions are moved to new `NaturalSort::Engine` module.
+* Kernel: Only include into `Set` if Set is defined
+* Kernel: `Range#natural_sort` is now an alias to `Range#to_a`
+* Test: Upgrade to use Minitest gem
+* Test: Improve readability by using `%w()` syntax for arrays
+* Documentation: Convert all code documentation to TomDoc format
+* Admin: Remove rdoc generator which was not working
+* Admin: Add files .gitignore, Gemfile, gemspec, and cleanup Rakefile
+* Admin: Add Travis and CodeClimate
+* Admin: Migrate to Github
+
+## 1.1.1 - 2010-07-21
+
+* Fix typo error in some unit test
+* Remove copy/paste between naturalsort and natural_sort methods
+* Added samples in rdoc
+* Adding contribution from Sobe http://pastie.caboo.se/139803 (thanks mate)
+* Sort complex text list (see test_natural_sort_kernel.rb:107))
+* Fix more complex [string][number] pattern like:
+   ```ruby
+   ["x2-y08", "x2-g8", "x2-y7", "x8-y8"].natural_sort => ["x2-g8", "x2-y7", "x2-y08", "x8-y8"]
+   ["x02-y08", "x02-g8", "x2-y7", "x8-y8"].natural_sort => ["x02-g8", "x2-y7", "x02-y08", "x8-y8"]
+   ```
+* Fix bug in Range ordering:
+   ```ruby
+   (1..21).natural_sort => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
+   ```
+
+## 1.1.0 - 2008-01-08
+
+* Improve documentation to get better google results
+* Remove alias methods: `sort_natural`, `sort_alpha`, `alpha_sort`, `sort_alphabetical`, `alphabetical_sort`, `sort_alphanum`, `alphanum_sort`
+
+## 1.0.1 - 2007-12-18
+
+* Fix problem using as a static method
+* Refactoring code
+
+## 1.0.0 - 2007-12-14
+
+* Project creation

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2007 Benjamin Francisoud
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# NaturalSort
+
+NaturalSort is a simple library which implements a natural, human-friendly alphanumeric sort in Ruby.
+
+## Examples
+
+```ruby
+   %w[a1 a11 a12 a2 a21].natural_sort #=> %w[a1 a2 a11 a12 a21]
+   %w[a b c A B C].natural_sort       #=> %w[A a B b C c]
+   %w[x__2 x_1].natural_sort          #=> %w[x_1 x__2]
+   %w[x2-y08 x2-g8 x2-y7 x8-y8].natural_sort   #=> %w[x2-g8 x2-y7 x2-y08 x8-y8]
+   %w[x02-y08 x02-g8 x2-y7 x8-y8].natural_sort #=> %w[x02-g8 x2-y7 x02-y08 x8-y8]
+```
+
+## Features
+
+* Sort case insensitive
+* Sort underscore insensitive
+* Sort filename matching patterns
+* Sort mixed alpha and numeric "abc1", "abc12", "abc2", "a1b2" in correct order
+
+## Install
+
+#### With Bundler
+
+In your `Gemfile`:
+
+```ruby
+gem 'naturalsort'
+```
+
+or to optionally extend Ruby native objects:
+
+```ruby
+gem 'naturalsort', require: 'natural_sort_kernel'
+```
+
+#### From Command Line
+
+```cmd
+$ gem install naturalsort
+```
+
+## Usage
+
+#### Extend Ruby native enumerable objects
+
+`require 'natural_sort_kernel'` adds `natural_sort` methods to all native Ruby enumerable objects (Array, Hash, etc...)
+
+```ruby
+   require 'natural_sort_kernel'
+
+   %w[a b c A B C].natural_sort
+```
+
+#### Use as a module function
+
+```ruby
+   require 'natural_sort'  # unless using Bundler
+
+   NaturalSort.sort %w[a b c d A B C D]
+```
+
+#### Use comparator function as a standalone
+
+Adds `natural_sort` methods to Ruby native enumerable objects (Array, Hash, etc...)
+
+```ruby
+   person_1 = Person.new('Moe')
+   person_2 = Person.new('Larry')
+   person_3 = Person.new('Curly')
+
+   [person_1, person_2, person_3].sort{|a,b| NaturalSort.comparator(a.name, b.name)}  #=> [person_3, person_2, person_1]
+
+   %w[a b c A B C].natural_sort
+```
+
+#### Include into your own objects
+
+Can be used to add `#natural_sort` method to on any enumerable object or any object which implements `#to_a`
+
+```ruby
+   class TodoList < Array
+     include NaturalSort
+   end
+
+   todo_list = TodoList.new
+   todo_list << 'Wash car'
+   todo_list << 'Water plants'
+   todo_list << 'Feed dog'
+
+   todo_list.natural_sort #=> ['Feed dog', 'Wash car', 'Water plants']
+```
+
+## Authors
+
+* [Benjamin Francisoud](http://www.google.com/profiles/benjamin.francisoud)
+* [Johnny Shields](http://github.com/johnnyshields) (version 1.2.0+)
+
+## Contributing
+
+Fork -> Patch -> Spec -> Push -> Pull Request
+
+## Related Links
+
+Links related to the natural sorting problem:
+
+* http://www.codinghorror.com/blog/archives/001018.html
+* http://sourcefrog.net/projects/natsort/
+* http://be2.php.net/natsort
+* http://www.wellho.net/forum/Programming-in-Python-and-Ruby/Python-Sort-Order.html
+* http://www.davekoelle.com/alphanum.html
+* http://rikkus.info/arch/sensible_sort.rb
+* http://weblog.masukomi.org/2007/12/10/alphabetical-asciibetical
+* http://nedbatchelder.com/blog/200712.html#e20071211T054956
+
+## License
+
+Copyright (c) 2007 Benjamin Francisoud
+
+Licensed under the MIT License. Refer to LICENSE for details.

data/lib/natural_sort/base.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Public: The public interface for NaturalSort module
+# For method descriptions refer to NaturalSort::Engine
+#
+# Examples
+#
+#  require 'natural_sort'
+#  NaturalSort.sort ['a1', 'a12', 'a2']  #=> ['a1', 'a2', 'a12']
+#
+#  # or
+#
+#  require 'natural_sort_kernel'
+#  ['a', 'b', 'A', 'B'].natural_sort     #=> ['A', 'a', 'B', 'b']
+module NaturalSort
+
+  class << self
+    extend Forwardable
+
+    # Public: sort
+    #
+    # Signature
+    #
+    #   NaturalSort.sort(object)
+    #
+    # Refer to NaturalSort::Engine.sort
+    def_delegator :'NaturalSort::Engine', :sort
+
+    # Public: comparator
+    #
+    # Signature
+    #
+    #   NaturalSort.comparator(a, b)
+    #
+    # Refer to NaturalSort::Engine.comparator
+    def_delegator :'NaturalSort::Engine', :comparator
+
+    # Deprecated: Alias to NaturalSort.sort. Was deprecated in version 1.2.0.
+    # To be removed in version 2.0.0 (according to semver)
+    #
+    # object - the object to sort, which must either be an Enumerable or implement #to_a to be meaningful.
+    #
+    # Returns a sorted version of the object.
+    def naturalsort(object)
+      warn('NaturalSort.naturalsort is deprecated and will be removed. Use NaturalSort.sort instead')
+      NaturalSort::Engine.sort(object)
+    end
+  end
+
+  # Public: Main method to sort (other are just aliases). To be used when including
+  # NaturalSort into another object. Delegates to NaturalSort::Engine.sort
+  #
+  # Note that the object must either be an Enumerable or implement #to_a to be meaningful.
+  #
+  # Returns a sorted version of the object.
+  #
+  # Examples
+  #
+  #   require 'natural_sort'
+  #
+  #   class MyObject
+  #     include NaturalSort
+  #     def to_a
+  #       ['a3, a2, a1']
+  #     end
+  #   end
+  def natural_sort
+    NaturalSort::Engine.sort(self)
+  end
+end

data/lib/natural_sort/engine.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# Internal: Singleton module which sorts elements in a natural,
+# human-friendly alphanumeric order.
+module NaturalSort::Engine
+
+  # Internal: Main Regexp used to in natural sorting
+  REGEXP = /(^|\D+)(\d+|(\D$))/
+
+  # Internal: A Regexp used to detect numeric substrings
+  NUMERIC = /(\d+)/
+
+  class << self
+
+    # Internal: Static method to sort.
+    #
+    # object - any object that is enumerable or has a #to_a method.
+    #
+    # Returns a sorted version of the object.
+    #
+    # Examples:
+    #
+    #   NaturalSort.sort ['a1', 'a12', 'a2']  #=> ['a1', 'a2', 'a12']
+    def sort(object)
+      Array(object).sort do |a,b|
+        self.comparator(a,b)
+      end
+    end
+
+    # Internal: Comparator function used for sorting, which can be
+    # used as a standalone.
+    #
+    # a - the left-hand side of the comparator
+    # b - the right-hand side of the comparator
+    #
+    # Returns 0, 1, or -1
+    #
+    # Examples
+    #
+    #   [person1, person2, person3].sort{|a,b| NaturalSort.comparator(a.name, b.name)}
+    def comparator(a, b)
+      sa, sb = a.to_s, b.to_s
+      if (sa.downcase <=> sb.downcase) == 0 then sa <=> sb
+      else
+        na, nb = check_regexp(sa, sb)
+        na <=> nb
+      end
+    end
+
+    private
+
+    def check_regexp(sa, sb)
+      ma, mb = multireg(REGEXP,sa), multireg(REGEXP,sb)
+      it = 0
+      equal = 0
+      ret = [sa, sb]
+      while (it < [ma.size,mb.size].min) and (equal==0)
+        if (ma[it] and mb[it]) and (ma[it][1] and mb[it][1]) and (NUMERIC.match ma[it][0] and NUMERIC.match mb[it][0])
+          l = [ma[it][2].size,mb[it][2].size].max
+          ret = [format(ma[it], l), format(mb[it], l)]
+        else
+          ret = [ma[it][0].downcase, mb[it][0].downcase]
+        end
+        equal = ret[0] <=> ret[1]
+        it+=1
+      end
+      return ret[0], ret[1]
+    end
+
+    # format([a, 1], 3) => a001
+    # add leading zero
+    def format(match_data, length)
+      match_data[1].gsub('_', '').downcase + ("%0#{length}d" % match_data[2].to_i)
+    end
+
+    # return an array with
+    # regexp matchdata on str
+    def multireg(regpexp, str)
+      result = []
+      while regpexp.match(str)
+        result.push regpexp.match(str)
+        str = regpexp.match(str).post_match
+      end
+      result
+    end
+  end
+end

data/lib/natural_sort/kernel.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Enumerable
+  # Add #natural_sort method to Enumerable module.
+  #
+  # Examples
+  #
+  #   require 'natural_sort_kernel'
+  #   ['a1', 'a12', 'a2'].natural_sort     #=> ['a1', 'a2', 'a12']
+  #   ['a', 'b', 'A', 'B'].natural_sort    #=> ['A', 'a', 'B', 'b']
+  include NaturalSort
+end
+
+class Array
+  # Add #natural_sort method to Array class.
+  #
+  # Examples
+  #
+  #   require 'natural_sort_kernel'
+  #   ['a1', 'a12', 'a2'].natural_sort     #=> ['a1', 'a2', 'a12']
+  #   ['a', 'b', 'A', 'B'].natural_sort    #=> ['A', 'a', 'B', 'b']
+  include NaturalSort
+end
+
+class Range
+  # Add #natural_sort method to Range class, which aliases #to_a
+  #
+  # Examples
+  #
+  #   require 'natural_sort_kernel'
+  #   (1..11).natural_sort    #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+  alias :natural_sort :to_a
+end
+
+if defined?(Set)
+  class Set
+    # Add #natural_sort method to Set class, if it has been initialized.
+    #
+    # Examples
+    #
+    #   require 'set'
+    #   require 'natural_sort_kernel'
+    #   Set.new(['a', 'b', 'c', 'd', 'A', 'B', 'C', 'D']).natural_sort  #=> ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd']
+    include NaturalSort
+  end
+end
+
+class Hash
+  # Add #natural_sort method to Hash class.
+  #
+  # Examples
+  #
+  #   require 'natural_sort_kernel'
+  #   { "a" => "value", "b" => "value", "A" => "value", "B" => "value" }.natural_sort  #=>
+  #     [["A", "value"], ["a", "value"], ["B", "value"], ["b", "value"]]
+  include NaturalSort
+end

data/lib/natural_sort/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module NaturalSort
+  module Version
+    VERSION = '1.3.0'
+  end
+end

data/lib/natural_sort.rb

@@ -1,102 +1,6 @@
-# Sort elements in a natural / alphabetical / human friendly order.
-#     require 'natural_sort'
-#     
-#     NaturalSort::naturalsort ['a1', 'a12', 'a2']   #=> ['a1', 'a2', 'a12']
-# or
-#     require 'natural_sort_kernel'
-#     
-#     ['a', 'b', 'A', 'B'].natural_sort              #=> ['A', 'a', 'B', 'b']
-module NaturalSort
-  VERSION = '1.1.1'
-  
-  # call-seq:
-  #    NaturalSort::naturalsort(object)                     => array
-  # 
-  # Static method to sort.
-  # 
-  # *Usage*
-  #     NaturalSort::naturalsort ['a1', 'a12', 'a2']     #=> ['a1', 'a2', 'a12']
-  # 
-  # <tt>object</tt> can by any object that has to_a method.
-  def self.naturalsort(object)
-    sorted = object.to_a.sort do |a,b|
-      sa, sb = a.to_s, b.to_s
-      if ((sa.downcase <=> sb.downcase) == 0) then sa <=> sb
-      else
-        na, nb = check_regexp(sa, sb)
-        na <=> nb
-      end
-    end
-  end
-  
-  # call-seq:
-  #    object.natural_sort                     => array
-  # 
-  # Main method to sort (other are just aliases).
-  # 
-  # *Usage*
-  #     require 'natural_sort'
-  #     include NaturalSort
-  #     
-  #     object.natural_sort         #=> ['a1', 'a2', 'a12']
-  # 
-  # <tt>object</tt> can by any object that has a method <tt>to_a</tt>
-  # 
-  # See <tt>natural_sort_kernel.rb</tt> to add natural sort methods to default ruby objects.
-  # Enumerable , Array, Range, Set, Hash
-  def natural_sort
-    NaturalSort::naturalsort(to_a)
-  end
-  
-  private
-  
-  def self.check_regexp(sa, sb)
-    regexp = /(^|\D+)(\d+|(\D$))/
-    ma, mb = multireg(regexp,sa), multireg(regexp,sb)
-    it = 0
-    equal = 0
-    ret = ["",""]
-    numeric = /(\d+)/
-    while (it < [ma.size,mb.size].min) and (equal==0) 
-      if (ma[it] and mb[it]) and (ma[it][1] and mb[it][1]) \
-         and (numeric.match ma[it][0] and numeric.match mb[it][0])
-        l = [ma[it][2].size,mb[it][2].size].max
-        ret = [format(ma[it], l), format(mb[it], l)]
-      else 
-        ret = [ma[it][0].downcase, mb[it][0].downcase]
-      end
-      equal = ret[0] <=> ret[1]
-      it+=1
-    end
-    return ret[0], ret[1]
-  end
-  
-  def check_regexp(sa, sb)
-    NaturalSort::check_regexp(sa, sb)
-  end
-  
-  # format([a, 1], 3) => a001
-  # add leading zero
-  def self.format(match_data, length)
-    match_data[1].gsub("_", "").downcase + ("%0#{length}d" % match_data[2].to_i)
-  end
-  
-  def format(match_data, length)
-    NaturalSort::format(match_data, length)
-  end
-  
-  # return an array with
-  # rgpx  matchdata on str
-  def self.multireg rgpx, str
-    result = []
-    while rgpx.match str
-        result.push rgpx.match(str)
-        str = rgpx.match(str).post_match
-    end
-    result
-  end
-    
-  def multireg rgpx, str
-    NaturalSort::multireg(rgpx, str)
-  end
-end
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'natural_sort/version'
+require 'natural_sort/engine'
+require 'natural_sort/base'

data/lib/natural_sort_kernel.rb

@@ -1,47 +1,4 @@
-# Add natural sorting method to default Kernel ruby objects.
-require File.dirname(__FILE__) + '/natural_sort.rb'
-require 'set'
+# frozen_string_literal: true
 
-# Add NaturalSort methods.
-#     require 'natural_sort_kernel'
-#     
-#     ['a1', 'a12', 'a2'].alphanum_sort         #=> ['a1', 'a2', 'a12']
-#     ['a', 'b', 'A', 'B'].alphanum_sort        #=> ['A', 'a', 'B', 'b']
-module Enumerable
-  include NaturalSort
-end
-
-# Add NaturalSort methods.
-#     require 'natural_sort_kernel'
-#     
-#     ['a1', 'a12', 'a2'].alphanum_sort         #=> ['a1', 'a2', 'a12']
-#     ['a', 'b', 'A', 'B'].alphanum_sort        #=> ['A', 'a', 'B', 'b']
-class Array
-  include NaturalSort
-end
-
-# Add NaturalSort methods.
-#     require 'natural_sort_kernel'
-#     
-#     (1..21).alphanum_sort         #=> [1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9]
-class Range
-  include NaturalSort
-end
-
-# Add NaturalSort methods.
-#     require 'set'
-#     require 'natural_sort_kernel'
-#     
-  #     Set.new(['a', 'b', 'c', 'd', 'A', 'B', 'C', 'D']).alphanum_sort         #=> ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd']
-class Set
-  include NaturalSort
-end
-
-# Add NaturalSort methods.
-#     require 'natural_sort_kernel'
-#     
-#     { "a" => "value", "b" => "value", "c" => "value", "d" => "value", "A" => "value", "B" => "value", "C" => "value", "D" => "value" }.alphanum_sort
-#     => [["A", "value"], ["a", "value"], ["B", "value"], ["b", "value"], ["C", "value"], ["c", "value"], ["D", "value"], ["d", "value"]]
-class Hash
-  include NaturalSort
-end
+require 'natural_sort'
+require 'natural_sort/kernel'

metadata

@@ -1,121 +1,81 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: naturalsort
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 1
-  - 1
-  - 1
-  version: 1.1.1
+version: !ruby/object:Gem::Version
+  version: 1.3.0
 platform: ruby
-authors: 
-- Benjamin Francisoud
-autorequire: 
+authors:
+- Johnny Shields
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2010-07-21 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rubyforge
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
+date: 2024-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 0
-        - 4
-        version: 2.0.4
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: hoe
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 6
-        - 0
-        version: 2.6.0
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-description: |-
-  Examples: 
-    ['a1', 'a11', 'a12', 'a2', 'a21']       => ['a1', 'a2', 'a11', 'a12','a21']
-    ['a', 'b', 'c', 'A', 'B', 'C']          => ['A', 'a', 'B', 'b', 'C', 'c']
-    ['x__2', 'x_1']                         => ['x_1', 'x__2']
-    ['x2-y08', 'x2-g8', 'x2-y7', 'x8-y8']   => ['x2-g8', 'x2-y7', 'x2-y08', 'x8-y8']
-  * ['x02-y08', 'x02-g8', 'x2-y7', 'x8-y8'] => ['x02-g8', 'x2-y7', 'x02-y08', 'x8-y8']
-  
-  == Features:
-    
-  * sort case insensitive
-  * sort filename matching pattern "abc1", "abc12", "abc2" in the correct order
-  * sort filename matching pattern "a1b2"
-  * sort underscore insensitive
-  
-  == Install:
-  
-  * sudo gem install naturalsort
-email: pub.cog@gmail.com
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'Example: %w[1 2a A1 a11 A12 a2 a21 x__2 X_1].natural_sort => %w[1 2a
+  A1 a11 A12 a2 a21 x__2 X_1]'
+email: info@tablecheck.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- README.txt
-files: 
-- History.txt
-- Manifest.txt
-- README.txt
-- Rakefile
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
 - lib/natural_sort.rb
+- lib/natural_sort/base.rb
+- lib/natural_sort/engine.rb
+- lib/natural_sort/kernel.rb
+- lib/natural_sort/version.rb
 - lib/natural_sort_kernel.rb
-- test/test_helper.rb
-- test/test_natural_sort.rb
-- test/test_natural_sort_alone.rb
-- test/test_natural_sort_kernel.rb
-has_rdoc: true
-homepage: http://naturalsort.rubyforge.org/
-licenses: []
-
-post_install_message: 
-rdoc_options: 
-- --main
-- README.txt
-require_paths: 
+homepage: https://github.com/johnnyshields/naturalsort
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+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
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: naturalsort
-rubygems_version: 1.3.6
-signing_key: 
-specification_version: 3
-summary: NaturalSort is a small and simple library to implements a natural or human friendly alphabetical sort in ruby.
-test_files: 
-- test/test_natural_sort_alone.rb
-- test/test_helper.rb
-- test/test_natural_sort_kernel.rb
-- test/test_natural_sort.rb
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: NaturalSort is a simple library which implements a natural, human-friendly
+  alphanumeric sort in Ruby
+test_files: []

data/History.txt

@@ -1,24 +0,0 @@
-== 1.1.1 / 2010-07-21
-* Fix typo error in some unit test
-* Remove copy/paste between naturalsort and natural_sort methods
-* Added samples in rdoc
-* Adding contribution from Sobe http://pastie.caboo.se/139803 (thanks mate)
-* Sort complex text list (see test_natural_sort_kernel.rb:107))
-* Fix more complex [string][number] pattern like:
-* ["x2-y08", "x2-g8", "x2-y7", "x8-y8"].natural_sort => ["x2-g8", "x2-y7", "x2-y08", "x8-y8"]
-* ["x02-y08", "x02-g8", "x2-y7", "x8-y8"].natural_sort => ["x02-g8", "x2-y7", "x02-y08", "x8-y8"]
-* Fix bug in Range ordering:
-* (1..21).natural_sort => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
-
-== 1.1.0 / 2008-01-08
-* Improve documentation to get better google results
-* Remove alias methods: <tt>sort_natural, sort_alpha, alpha_sort, sort_alphabetical, alphabetical_sort, sort_alphanum, alphanum_sort</tt>
-
-== 1.0.1 / 2007-12-18
-
-* Fix problem using as a static method
-* Refactoring code
-
-== 1.0.0 / 2007-12-14
-
-* Project creation

data/Manifest.txt

@@ -1,10 +0,0 @@
-History.txt
-Manifest.txt
-README.txt
-Rakefile
-lib/natural_sort.rb
-lib/natural_sort_kernel.rb
-test/test_helper.rb
-test/test_natural_sort.rb
-test/test_natural_sort_alone.rb
-test/test_natural_sort_kernel.rb

data/README.txt

@@ -1,87 +0,0 @@
-NaturalSort
-http://naturalsort.rubyforge.org/
-
-== Description:
-  
-NaturalSort is a small and simple library to implements a natural or human alphabetical sort in ruby.
-It's sometimes call: 
-* natural sort
-* alpha sort
-* alphabetical sort
-* alphanum sort
-
-Examples: 
-  ['a1', 'a11', 'a12', 'a2', 'a21']       => ['a1', 'a2', 'a11', 'a12','a21']
-  ['a', 'b', 'c', 'A', 'B', 'C']          => ['A', 'a', 'B', 'b', 'C', 'c']
-  ['x__2', 'x_1']                         => ['x_1', 'x__2']
-  ['x2-y08', 'x2-g8', 'x2-y7', 'x8-y8']   => ['x2-g8', 'x2-y7', 'x2-y08', 'x8-y8']
-* ['x02-y08', 'x02-g8', 'x2-y7', 'x8-y8'] => ['x02-g8', 'x2-y7', 'x02-y08', 'x8-y8']
-
-== Features:
-  
-* sort case insensitive
-* sort filename matching pattern "abc1", "abc12", "abc2" in the correct order
-* sort filename matching pattern "a1b2"
-* sort underscore insensitive
-
-== Install:
-
-* sudo gem install naturalsort
-
-== Synopsis:
-
-=== Usage N�1 - Add to your ruby default objects
-Add natural sort methods to ruby default object (Array, Hash, etc...)
-
-  require 'natural_sort_kernel'
-  
-  sorted = ['a', 'b', 'c', 'd', 'A', 'B', 'C', 'D'].natural_sort
-  ...
-
-=== Usage N�2  - Use only one method
-
-  require 'natural_sort'
-  
-  sorted = NaturalSort::naturalsort ['a', 'b', 'c', 'd', 'A', 'B', 'C', 'D']
-
-== About
-
-* Rubyforge project page http://rubyforge.org/projects/naturalsort
-* Author: Benjamin Francisoud http://www.google.com/profiles/benjamin.francisoud
-
-== Related Links
-
-Links related to the alphabetical sorting problem:
-* http://www.codinghorror.com/blog/archives/001018.html
-* http://sourcefrog.net/projects/natsort/
-* http://be2.php.net/natsort
-* http://www.wellho.net/forum/Programming-in-Python-and-Ruby/Python-Sort-Order.html
-* http://www.davekoelle.com/alphanum.html
-* http://rikkus.info/arch/sensible_sort.rb
-* http://weblog.masukomi.org/2007/12/10/alphabetical-asciibetical
-* http://nedbatchelder.com/blog/200712.html#e20071211T054956
-
-== License:
-
-(The MIT License)
-
-Copyright (c) 2007 Benjamin Francisoud
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,30 +0,0 @@
-# -*- ruby -*-
-
-require 'rubygems'
-require 'hoe'
-require './lib/natural_sort.rb'
-
-Hoe.new('naturalsort', NaturalSort::VERSION) do |p|
-  p.rubyforge_name = 'naturalsort'
-  p.author = 'Benjamin Francisoud'
-  p.email = 'pub.cog@gmail.com'
-  p.summary = 'NaturalSort is a small and simple library to implements a natural or human friendly alphabetical sort in ruby.'
-  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
-  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
-  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
-  p.remote_rdoc_dir = '' # Release to root
-  p.need_zip = true
-end
-
-SVN = 'svn+ssh://cogito@rubyforge.org/var/svn/naturalsort'
-
-task :svn_branch => [:clean] do
-  `svn delete #{SVN}/branches/1.X -m "cleanup branch"`
-  `svn copy #{SVN}/trunk #{SVN}/branches/1.X -m "create branch"`
-end
-
-task :svn_tag do
-  `svn copy #{SVN}/trunk #{SVN}/tags/#{NaturalSort::VERSION} -m "create tag"`
-end
-
-# vim: syntax=Ruby

data/test/test_helper.rb

@@ -1,29 +0,0 @@
-require 'test/unit'
-
-module NaturalSort
-  Base = ['a', 'b', 'c', 'd', 'A', 'B', 'C', 'D']
-  BaseSorted = ['A', 'a', 'B', 'b', 'C', 'c', 'D', 'd']
-  
-  Complex = ['1000X Radonius Maximus', '10X Radonius', '200X Radonius', '20X Radonius', 
-    '20X Radonius Prime', '30X Radonius', '40X Radonius', 'Allegia 50 Clasteron', 
-    'Allegia 500 Clasteron', 'Allegia 51 Clasteron', 'Allegia 51B Clasteron', 'Allegia 52 Clasteron', 
-    'Allegia 60 Clasteron', 'Alpha 100', 'Alpha 2', 'Alpha 200', 'Alpha 2A', 'Alpha 2A-8000', 
-    'Alpha 2A-900', 'Callisto Morphamax', 'Callisto Morphamax 500', 'Callisto Morphamax 5000', 
-    'Callisto Morphamax 600', 'Callisto Morphamax 700', 'Callisto Morphamax 7000', 
-    'Callisto Morphamax 7000 SE', 'Callisto Morphamax 7000 SE2', 'QRS-60 Intrinsia Machine', 
-    'QRS-60F Intrinsia Machine', 'QRS-62 Intrinsia Machine', 'QRS-62F Intrinsia Machine', 
-    'Xiph Xlater 10000', 'Xiph Xlater 2000', 'Xiph Xlater 300', 'Xiph Xlater 40', 
-    'Xiph Xlater 5', 'Xiph Xlater 50', 'Xiph Xlater 500', 'Xiph Xlater 5000', 'Xiph Xlater 58']
-  
-  ComplexSorted = ['10X Radonius', '20X Radonius', '20X Radonius Prime', '30X Radonius', 
-    '40X Radonius', '200X Radonius', '1000X Radonius Maximus', 'Allegia 50 Clasteron', 
-    'Allegia 51 Clasteron', 'Allegia 51B Clasteron', 'Allegia 52 Clasteron', 
-    'Allegia 60 Clasteron', 'Allegia 500 Clasteron', 'Alpha 2', 'Alpha 2A', 'Alpha 2A-900', 
-    'Alpha 2A-8000', 'Alpha 100', 'Alpha 200', 'Callisto Morphamax', 'Callisto Morphamax 500',
-    'Callisto Morphamax 600', 'Callisto Morphamax 700', 'Callisto Morphamax 5000', 
-    'Callisto Morphamax 7000', 'Callisto Morphamax 7000 SE', 'Callisto Morphamax 7000 SE2',
-    'QRS-60 Intrinsia Machine', 'QRS-60F Intrinsia Machine', 'QRS-62 Intrinsia Machine', 
-    'QRS-62F Intrinsia Machine', 'Xiph Xlater 5', 'Xiph Xlater 40', 'Xiph Xlater 50',
-    'Xiph Xlater 58', 'Xiph Xlater 300', 'Xiph Xlater 500', 'Xiph Xlater 2000', 
-    'Xiph Xlater 5000', 'Xiph Xlater 10000']
-end

data/test/test_natural_sort.rb

@@ -1,55 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-require File.dirname(__FILE__) + '/../lib/natural_sort.rb'
-
-class MyClass
-  include NaturalSort
-  
-  def initialize(array = Base)
-    @array = array
-  end
-  
-  def to_a
-    @array
-  end
-end
-
-# Test without include
-class TestNaturalSortSelf < Test::Unit::TestCase
-  def test_self
-    assert_equal NaturalSort::BaseSorted, NaturalSort::naturalsort(NaturalSort::Base)
-  end
-end
-
-# Test using include
-class TestNaturalSort < Test::Unit::TestCase
-  include NaturalSort
-  
-  def setup
-    @obj = MyClass.new
-  end
-  
-  def test_case_sensitive
-    sorted = @obj.natural_sort
-    assert_equal BaseSorted, sorted
-  end
-  
-  def test_mixed
-    obj = MyClass.new ['a1', 'a12', 'A11', 'a2', 'a10', 'A3', 'a21', 'A29']
-    assert_equal ['a1', 'a2', 'A3', 'a10', 'A11', 'a12', 'a21', 'A29'], obj.natural_sort
-  end
-  
-  def test_numbers
-    obj = MyClass.new ['a1', 'a12', 'a11', 'a2', 'a10', 'a3', 'a21', 'a29']
-    assert_equal ['a1', 'a2', 'a3', 'a10', 'a11', 'a12', 'a21', 'a29'], obj.natural_sort
-  end
-
-  def test_first_no_number
-    obj = MyClass.new ['aaa2', 'aaa3', 'aaa4', 'aaa']
-    assert_equal ['aaa', 'aaa2', 'aaa3', 'aaa4'], obj.natural_sort
-  end
-
-  def test_number_leading_zero
-    obj = MyClass.new ["A001", "A08", "A007", "A003", "A011", "A20", "A200"]
-    assert_equal ["A001", "A003", "A007", "A08", "A011", "A20", "A200"], obj.natural_sort
-  end
-end

data/test/test_natural_sort_alone.rb

@@ -1,9 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-require File.dirname(__FILE__) + '/../lib/natural_sort.rb'
-
-# Test without include
-class TestNaturalSortAlone < Test::Unit::TestCase
-  def test_alone
-    assert_equal NaturalSort::BaseSorted, NaturalSort::naturalsort(NaturalSort::Base)
-  end
-end

data/test/test_natural_sort_kernel.rb

@@ -1,109 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-require File.dirname(__FILE__) + '/../lib/natural_sort_kernel.rb'
-
-class TestEnum
-  include Enumerable
-  def to_a
-    NaturalSort::Base
-  end
-end
-
-class TestNaturalSortKernel < Test::Unit::TestCase
-  
-  def test_empty
-    assert_equal(['', ''], ['', ''].natural_sort)
-  end
-  
-  def test_enum
-    enum = TestEnum.new
-    assert_equal NaturalSort::BaseSorted, enum.natural_sort
-  end
-  
-  def test_array
-    assert_equal NaturalSort::BaseSorted, NaturalSort::Base.natural_sort
-  end
-  
-  def test_range
-    expected = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
-    assert_equal expected, (1..21).natural_sort
-  end
-  
-  def test_set
-    set = Set.new NaturalSort::Base
-    assert_equal NaturalSort::BaseSorted, set.natural_sort
-  end
-  
-  def test_hash
-    expected = [["A", "value"], ["a", "value"], ["B", "value"], ["b", "value"],
-                ["C", "value"], ["c", "value"], ["D", "value"], ["d", "value"]]
-    hash = { "a" => "value", "b" => "value", "c" => "value", "d" => "value", "A" => "value", "B" => "value", "C" => "value", "D" => "value" }
-    assert_equal expected, hash.natural_sort
-  end
-  
-    def test_identical_simple
-      assert_equal(['x', 'x'], ['x', 'x'].natural_sort)
-    end
-
-    def test_identical_two_groups
-      assert_equal(['x1', 'x1'], ['x1', 'x1'].natural_sort)
-    end
-
-    def test_ordered_simple
-      assert_equal(['x', 'y'], ['x', 'y'].natural_sort)
-    end
-
-    def test_ordered_simple_start_backwards
-      assert_equal(['x', 'y'], ['y', 'x'].natural_sort)
-    end
-
-    def test_ordered_two_groups
-      assert_equal(['x1', 'x2'], ['x1', 'x2'].natural_sort)
-    end
-
-    def test_ordered_two_groups_start_backwards
-      assert_equal(['x1', 'x2'], ['x2', 'x1'].natural_sort)
-    end
-
-    def test_ordered_two_groups_separated
-      assert_equal(['x_1', 'x_2'], ['x_2', 'x_1'].natural_sort)
-    end
-
-    def test_ordered_two_groups_separated_different_distances
-      assert_equal(['x_1', 'x__2'], ['x__2', 'x_1'].natural_sort)
-    end
-
-    def test_ordered_two_groups_separated_different_distances_swapped
-      assert_equal(['x__1', 'x_2'], ['x_2', 'x__1'].natural_sort)
-    end
-
-    def test_three_groups
-      assert_equal(
-        ['hello 2 world', 'hello world', 'hello world 2'],
-        ['hello world', 'hello world 2', 'hello 2 world'].natural_sort
-      )
-    end
-    
-    def test_decimal
-      # 1.001 < 1.002 < 1.010 < 1.02 < 1.1 < 1.3
-      # assert_equal ['1.001', '1.002', '1.010', '1.02', '1.1', '1.3'], ['1.1', '1.001', '1.002', '1.010', '1.02', '1.3'].natural_sort, "FIXME this test doesn't pass and need to be fix"
-    end
-    
-    def test_multiple_string_number
-      # x2-g8 < x2-y7 < x2-y08 < x8-y8
-      assert_equal ['x2-g8', 'x2-y7', 'x2-y08', 'x8-y8'], ['x2-y08', 'x8-y8', 'x2-y7', 'x2-g8'].natural_sort
-    end
-    
-    # same as test_multiple_string_number but first number has (sometimes) leading zero
-    def test_multiple_string_number_2
-      # x2-g8 < x2-y7 < x2-y08 < x8-y8
-      assert_equal ['x02-g8', 'x2-y7', 'x02-y08', 'x8-y8'], ['x02-y08', 'x8-y8', 'x2-y7', 'x02-g8'].natural_sort
-    end
-    
-    def test_filename
-      assert_equal ["img1.png", "img2.png", "img10.png", "img12.png"], ["img12.png", "img10.png", "img2.png", "img1.png"].natural_sort
-    end
-    
-    def test_complex
-      assert_equal NaturalSort::ComplexSorted, NaturalSort::Complex.natural_sort
-    end
-end