natural comparison library for sorting lists nicely - works wonders

1 files changed, 156 insertions, 0 deletions

diff --git a/javascript/libs/natcompare.js b/javascript/libs/natcompare.js
new file mode 100644
index 0000000..9988643
--- /dev/null
+++ b/javascript/libs/natcompare.js
@@ -0,0 +1,156 @@
+/*
+natcompare.js -- Perform 'natural order' comparisons of strings in JavaScript.
+Copyright (C) 2005 by SCK-CEN (Belgian Nucleair Research Centre)
+Written by Kristof Coomans <kristof[dot]coomans[at]sckcen[dot]be>
+
+Based on the Java version by Pierre-Luc Paour, of which this is more or less a straight conversion.
+Copyright (C) 2003 by Pierre-Luc Paour <natorder@paour.com>
+
+The Java version was based on the C version by Martin Pool.
+Copyright (C) 2000 by Martin Pool <mbp@humbug.org.au>
+
+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.
+*/
+
+
+function isWhitespaceChar(a)
+{
+    var charCode;
+    charCode = a.charCodeAt(0);
+
+    if ( charCode <= 32 )
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+function isDigitChar(a)
+{
+    var charCode;
+    charCode = a.charCodeAt(0);
+
+    if ( charCode >= 48  && charCode <= 57 )
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+function compareRight(a,b)
+{
+    var bias = 0;
+    var ia = 0;
+    var ib = 0;
+
+    var ca;
+    var cb;
+
+    // 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 (;; ia++, ib++) {
+        ca = a.charAt(ia);
+        cb = b.charAt(ib);
+
+        if (!isDigitChar(ca)
+                && !isDigitChar(cb)) {
+            return bias;
+        } else if (!isDigitChar(ca)) {
+            return -1;
+        } else if (!isDigitChar(cb)) {
+            return +1;
+        } else if (ca < cb) {
+            if (bias == 0) {
+                bias = -1;
+            }
+        } else if (ca > cb) {
+            if (bias == 0)
+                bias = +1;
+        }
+    }
+}
+
+function natcompare(a,b) {
+
+    var ia = 0, ib = 0;
+    var nza = 0, nzb = 0;
+    var ca, cb;
+    var result;
+
+    while (true)
+    {
+        // only count the number of zeroes leading the last number compared
+        nza = nzb = 0;
+
+        ca = a.charAt(ia);
+        cb = b.charAt(ib);
+
+        // skip over leading spaces or zeros
+        while ( isWhitespaceChar( ca ) || ca =='0' ) {
+            if (ca == '0') {
+                nza++;
+            } else {
+                // only count consecutive zeroes
+                nza = 0;
+            }
+
+            ca = a.charAt(++ia);
+        }
+
+        while ( isWhitespaceChar( cb ) || cb == '0') {
+            if (cb == '0') {
+                nzb++;
+            } else {
+                // only count consecutive zeroes
+                nzb = 0;
+            }
+
+            cb = b.charAt(++ib);
+        }
+
+        // process run of digits
+        if (isDigitChar(ca) && isDigitChar(cb)) {
+            if ((result = compareRight(a.substring(ia), b.substring(ib))) != 0) {
+                return result;
+            }
+        }
+
+        if (ca == 0 && cb == 0) {
+            // The strings compare the same.  Perhaps the caller
+            // will want to call strcmp to break the tie.
+            return nza - nzb;
+        }
+
+        if (ca < cb) {
+            return -1;
+        } else if (ca > cb) {
+            return +1;
+        }
+
+        ++ia; ++ib;
+    }
+}
+
+