natural_sort 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2dfd714b89645e2d4fc0026d19e90f0281422d61
-  data.tar.gz: 3164c7c67926ff12f6cc1231cb38195000f14da1
+SHA256:
+  metadata.gz: 354422d90d16ba088c221c5d69e708a0abe72c3fcc693016144b7b36237cd106
+  data.tar.gz: c05143277661784e8de74e8acf05100eeaee1bc53566bc0ff4b61e8e8ef4bcc6
 SHA512:
-  metadata.gz: ecfff960d299ddae782abd505017044ee7d3bcbcf3ca34bc4538b2412ef5632b84d72dfc99f98e9adaa906798cfb78254521e4813e7c6ab04e56eb916852eea4
-  data.tar.gz: e996ca5915e77c65a77e063bc7459663a0d9e69e8f52eb105d2413f8de350896deded52e8b73c43d41352984c9a568f65cb9e7f7be4452b054840a18094c1be9
+  metadata.gz: c5f16a6eeeb80cc07bb97891d8c77ce4d4a063b1fd276d760b4c5d4fc0bfd06729ce870bc82132cbd534ebc9fe1b25bbe0137ba9d0dca2eacaf35ffa48a125de
+  data.tar.gz: e441af4a1085b92b999f9e8f5da4cf1e71b20aa4e74fd35f135b1122fed609e9c8d74a852522731a3ef1a36853e7199add5558f5df134cb60e3263aa6fded225

data/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to this project are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). The sort
+order itself is part of the public API — a change to how strings are ordered is
+a breaking change.
+
+## [1.0.0] - 2026-06-14
+
+First stable release.
+
+Ordering is a faithful port of Martin Pool's natural-order string comparison
+(the algorithm PHP's `strnatcmp` uses), so results are reference-defined.
+Ordering may differ from the 0.x series — review your sort output before
+upgrading, and pin with `~> 1.0`.
+
+- Faithful `strnatcmp` ordering: leading-zero digit runs compare as text,
+  whitespace is insignificant on its own, non-digit bytes compare by byte value
+  (case-sensitive), and arbitrarily large integers compare exactly.
+- Plugs into Ruby's own sort methods: `NaturalSort.sort`, `.sort!`, `.compare`,
+  `.key`, and `&NaturalSort` as a comparison block.
+- `NaturalSort::Key` is a frozen, immutable comparison key.
+- Tolerates malformed or ASCII-incompatible encodings, sorting by byte value
+  instead of raising.
+- Opt-in extras kept out of the default require: the `NaturalSort()` Kernel
+  helper (`require "natural_sort/kernel"`) and `Array`/`Hash`/`Set` refinements
+  (`require "natural_sort/refinements"`).
+- Requires Ruby 3.3 or newer.
+
+## [0.3.0] - 2018-09-27
+
+- Handle additional edge cases for multi-segment numbers.
+
+## [0.2.0] - 2016-11-14
+
+- Add `NaturalSort.sort!` and expand the usage examples.
+
+## [0.1.0] - 2016-01-03
+
+- Initial release.
+
+[1.0.0]: https://github.com/rwz/natural_sort/compare/v0.3.0...v1.0.0
+[0.3.0]: https://github.com/rwz/natural_sort/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/rwz/natural_sort/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/rwz/natural_sort/releases/tag/v0.1.0

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Pavel Pravosud
+Copyright (c) 2015-2026 Pavel Pravosud
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,92 +1,175 @@
 # Natural Sort
 
-[![Build Status](https://api.travis-ci.org/rwz/natural_sort.svg?branch=master)][travis]
-[![Gem Version](http://img.shields.io/gem/v/natural_sort.svg)][gem]
-[![Code Climate](http://img.shields.io/codeclimate/github/rwz/natural_sort.svg)][codeclimate]
+[![CI](https://github.com/rwz/natural_sort/actions/workflows/ci.yml/badge.svg)][ci]
+[![Gem Version](https://img.shields.io/gem/v/natural_sort.svg)][gem]
 
-[travis]: https://travis-ci.org/rwz/natural_sort
+[ci]: https://github.com/rwz/natural_sort/actions/workflows/ci.yml
 [gem]: https://rubygems.org/gems/natural_sort
-[codeclimate]: https://codeclimate.com/github/rwz/natural_sort
 
-Natual sorting implementation in Ruby.
+Natural-sort ordering for Ruby — sort strings the way people read them, so
+`"a2"` comes before `"a10"` instead of after it.
+
+```ruby
+%w[a1 a10 a2].sort               # => ["a1", "a10", "a2"]   # lexical: a10 before a2
+NaturalSort.sort(%w[a1 a10 a2])  # => ["a1", "a2", "a10"]   # natural
+```
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add it to your Gemfile:
 
 ```ruby
 gem "natural_sort"
 ```
 
-And then execute:
+…then `bundle install`. Or grab it directly:
 
-    $ bundle
-
-Or install it yourself as:
+```
+$ gem install natural_sort
+```
 
-    $ gem install natural_sort
+Requires Ruby 3.3 or newer.
 
 ## Usage
 
+`NaturalSort` is a comparator that plugs into Ruby's own sort methods — it
+doesn't replace them.
+
 ```ruby
-list = ["a10", "a", "a20", "a1b", "a1a", "a2", "a0", "a1"]
-list.sort(&NaturalSort) # => ["a", "a0", "a1", "a1a", "a1b", "a2", "a10", "a20"]
+list = %w[a10 a a20 a1b a1a a2 a0 a1]
+
+NaturalSort.sort(list)   # => ["a", "a0", "a1", "a1a", "a1b", "a2", "a10", "a20"]
+NaturalSort.sort!(list)  # same, but sorts `list` in place and returns it
+list.sort(&NaturalSort)  # NaturalSort works directly as the comparison block
 ```
 
+`sort(&NaturalSort)` works because the module is a *comparator*. To sort by a
+*derived* value you want a *key* instead — `NaturalSort.key(x)`, or the
+`NaturalSort()` helper — for `sort_by`, `min_by`, and friends:
+
 ```ruby
-list = ["a10", "a", "a20", "a1b", "a1a", "a2", "a0", "a1"]
-NaturalSort.sort(list)  # => ["a", "a0", "a1", "a1a", "a1b", "a2", "a10", "a20"]
+require "natural_sort/kernel"
+
+UbuntuRelease = Struct.new(:number, :name)
+
+releases = [
+  UbuntuRelease.new("9.04",    "Jaunty Jackalope"),
+  UbuntuRelease.new("10.10",   "Maverick Meerkat"),
+  UbuntuRelease.new("8.10",    "Intrepid Ibex"),
+  UbuntuRelease.new("10.04.4", "Lucid Lynx"),
+  UbuntuRelease.new("9.10",    "Karmic Koala"),
+]
+
+releases.sort_by { |release| NaturalSort(release.number) }
+# => 8.10, 9.04, 9.10, 10.04.4, 10.10
 ```
 
+`NaturalSort()` is a global helper — a `Kernel` method in the spirit of
+`Integer()` or `Array()`. It lives in a separate file so that requiring the gem
+(or its refinements) never adds a method to every object unless you explicitly
+ask for it with `require "natural_sort/kernel"`. If you'd rather not add a
+global method, `NaturalSort.key(value)` does the same thing:
+
 ```ruby
-list = ["a10", "a", "a20", "a1b", "a1a", "a2", "a0", "a1"]
-NaturalSort.sort! list  # => ["a", "a0", "a1", "a1a", "a1b", "a2", "a10", "a20"]
-list  # => ["a", "a0", "a1", "a1a", "a1b", "a2", "a10", "a20"]
+releases.sort_by { |release| NaturalSort.key(release.number) }
 ```
 
+**Performance.** `NaturalSort.sort` and `sort_by` with a `NaturalSort.key` build
+one key per element; `&NaturalSort` re-splits both strings on every comparison
+(so roughly `n log n` key builds instead of `n`). For large arrays, prefer the
+key-based forms.
+
+Keys are immutable and safe to share across threads, so you can build one once
+and reuse it — e.g. cache keys when sorting the same data repeatedly.
+
+## How it sorts
+
+`NaturalSort` is a faithful port of [Martin Pool's natural-order string
+comparison][natsort] — the same algorithm PHP's `strnatcmp` uses. When an
+ordering looks ambiguous, that implementation is the source of truth.
+
+Each string is split into runs of digits and runs of non-digits, then compared
+segment by segment:
+
+- **Numbers compare numerically** — `"a2"` sorts before `"a10"`, and arbitrarily
+  large integers compare exactly (no float rounding or overflow).
+- **Everything else compares by byte value** (case-sensitive ASCII), so every
+  uppercase letter sorts before every lowercase one.
+- **A digit run with a leading zero is treated as text**, so fraction- and
+  version-like strings order the way you'd expect:
+
+  ```ruby
+  NaturalSort.sort(%w[1.1 1.02 1.002])  # => ["1.002", "1.02", "1.1"]
+  ```
+- **Whitespace is skipped** — it never affects ordering on its own, though it
+  still separates adjacent digit runs.
+
+Comparison is byte-based and not locale-aware: non-ASCII bytes sort by byte
+value (for valid UTF-8, that's the same as codepoint order), and malformed or
+non-ASCII-compatible input — UTF-16, stray bytes — is ordered by byte rather
+than raising.
+
+[natsort]: https://github.com/sourcefrog/natsort
+
+## Surprising cases
+
+Because this matches `strnatcmp` exactly, it inherits a few results that catch
+people off guard — all consequences of the rules above:
+
 ```ruby
-UbuntuRelease = Struct.new(:number, :name)
+# A leading zero makes a number sort like a fraction, so "08" and "09" land
+# BEFORE "1" — not where you'd put the eighth and ninth items.
+NaturalSort.sort(%w[10 08 1 09 2])   # => ["08", "09", "1", "2", "10"]
+NaturalSort.sort(%w[1.5 1.50 1.05])  # => ["1.05", "1.5", "1.50"]
+
+# Among themselves, leading-zero numbers compare as text, so "01333" sorts
+# BEFORE "0400" and "0401" — '1' beats '4' even though 1333 > 400.
+NaturalSort.sort(%w[0400 01333 0401])  # => ["01333", "0400", "0401"]
+
+# Whitespace is insignificant, so these compare equal...
+NaturalSort.compare("a b", "ab")     # => 0
+# ...but it still splits a number in two, so "1 0" is [1, 0], not 10:
+NaturalSort.compare("1 0", "10")     # => -1
+
+# Case-sensitive byte order: every uppercase letter sorts before every
+# lowercase one (so "Z" sorts before "a").
+NaturalSort.sort(%w[banana Apple apple Banana])
+# => ["Apple", "Banana", "apple", "banana"]
+```
 
-ubuntu_releases = [
-  UbuntuRelease.new("9.04", "Jaunty Jackalope"),
-  UbuntuRelease.new("10.10", "Maverick Meerkat"),
-  UbuntuRelease.new("8.10", "Intrepid Ibex"),
-  UbuntuRelease.new("10.04.4", "Lucid Lynx"),
-  UbuntuRelease.new("9.10", "Karmic Koala"),
-]
+Want case-insensitive ordering? Normalize your keys:
 
-ubuntu_releases.sort_by { |v| NaturalSort(v.number) }
-# => [
-#   UbuntuRelease.new("8.10", "Intrepid Ibex"),
-#   UbuntuRelease.new("9.04", "Jaunty Jackalope"),
-#   UbuntuRelease.new("9.10", "Karmic Koala"),
-#   UbuntuRelease.new("10.04.4", "Lucid Lynx"),
-#   UbuntuRelease.new("10.10", "Maverick Meerkat")
-# ]
+```ruby
+%w[img10 IMG2 img1].sort_by { |s| NaturalSort.key(s.downcase) }
+# => ["img1", "IMG2", "img10"]
 ```
 
 ## Refinements
 
-If you're running ruby 2.1 or newer, you can use refinements.
+Prefer calling methods directly? Opt into `natural_sort` and `natural_sort_by`
+on `Array`, `Hash`, and `Set`:
 
 ```ruby
-require "natural_sort/refinments"
+require "natural_sort/refinements"
 
-class MyClass
-  using NatualSort
+using NaturalSort
 
-  list.natural_sort                        # => ["a", "a0", "a1", "a1a"...
-  ubuntu_releases.natural_sort_by(&:number) # => [ UbuntuRelease.new("8.10"...
-end
+%w[a1 a10 a2].natural_sort           # => ["a1", "a2", "a10"]
+releases.natural_sort_by(&:number)   # => sorted by version number
 ```
 
+## Versioning
+
+This project follows [Semantic Versioning](https://semver.org). The sort order
+itself is part of the public API: any change to how strings are ordered is a
+breaking change and ships only in a major release.
+
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at
+Bug reports and pull requests are welcome at
 https://github.com/rwz/natural_sort.
 
-
 ## License
 
-The gem is available as open source under the terms of the [MIT
-License](http://opensource.org/licenses/MIT).
+Available as open source under the terms of the
+[MIT License](https://github.com/rwz/natural_sort/blob/main/LICENSE.txt).

data/lib/natural_sort/kernel.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "natural_sort"
+
+# Conversion-style helper (in the spirit of Integer()/Array()): wraps +input+
+# in a NaturalSort comparison key for use as a sort_by key, e.g.
+# +list.sort_by { |x| NaturalSort(x) }+. Opt-in — requiring this file defines
+# it at the top level, so it lands on Kernel and is callable on every object.
+#
+# @param input [#to_s]
+# @return [NaturalSort::Key]
+def NaturalSort(input)
+  NaturalSort.key(input)
+end

data/lib/natural_sort/key.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module NaturalSort
+  # A precomputed, comparable sort key. Wrap a value with NaturalSort.key (or
+  # the NaturalSort() helper) and use it as a sort_by key:
+  #
+  #   array.sort_by { |string| NaturalSort.key(string) }
+  #
+  # The string is split once, on construction: digit runs with no leading zero
+  # become Integers (compared by value); everything else — text, and digit runs
+  # with a leading zero — stays a String (compared by byte value). Whitespace is
+  # skipped. This reproduces Martin Pool's strnatcmp ordering.
+  #
+  # Splitting runs over the raw bytes, so any input sorts by byte value rather
+  # than raising — including malformed encodings (e.g. Latin-1 bytes mislabeled
+  # UTF-8) and ASCII-incompatible ones (UTF-16/UTF-32). For valid UTF-8, byte
+  # order and codepoint order agree, so this changes ordering for no one.
+  class Key
+    include Comparable
+
+    TOKENIZER  = /\d+|\D/
+    NUMERIC    = /\A[1-9]\d*\z/
+    WHITESPACE = /\A\s+\z/
+    private_constant :TOKENIZER, :NUMERIC, :WHITESPACE
+
+    # Internal: the token list. Protected so #<=> can read another Key's
+    # segments without exposing the (changeable) token format as public API.
+    protected attr_reader :segments
+
+    def initialize(input)
+      @input = input.to_s.dup.freeze
+      @segments = @input.b.scan(TOKENIZER).filter_map do |token|
+        if token.match?(WHITESPACE)
+          nil
+        elsif NUMERIC.match?(token)
+          Integer(token)
+        else
+          token
+        end
+      end.freeze
+      freeze
+    end
+
+    def to_s
+      @input
+    end
+
+    # Three-way comparison. Numeric segments (Integers) compare by value when
+    # paired with another numeric segment; in every other pairing both sides
+    # compare by byte value. A non-zero-leading integer's #to_s is its original
+    # digits, so the cross-type byte comparison stays exact.
+    #
+    # @return [Integer, nil] -1, 0, or 1, or nil when +other+ is not a Key
+    def <=>(other)
+      return nil unless other.is_a?(Key)
+
+      mine = segments
+      theirs = other.segments
+      index = 0
+
+      while index < mine.length
+        right = theirs[index]
+        return 1 if right.nil?
+
+        left = mine[index]
+        result =
+          if left.is_a?(Integer)
+            right.is_a?(Integer) ? left <=> right : left.to_s <=> right
+          else
+            right.is_a?(Integer) ? left <=> right.to_s : left <=> right
+          end
+        return result unless result.zero?
+
+        index += 1
+      end
+
+      theirs.length > mine.length ? -1 : 0
+    end
+
+    # Equal keys (same token list) hash alike and collapse in a Hash, Set, or
+    # #uniq — consistent with #== / #<=>, since segments are equal exactly when
+    # the comparison is 0.
+    #
+    # @return [Boolean]
+    def eql?(other)
+      other.is_a?(Key) && segments == other.segments
+    end
+
+    # @return [Integer]
+    def hash
+      segments.hash
+    end
+  end
+end

data/lib/natural_sort/refinements.rb

@@ -1,16 +1,18 @@
-require "set"
+# frozen_string_literal: true
+
+require "natural_sort"
 
 module NaturalSort
   [Array, Hash, Set].each do |klass|
     refine klass do
       def natural_sort
-        to_a.sort(&NaturalSort)
+        # For a Hash, +to_a+ yields [key, value] pairs; key on the key alone so
+        # the value never sways ordering. For Array/Set the element is taken whole.
+        to_a.sort_by { |element, _| NaturalSort.key(element) }
       end
 
       def natural_sort_by
-        to_a.sort_by do |element|
-          NaturalSort(yield(element))
-        end
+        to_a.sort_by { |element| NaturalSort.key(yield(element)) }
       end
     end
   end

data/lib/natural_sort/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NaturalSort
-  VERSION = "0.2.0".freeze
+  VERSION = "1.0.0"
 end

data/lib/natural_sort.rb

@@ -1,28 +1,58 @@
+# frozen_string_literal: true
+
 require "natural_sort/version"
 
 module NaturalSort
   module_function
 
-  autoload :Segment,         "natural_sort/segment"
-  autoload :SegmentedString, "natural_sort/segmented_string"
+  autoload :Key, "natural_sort/key"
 
+  # Comparator proc, so the module itself works as a sort block:
+  # +list.sort(&NaturalSort)+. Prefer +sort+ or +sort_by { NaturalSort.key(x) }+
+  # when speed matters — those build one key per element instead of one per
+  # comparison.
+  #
+  # @return [Proc] a two-argument comparator returning -1, 0, or 1
   def to_proc
-    lambda(&method(:compare))
+    method(:compare).to_proc
   end
 
+  # Natural-sorts +input+ into a new array. Not stable: elements whose
+  # natural-order keys are equal may be reordered relative to each other.
+  #
+  # @param input [Enumerable] strings (or any +#to_s+-able values)
+  # @return [Array] a new array in natural order
   def sort(input)
-    input.sort(&self)
+    input.sort_by { |element| Key.new(element) }
   end
 
+  # Natural-sorts +input+ in place. Like {sort}, not stable for equal keys.
+  #
+  # @param input [Array] (or anything with +#sort_by!+)
+  # @return [Array] +input+ itself, sorted
+  # @raise [ArgumentError] when +input+ cannot be sorted in place
   def sort!(input)
-    input.sort!(&self)
+    unless input.respond_to?(:sort_by!)
+      raise ArgumentError, "sort! needs an Array (or anything with #sort_by!); use sort for other enumerables"
+    end
+
+    input.sort_by! { |element| Key.new(element) }
   end
 
+  # Three-way natural-order comparison of two values (each coerced via +#to_s+).
+  #
+  # @param a [#to_s]
+  # @param b [#to_s]
+  # @return [Integer] -1, 0, or 1
   def compare(a, b)
-    SegmentedString.new(a) <=> SegmentedString.new(b)
+    Key.new(a) <=> Key.new(b)
   end
-end
 
-def NaturalSort(input)
-  NaturalSort::SegmentedString.new(input)
+  # The comparable sort key for +value+, for use as a +sort_by+ key.
+  #
+  # @param value [#to_s]
+  # @return [NaturalSort::Key]
+  def key(value)
+    Key.new(value)
+  end
 end

metadata

@@ -1,34 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: natural_sort
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Pavel Pravosud
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-11-14 00:00:00.000000000 Z
+date: 2026-06-14 00:00:00.000000000 Z
 dependencies: []
-description: 
+description: |
+  Natural-sort ordering for Ruby: split strings into digit and non-digit
+  runs and compare numerically, so "a2" sorts before "a10". Plugs into
+  Ruby's own sort methods, with optional Array/Hash/Set refinements and an
+  opt-in NaturalSort() helper.
 email:
 - pavel@pravosud.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - lib/natural_sort.rb
+- lib/natural_sort/kernel.rb
+- lib/natural_sort/key.rb
 - lib/natural_sort/refinements.rb
-- lib/natural_sort/segment.rb
-- lib/natural_sort/segmented_string.rb
 - lib/natural_sort/version.rb
 homepage: https://github.com/rwz/natural_sort
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/rwz/natural_sort
+  source_code_uri: https://github.com/rwz/natural_sort/tree/v1.0.0
+  bug_tracker_uri: https://github.com/rwz/natural_sort/issues
+  changelog_uri: https://github.com/rwz/natural_sort/blob/main/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/natural_sort
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -36,16 +47,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.7
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Natural sorting support for Ruby
 test_files: []

data/lib/natural_sort/segment.rb

@@ -1,36 +0,0 @@
-module NaturalSort
-  class Segment
-    include Comparable
-
-    NUMERIC = /\A\d+(?:\.\d+)?\z/
-    private_constant :NUMERIC
-
-    attr_reader :input
-
-    def initialize(input)
-      @input = input.to_s
-    end
-
-    def to_s
-      @input
-    end
-
-    def <=>(other)
-      if numeric? && other.numeric?
-        Rational(input) <=> Rational(other.to_s)
-      else
-        compare_chars(input, other.to_s)
-      end
-    end
-
-    def numeric?
-      NUMERIC === input
-    end
-
-    private
-
-    def compare_chars(a, b)
-      a == b.swapcase ? a <=> b : a.downcase <=> b.downcase
-    end
-  end
-end

data/lib/natural_sort/segmented_string.rb

@@ -1,43 +0,0 @@
-module NaturalSort
-  class SegmentedString
-    include Comparable
-
-    TOKENIZER = /\d+(?:\.\d+)?|\D/
-    private_constant :TOKENIZER
-
-    attr_reader :input
-
-    def initialize(input)
-      @input = input.to_s
-    end
-
-    def segments
-      @segments ||= tokens.map { |token| Segment.new(token) }
-    end
-
-    def <=>(other)
-      raise ArgumentError unless SegmentedString === other
-
-      other_segments = other.segments
-
-      segments.each_with_index do |segment, index|
-        other_segment = other_segments[index]
-        return 1 if other_segment.nil?
-        result = compare_segments(segment, other_segment)
-        return result unless result.zero?
-      end
-
-      other_segments.length > segments.length ? -1 : 0
-    end
-
-    private
-
-    def tokens
-      @tokens ||= input.scan(TOKENIZER)
-    end
-
-    def compare_segments(segment, other)
-      segment <=> other
-    end
-  end
-end