Semver major algo change, sort now more stable

The way the levenshtein algo works is relative to string size, which in
the previous sort implementation could lead to unexpected results. Now
we normalize the length of all inputs so the scoring is consistent
across the data set, resulting in less unexpected sorting results.

Author: doesdev

index.js

@@ -1,48 +1,72 @@
 'use strict'
 
 var levenSrc = require('leven')
+var bufChar = String.fromCharCode(2000)
 
-var maxDist = function (a, b, c) {
-  var aLen = (a || '').length
-  var bLen = (b || '').length
+module.exports = function (ary, src1, key1, src2, key2) {
+  var max = 0
+  ary.forEach(function (el) {
+    if (!el) return
+    if (!key1 && !key2 && el.length > max) max = el.length
 
-  return (aLen > bLen ? aLen : bLen) || 1
-}
+    if (key1 instanceof Array) {
+      return key1.forEach(function (k) {
+        if (k && el[k] && el[k].length > max) max = el[k].length
+      })
+    }
 
-var leven = function (a, b) {
-  if (a === b) return 0
-  if (!a || !b) return maxDist(a, b)
+    if (key1 && el[key1] && el[key1].length > max) max = el[key1].length
+    if (key2 && el[key2] && el[key2].length > max) max = el[key2].length
+  })
 
-  return levenSrc(a, b)
-}
+  var maximize = function (val) {
+    if (!val || val.length === max) return val
+    return val + Array(max - val.length).join(bufChar)
+  }
 
-var levSort = function (src, a, b) {
-  if (!a) return 1
-  if (!b) return -1
+  var maxDist = function (a, b, c) {
+    var aLen = (a || '').length
+    var bLen = (b || '').length
 
-  a = leven(src, a)
-  b = leven(src, b)
+    return (aLen > bLen ? aLen : bLen) || 1
+  }
 
-  return a - b
-}
+  var leven = function (a, b) {
+    if (a === b) return 0
 
-var levMinInAry = function (array, src) {
-  var min = 1000
-  var len = array.length
+    b = maximize(b)
 
-  for (var counter = 0; counter < len; counter++) {
-    var val = array[counter]
+    if (!a || !b) return maxDist(a, b)
 
-    if (val && val.length && val.length > 0) {
-      var levScore = leven(src, array[counter])
-      if (levScore < min) min = levScore
-    }
+    return levenSrc(a, b)
   }
 
-  return min
-}
+  var levSort = function (src, a, b) {
+    if (!a) return 1
+    if (!b) return -1
+
+    a = leven(src, a)
+    b = leven(src, b)
+
+    return a - b
+  }
+
+  var levMinInAry = function (array, src) {
+    var min = 1000
+    var len = array.length
+
+    for (var counter = 0; counter < len; counter++) {
+      var val = array[counter]
+
+      if (val && val.length && val.length > 0) {
+        var levScore = leven(src, array[counter])
+        if (levScore < min) min = levScore
+      }
+    }
+
+    return min
+  }
 
-module.exports = function (ary, src1, key1, src2, key2) {
   var sorted = ary.sort(function (a, b) {
     if (key1 instanceof Array) {
       var aLev = levMinInAry(key1.map(function (k) { return a[k] }), src1)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "leven-sort",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "main": "index.js",
   "files": [
     "index.js"

test.js

@@ -25,19 +25,19 @@ runTests('Testing leven-sort', () => {
       'Bill Griffin',
       'Billy Griffith',
       'Billy Campbell',
-      'Alan King',
       'William George',
       'Carl Martinez',
       'Roger Davis',
       'Benjamin Wilson',
       'Dennis Smith',
       'Andrew Torres',
+      'Alan King',
       null
     ]
 
     const levSorted = levenSort(nameAry, sourceName)
 
-    return test('samesies', JSON.stringify(levSorted), JSON.stringify(expect))
+    return test('Simple same', JSON.stringify(levSorted), JSON.stringify(expect))
   })
 
   test(`sorts array of objects, with secondary sort`, () => {
@@ -62,19 +62,19 @@ runTests('Testing leven-sort', () => {
       { first: 'Bill', last: 'Griffin' },
       { first: 'Billy', last: 'Griffith' },
       { first: 'Billy', last: 'Campbell' },
+      { first: 'William', last: 'George' },
+      { first: 'Dennis', last: 'Smith' },
       { first: 'Carl', last: 'Martinez' },
+      { first: 'Benjamin', last: 'Wilson' },
       { first: 'Alan', last: 'King' },
-      { first: 'William', last: 'George' },
       { first: 'Roger', last: 'Davis' },
-      { first: 'Dennis', last: 'Smith' },
       { first: 'Andrew', last: 'Torres' },
-      { first: 'Benjamin', last: 'Wilson' },
       { first: null, last: null }
     ]
 
     const levSorted = levenSort(nameObjAry, sourceFirst, 'first', sourceLast, 'last')
 
-    return test('samesies', JSON.stringify(levSorted), JSON.stringify(expect))
+    return test('Secondary same', JSON.stringify(levSorted), JSON.stringify(expect))
   })
 
   test(`sorts array of objects by multiple keys`, () => {
@@ -98,18 +98,18 @@ runTests('Testing leven-sort', () => {
       { first: 'Bill', last: 'Griffin' },
       { first: 'Billy', last: 'Griffith' },
       { first: 'Billy', last: 'Campbell' },
-      { first: 'Carl', last: 'Martinez' },
-      { first: 'Alan', last: 'King' },
-      { first: 'Benjamin', last: 'Wilson' },
       { first: 'William', last: 'George' },
-      { first: 'Dennis', last: 'Smith' },
+      { first: 'Benjamin', last: 'Wilson' },
       { first: 'Roger', last: 'Davis' },
+      { first: 'Dennis', last: 'Smith' },
+      { first: 'Carl', last: 'Martinez' },
+      { first: 'Alan', last: 'King' },
       { first: 'Andrew', last: 'Torres' },
       { first: null, last: null }
     ]
 
     const levSorted = levenSort(nameObjAry, source, ['first', 'last'])
 
-    return test('samesies', JSON.stringify(levSorted), JSON.stringify(expect))
+    return test('Key array same', JSON.stringify(levSorted), JSON.stringify(expect))
   })
 })