sort_authority 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem*
+ext/**/*.bundle
+ext/**/*.o
+Gemfile.lock
+pkg

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2013 Wegowise Inc.
+
+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,53 @@
+# sort_authority
+
+Natural order string comparison using
+[natsort](http://sourcefrog.net/projects/natsort/)
+by [Martin Pool](http://sourcefrog.net/).
+
+### Getting Started
+
+If you're using Bundler, you can add `sort_authority` to your Gemfile:
+
+```ruby
+gem 'sort_authority'
+```
+
+Or manually install the gem using:
+
+```shell
+gem install sort_authority
+```
+
+### Usage
+
+```ruby
+# bad
+['9 Main Street', '10 Main Street'].sort
+# => ['10 Main Street', '9 Main Street']
+
+# good!
+require 'sort_authority/ext/enumerable'
+['9 Main Street', '10 Main Street'].natural_sort
+# => ['9 Main Street', '10 Main Street']
+```
+
+### Benchmarks
+
+Comparison of sorting an array `['x1'] * 100_000` with [naturalsort](https://rubygems.org/gems/naturalsort),
+[naturally](https://rubygems.org/gems/naturally), [natcmp](https://rubygems.org/gems/natcmp),
+and [sensible_sort](http://www.davekoelle.com/alphanum.html).
+
+```
+                 user     system      total        real
+sort             0.000000   0.000000   0.000000 (  0.001758)
+strnatcmp.c      0.030000   0.000000   0.030000 (  0.029083)
+naturalsort gem  0.060000   0.000000   0.060000 (  0.061879)
+naturally gem    0.990000   0.020000   1.010000 (  1.009634)
+natcmp gem       1.140000   0.010000   1.150000 (  1.141950)
+sensible_sort    2.280000   0.000000   2.280000 (  2.286274)
+```
+
+
+### Contributing
+
+Fork, branch, and pull-request.

data/Rakefile

@@ -0,0 +1,13 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end

data/ext/Rakefile

@@ -0,0 +1,8 @@
+require 'ffi-compiler/compile_task'
+
+FFI::Compiler::CompileTask.new('strnatcmp') do |c|
+  c.have_header?('ctype.h', '/usr/include')
+  c.have_header?('string.h', '/usr/include')
+  c.have_header?('assert.h', '/usr/include')
+  c.have_header?('stdio.h', '/usr/include')
+end

data/ext/strnatcmp.c

@@ -0,0 +1,178 @@
+/* -*- mode: c; c-file-style: "k&r" -*-
+
+  strnatcmp.c -- Perform 'natural order' comparisons of strings in C.
+  Copyright (C) 2000, 2004 by Martin Pool <mbp sourcefrog net>
+
+  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.
+*/
+
+
+/* partial change history:
+ *
+ * 2004-10-10 mbp: Lift out character type dependencies into macros.
+ *
+ * Eric Sosman pointed out that ctype functions take a parameter whose
+ * value must be that of an unsigned int, even on platforms that have
+ * negative chars in their default char type.
+ */
+
+#include <ctype.h>
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+
+#include "strnatcmp.h"
+
+
+/* These are defined as macros to make it easier to adapt this code to
+ * different characters types or comparison functions. */
+static inline int
+nat_isdigit(nat_char a)
+{
+     return isdigit((unsigned char) a);
+}
+
+
+static inline int
+nat_isspace(nat_char a)
+{
+     return isspace((unsigned char) a);
+}
+
+
+static inline nat_char
+nat_toupper(nat_char a)
+{
+     return toupper((unsigned char) a);
+}
+
+
+
+static int
+compare_right(nat_char const *a, nat_char const *b)
+{
+     int bias = 0;
+
+     /* The longest run of digits wins.  That aside, the greatest
+  value wins, but we can't know that it will until we've scanned
+  both numbers to know that they have the same magnitude, so we
+  remember it in BIAS. */
+     for (;; a++, b++) {
+    if (!nat_isdigit(*a)  &&  !nat_isdigit(*b))
+         return bias;
+    else if (!nat_isdigit(*a))
+         return -1;
+    else if (!nat_isdigit(*b))
+         return +1;
+    else if (*a < *b) {
+         if (!bias)
+        bias = -1;
+    } else if (*a > *b) {
+         if (!bias)
+        bias = +1;
+    } else if (!*a  &&  !*b)
+         return bias;
+     }
+
+     return 0;
+}
+
+
+static int
+compare_left(nat_char const *a, nat_char const *b)
+{
+     /* Compare two left-aligned numbers: the first to have a
+        different value wins. */
+     for (;; a++, b++) {
+    if (!nat_isdigit(*a)  &&  !nat_isdigit(*b))
+         return 0;
+    else if (!nat_isdigit(*a))
+         return -1;
+    else if (!nat_isdigit(*b))
+         return +1;
+    else if (*a < *b)
+         return -1;
+    else if (*a > *b)
+         return +1;
+     }
+
+     return 0;
+}
+
+
+static int strnatcmp0(nat_char const *a, nat_char const *b, int fold_case)
+{
+     int ai, bi;
+     nat_char ca, cb;
+     int fractional, result;
+
+     assert(a && b);
+     ai = bi = 0;
+     while (1) {
+    ca = a[ai]; cb = b[bi];
+
+    /* skip over leading spaces or zeros */
+    while (nat_isspace(ca))
+         ca = a[++ai];
+
+    while (nat_isspace(cb))
+         cb = b[++bi];
+
+    /* process run of digits */
+    if (nat_isdigit(ca)  &&  nat_isdigit(cb)) {
+         fractional = (ca == '0' || cb == '0');
+
+         if (fractional) {
+        if ((result = compare_left(a+ai, b+bi)) != 0)
+       return result;
+         } else {
+        if ((result = compare_right(a+ai, b+bi)) != 0)
+       return result;
+         }
+    }
+
+    if (!ca && !cb) {
+         /* The strings compare the same.  Perhaps the caller
+                  will want to call strcmp to break the tie. */
+         return 0;
+    }
+
+    if (fold_case) {
+         ca = nat_toupper(ca);
+         cb = nat_toupper(cb);
+    }
+
+    if (ca < cb)
+         return -1;
+    else if (ca > cb)
+         return +1;
+
+    ++ai; ++bi;
+     }
+}
+
+
+
+int strnatcmp(nat_char const *a, nat_char const *b) {
+     return strnatcmp0(a, b, 0);
+}
+
+
+/* Compare, recognizing numeric string and ignoring case. */
+int strnatcasecmp(nat_char const *a, nat_char const *b) {
+     return strnatcmp0(a, b, 1);
+}

data/ext/strnatcmp.h

@@ -0,0 +1,31 @@
+/* -*- mode: c; c-file-style: "k&r" -*-
+
+  strnatcmp.c -- Perform 'natural order' comparisons of strings in C.
+  Copyright (C) 2000, 2004 by Martin Pool <mbp sourcefrog net>
+
+  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.
+*/
+
+
+/* CUSTOMIZATION SECTION
+ *
+ * You can change this typedef, but must then also change the inline
+ * functions in strnatcmp.c */
+typedef char nat_char;
+
+int strnatcmp(nat_char const *a, nat_char const *b);
+int strnatcasecmp(nat_char const *a, nat_char const *b);

data/lib/sort_authority/ext/enumerable.rb

@@ -0,0 +1,17 @@
+module Enumerable
+  def natural_sort
+    sort {|a, b| SortAuthority.strnatcmp(a, b) }
+  end
+
+  def natural_sort!
+    sort! {|a, b| SortAuthority.strnatcmp(a, b) }
+  end
+
+  def natural_sort_by(&block)
+    sort {|a, b| SortAuthority.strnatcmp(block.call(a), block.call(b)) }
+  end
+
+  def natural_sort_by!(&block)
+    sort! {|a, b| SortAuthority.strnatcmp(block.call(a), block.call(b)) }
+  end
+end

data/lib/sort_authority/version.rb

@@ -0,0 +1,3 @@
+module SortAuthority
+  VERSION = '0.0.1'
+end

data/lib/sort_authority.rb

@@ -0,0 +1,8 @@
+require 'ffi'
+require 'ffi-compiler/loader'
+
+module SortAuthority
+  extend FFI::Library
+  ffi_lib FFI::Compiler::Loader.find('strnatcmp')
+  attach_function :strnatcmp, [:pointer, :pointer], :int
+end

data/sort_authority.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/sort_authority/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = 'sort_authority'
+  s.version = SortAuthority::VERSION
+  s.authors = ['Nathan Fixler']
+  s.email = 'nathan@fixler.org'
+  s.license = 'MIT'
+  s.summary = 'Natural order string comparison'
+  s.description = 'String ordering for humans.'
+  s.homepage = 'https://rubygems.org/gems/sort_authority'
+
+  s.files = `git ls-files`.split("\n")
+  s.extensions << 'ext/Rakefile'
+
+  s.add_dependency 'rake'
+  s.add_dependency 'ffi-compiler', '~> 0.1.3'
+
+  s.add_development_dependency 'minitest', '~> 5.0.0'
+end

data/test/benchmark_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+describe 'SortAuthority Benchmark' do
+  bench_performance_linear '#natural_sort' do |n|
+    ary = ['x1'] * n
+    ary.natural_sort
+  end
+end

data/test/ext/enumerable_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+describe Enumerable do
+  it 'natural sorts' do
+    assert_equal ['9m', '10m'], ['10m', '9m'].natural_sort
+  end
+
+  it 'natural sorts in place' do
+    actual = ['10m', '9m']
+    actual.natural_sort!
+    assert_equal ['9m', '10m'], actual
+  end
+
+  it 'natural sorts with a block' do
+    actual = []
+    actual << OpenStruct.new(name: 'hello world')
+    actual << OpenStruct.new(name: 'hello world 2')
+    actual << OpenStruct.new(name: 'hello 2 world')
+    assert_equal ['hello 2 world', 'hello world', 'hello world 2'],
+                 actual.natural_sort_by(&:name).map(&:name)
+  end
+
+  it 'natural sorts with a block in place' do
+    actual = []
+    actual << OpenStruct.new(name: 'hello world')
+    actual << OpenStruct.new(name: 'hello world 2')
+    actual << OpenStruct.new(name: 'hello 2 world')
+    actual.natural_sort_by!(&:name)
+    assert_equal ['hello 2 world', 'hello world', 'hello world 2'],
+                 actual.map(&:name)
+  end
+
+end

data/test/strnatcmp_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+describe 'strnatcmp' do
+  include SortAuthority
+
+  it 'sorts two empty strings' do
+    assert_equal 0, strnatcmp('', '')
+  end
+
+  it 'sorts two identical strings with letters' do
+    assert_equal 0, strnatcmp('x', 'x')
+  end
+
+  it 'sorts two identical strings with letters and numbers' do
+    assert_equal 0, strnatcmp('x1', 'x1')
+  end
+
+  it 'sorts letters (x < y)' do
+    assert_equal -1, strnatcmp('x', 'y')
+  end
+
+  it 'sorts letters (y > x)' do
+    assert_equal 1, strnatcmp('y', 'x')
+  end
+
+  it 'sorts letters and numbers (x1 < y1)' do
+    assert_equal -1, strnatcmp('x1', 'y1')
+  end
+
+  it 'sorts letters and numbers (y1 > x1)' do
+    assert_equal 1, strnatcmp('y1', 'x1')
+  end
+
+  it 'sorts letters and numbers (x1 < x2)' do
+    assert_equal -1, strnatcmp('x1', 'x2')
+  end
+
+  it 'sorts letters and numbers (x2 > x1)' do
+    assert_equal 1, strnatcmp('x2', 'x1')
+  end
+
+  it 'sorts numbers numerically' do
+    assert_equal -1, strnatcmp('9', '10')
+  end
+
+  it 'sorts multi-word strings that are equal' do
+    assert_equal 0, strnatcmp('x 1', 'x 1')
+  end
+
+  it 'sorts multi-word strings that are not equal' do
+    assert_equal -1, strnatcmp('x 1', 'x 2')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require_relative '../lib/sort_authority'
+require_relative '../lib/sort_authority/ext/enumerable'
+
+gem 'minitest'
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/benchmark'
+require 'ostruct'

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: sort_authority
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nathan Fixler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+description: String ordering for humans.
+email: nathan@fixler.org
+executables: []
+extensions:
+- ext/Rakefile
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ext/Rakefile
+- ext/strnatcmp.c
+- ext/strnatcmp.h
+- lib/sort_authority.rb
+- lib/sort_authority/ext/enumerable.rb
+- lib/sort_authority/version.rb
+- sort_authority.gemspec
+- test/benchmark_test.rb
+- test/ext/enumerable_test.rb
+- test/strnatcmp_test.rb
+- test/test_helper.rb
+homepage: https://rubygems.org/gems/sort_authority
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -215718808201645381
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -215718808201645381
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Natural order string comparison
+test_files: []