feat: add support for descending sort

provisional test set working against new api.

fixes issue #6

Author: bjvickers

index.js

@@ -90,54 +90,67 @@ module.exports = sortBy
  * }
  * ```
  */
-function sortBy (recordset, sortBy, sortTypes, sharedComputedProps, sharedCustomOrders) {
-  // First stage preformatting
+function sortBy (recordset, sortBy, sortTypes, namedConfigs) {
+  // First stage data preparation
   recordset = arrayify(recordset)
   sortBy = arrayify(sortBy)
   sortTypes = arrayify(sortTypes)
-  sharedComputedProps = t.isObject(sharedComputedProps) ? sharedComputedProps : {}
-  sharedCustomOrders = t.isObject(sharedCustomOrders) ? sharedCustomOrders : {}
-    
+
+  let namedComputedProps = {}
+  let namedCustomOrders = {}
+  if (t.isObject(namedConfigs)) {
+    if (t.isDefined(namedConfigs['namedComputedProps'])) {
+      namedComputedProps = namedConfigs['namedComputedProps']
+    }
+    if (t.isDefined(namedConfigs['namedCustomOrders'])) {
+      namedCustomOrders = namedConfigs['namedCustomOrders']
+    }
+  }
+
   // Perform sanity checks.
   let isPrimitiveSort = recordset.some(record => t.isPrimitive(record))
   if (isPrimitiveSort) {
-    // Any 'sortBy' arguments invalidate the sort, because they will not be 
-    // applicable on a primitive array.
-    if (sortBy.length !== 0) {
-      return recordset
+    // The only applicable 'sortBy' arguments on a primitive array
+    // are 'computed property' functions.
+    for (let i = 0; i < sortBy.length; i++) {
+      if (!t.isFunction(sortBy[i])) {
+        return recordset
+      }
     }
   } else {
-    // At least one 'sortBy' argument must be provided, so that the recordset 
+    // At least one 'sortBy' argument must be provided, so that the recordset
     // can be sorted according to that property.
     if (sortBy.length === 0) {
       return recordset
     }
   }
-  
-  // Ensure that if sharedComputedProps is provided, that the object keys
+
+  // Ensure that if namedComputedProps is provided, that the object keys
   // are referenced in the sortBy array
-  if (Object.keys(sharedComputedProps).length > 0) {
-    for (let key in Object.keys(sharedComputedProps)) {
-      if (!t.isDefined(sortBy[key])) {
+  let noOfNamedComputedProps = Object.keys(namedComputedProps).length
+  if (noOfNamedComputedProps > 0) {
+    for (let i = 0; i < noOfNamedComputedProps; i++) {
+      if (sortBy.indexOf(Object.keys(namedComputedProps)[i]) < 0) {
         // Missing object key, return the recordset unchanged
         return recordset
       }
     }
   }
-  
-  // Ensure that if sharedCustomOrders is provided, that the object keys
+
+  // Ensure that if namedCustomOrders is provided, that the object keys
   // are referenced in the sortTypes array
-  if (Object.keys(sharedCustomOrders).length > 0) {
-    for (let key in Object.keys(sharedCustomOrders)) {
-      if (!t.isDefined(sortTypes[key])) {
+  let noOfNamedCustomOrders = Object.keys(namedCustomOrders).length
+  if (noOfNamedCustomOrders > 0) {
+    for (let i = 0; i < noOfNamedCustomOrders; i++) {
+      if (sortTypes.indexOf(Object.keys(namedCustomOrders)[i]) < 0) {
         // Missing object key, return the recordset unchanged
         return recordset
       }
     }
   }
-  
-  // Second stage preformatting. Ensure that each property in sortBy
-  // has a corresponding property in sortTypes. Populate missing, and
+
+  // Second stage data preparation. Ensure that each property in sortBy
+  // has a corresponding property in sortTypes. Populate missing and
   // remove excess, as required.
   if ((sortBy.length === 0) && (sortTypes.length === 0)) {
     sortTypes.push('asc')
@@ -148,69 +161,111 @@ function sortBy (recordset, sortBy, sortTypes, sharedComputedProps, sharedCustom
     for (let i = 0; i < noOfMissingSortTypes; i++) {
       sortTypes.push('asc')
     }
-  } else if (sortBy.length < sortTypes.length) {
+  } else if (!isPrimitiveSort && (sortBy.length < sortTypes.length)) {
     // Too many sortTypes have been provided. Prune the redundant ones
     // at the end of the sortType array.
     sortTypes.splice(-1, sortTypes.length - sortBy.length)
   }
-  
+
   if (isPrimitiveSort) {
     return recordset.sort(comparePrim(sortBy, sortTypes))
   } else {
-    return recordset.sort(compare(sortBy, sortTypes, sharedComputedProps, sharedCustomOrders))
+    return recordset.sort(compare(sortBy, sortTypes, namedComputedProps, namedCustomOrders))
   }
 }
 
-// @TODO: implement compare primitives
 function comparePrim (sortBy, sortTypes) {
-  console.log('comparePrim() NOT YET IMPLEMENTED')
+  // The property should be undefined or a function
+  let sorts = sortBy.slice(0)
+  let property = sorts.shift()
+
+  // The sort should be 'asc', 'desc', or a custom array
+  let sort
+  if (sortTypes.length > 1) {
+    sort = sortTypes.slice(0)
+  } else {
+    let types = sortTypes.slice(0)
+    sort = types.shift()
+  }
+
+  return function sorter (a, b) {
+    let x
+    let y
+    let result
+
+    // Allocate the comparees.
+    if (t.isFunction(property)) {
+      x = property(a)
+      y = property(b)
+    } else {
+      x = a
+      y = b
+    }
+
+    // Perform the sort
+    if (t.isArrayLike(sort)) {
+      // Apply custom ordering
+      result = sort.indexOf(x) - sort.indexOf(y)
+    } else {
+      // Perform an asc sort by default, then invert later if a desc has been
+      // requested for the current property.
+      result = getAscOrder(x, y)
+    }
+
+    // Present the result
+    if (sort === 'desc') {
+      return result * -1
+    } else {
+      return result
+    }
+  }
 }
 
-function compare (sortBy, sortTypes, sharedComputedProps, sharedCustomOrders) {
+function compare (sortBy, sortTypes, namedComputedProps, namedCustomOrders) {
   // Identify the first property on which to sort, and the way it should be sorted.
-  
+
   // The property may be either a string property name, an anonymous function, or
-  // a string key into the sharedComputedProps object.
+  // a string key into the namedComputedProps object.
   let sorts = sortBy.slice(0)
   let property = sorts.shift()
-  
-  // The sort can be 'asc', 'desc', a custom array or a string key into the 
-  // sharedCustomOrders object.
+
+  // The sort can be 'asc', 'desc', a custom array or a string key into the
+  // namedCustomOrders object.
   let types = sortTypes.slice(0)
   let sort = types.shift()
-  
+
   return function sorter (a, b) {
     let x
     let y
     let result
     let recurse
     let currentSort = sort
-    
+
     // Allocate the comparees.
     if (t.isFunction(property)) {
       x = property(a)
       y = property(b)
-    } else if(t.isDefined(sharedComputedProps[property])) {
-      x = sharedComputedProps[property](a)
-      y = sharedComputedProps[property](b)
+    } else if (t.isDefined(namedComputedProps[property])) {
+      x = namedComputedProps[property](a)
+      y = namedComputedProps[property](b)
     } else {
       x = a[property]
       y = b[property]
     }
-    
+
     // Perform the sort
     if (t.isArrayLike(sort)) {
       // Apply custom ordering
       result = sort.indexOf(x) - sort.indexOf(y)
-    } else if (t.isDefined(sharedCustomOrders[sort])) {
+    } else if (t.isDefined(namedCustomOrders[sort])) {
       // Apply custom ordering
-      result = sharedCustomOrders[sort].indexOf(x) - sharedCustomOrders[sort].indexOf(y)
+      result = namedCustomOrders[sort].indexOf(x) - namedCustomOrders[sort].indexOf(y)
     } else {
-      // Perform an asc sort by default, then invert later if a desc has been 
+      // Perform an asc sort by default, then invert later if a desc has been
       // requested for the current property.
       result = getAscOrder(x, y)
     }
-    
+
     // Reset this sorting function and parent, unless there is an equal
     // result and there are more sorts still to perform, in which case
     // move on to the next one.
@@ -235,7 +290,7 @@ function compare (sortBy, sortTypes, sharedComputedProps, sharedCustomOrders) {
   }
 }
 
-function getAscOrder(x, y) {
+function getAscOrder (x, y) {
   let result
   if (x === null && y === null) {
     result = 0

test/primitive-sort.js

@@ -4,5 +4,51 @@ const a = require('assert')
 
 const runner = new TestRunner()
 
-// @TODO: test for sharedComputedProps with invalid keys
-// @TODO: test for sharedCustomOrders with invalid keys
+runner.test('computed property: missing computed property name', function () {
+  const fixture = [
+    { inner: { a: 5, b: 10 } },
+    { inner: { a: 2, b: 10 } },
+    { inner: { a: 3, b: 10 } },
+    { inner: { a: 1, b: 10 } },
+    { inner: { a: 4, b: 10 } }
+  ]
+  const expected = [
+    { inner: { a: 5, b: 10 } },
+    { inner: { a: 2, b: 10 } },
+    { inner: { a: 3, b: 10 } },
+    { inner: { a: 1, b: 10 } },
+    { inner: { a: 4, b: 10 } }
+  ]
+  const sortBy = [ 'total' ]
+  const sortTypes = [ 'asc' ]
+  const namedConfigs = {
+    namedComputedProps: {
+      MISSPELT: item => item.inner.a + item.inner.b
+    }
+  }
+  const result = sort(fixture, sortBy, sortTypes, namedConfigs)
+  a.deepStrictEqual(result, expected)
+})
+
+runner.test('customOrder: missing custom order name', function () {
+  const fixture = [
+    { a: 2 },
+    { a: undefined },
+    { a: 1 }
+  ]
+  const expected = [
+    { a: 2 },
+    { a: undefined },
+    { a: 1 }
+  ]
+
+  const sortBy = [ 'a' ]
+  const sortTypes = [ 'custom1' ]
+  const namedConfigs = {
+    namedCustomOrders: {
+      MISSSPELLED: [ 1, 2, undefined ]
+    }
+  }
+  const result = sort(fixture, sortBy, sortTypes, namedConfigs)
+  a.deepStrictEqual(result, expected)
+})

test/sanity-checks.js

@@ -44,10 +44,12 @@ runner.test('computed property: named', function () {
   ]
   const sortBy = [ 'total' ]
   const sortTypes = [ 'asc' ]
-  const shared = {
-    total: item => item.inner.a + item.inner.b
+  const namedConfigs = {
+    namedComputedProps: {
+      total: item => item.inner.a + item.inner.b
+    }
   }
-  const result = sort(fixture, sortBy, sortTypes, shared)
+  const result = sort(fixture, sortBy, sortTypes, namedConfigs)
   a.deepStrictEqual(result, expected)
 })
 
@@ -89,10 +91,12 @@ runner.test('computed property: named, descending custom order', function () {
   ]
   const sortBy = [ 'total' ]
   const sortTypes = [ 'desc' ]
-  const shared = {
-    total: item => item.inner.number
+  const namedConfigs = {
+    namedComputedProps: {
+      total: item => item.inner.number
+    }
   }
-  const result = sort(fixture, sortBy, sortTypes, shared)
+  const result = sort(fixture, sortBy, sortTypes, namedConfigs)
   a.deepStrictEqual(result, expected)
 })
 
@@ -111,16 +115,18 @@ runner.test('computed property: custom order', function () {
     { inner: { number: 3 } },
     { inner: { number: 5 } }
   ]
-  
+
   const sortBy = [ 'number' ]
-  const sortTypes = [ 
+  const sortTypes = [
     [ 1, 2, 4, 3, 5 ]
   ]
-  const shared = {
-    number: item => item.inner.number
+  const namedConfigs = {
+    namedComputedProps: {
+      number: item => item.inner.number
+    }
   }
-  
-  const result = sort(fixture, sortBy, sortTypes, shared)
+
+  const result = sort(fixture, sortBy, sortTypes, namedConfigs)
   a.deepStrictEqual(result, expected)
 })
 
@@ -139,14 +145,16 @@ runner.test('computed property: custom order, nulls', function () {
     { inner: { number: 3 } },
     { inner: { number: 5 } }
   ]
-  
+
   const sortBy = [ 'number' ]
   const sortTypes = [
     [ 1, 2, null, 3, 5 ]
   ]
-  const shared = {
-    number: item => item.inner.number
+  const namedConfigs = {
+    namedComputedProps: {
+      number: item => item.inner.number
+    }
   }
-  const result = sort(fixture, sortBy, sortTypes, shared)
+  const result = sort(fixture, sortBy, sortTypes, namedConfigs)
   a.deepStrictEqual(result, expected)
 })