fix #23

Author: Bridget Almas

dist/alpheios-data-models.js

@@ -63,7 +63,8 @@ export default class Feature {
       normalized = [[data, this.defaultSortOrder]]
     } else if (!Array.isArray(data[0])) {
       // Multiple values without any sort order, default sort order will be used
-      normalized = data.map((v, i) => [v, i + 1])
+      // we reverse because sortOrder is numeric descending (i.e. 2 is before 1)
+      normalized = data.map((v, i) => [v, data.length - i])
     } else {
       // Value has all the data, including a sort order
       normalized = data
@@ -154,7 +155,18 @@ export default class Feature {
    * Sort order is deterministic.
    */
   sort () {
-    this._data.sort((a, b) => a.sortOrder !== b.sortOrder ? a.sortOrder - b.sortOrder : a.value.localeCompare(b.value))
+    this._data.sort((a, b) => a.sortOrder !== b.sortOrder ? b.sortOrder - a.sortOrder : a.value.localeCompare(b.value))
+  }
+
+  /**
+   * Compares a feature's values to another feature's values for sorting
+   * @param {Feature} otherFeature the feature to compare this feature's values to
+   * @return {integer} >=1 if this feature should be sorted first, 0 if they are equal and -1 if this feature should be sorted second
+   */
+  compareTo (otherFeature) {
+    // the data values are sorted upon construction and insertion so we only should need to look at the first values
+    // feature sortOrders are descending (i.e. 5 sorts higher than 1)
+    return otherFeature._data[0].sortOrder - this._data[0].sortOrder
   }
 
   get items () {

dist/alpheios-data-models.js.map

@@ -85,22 +85,15 @@ class Lexeme {
   static getSortByTwoLemmaFeatures (primary, secondary) {
     return (a, b) => {
       if (a.lemma.features[primary] && b.lemma.features[primary]) {
-        if (a.lemma.features[primary].sortOrder < b.lemma.features[primary].sortOrder) {
-          return 1
-        } else if (a.lemma.features[primary].sortOrder > b.lemma.features[primary].sortOrder) {
-          return -1
+        let primarySort = a.lemma.features[primary].compareTo(b.lemma.features[primary])
+        if (primarySort !== 0) {
+          return primarySort
         } else if (a.lemma.features[secondary] && b.lemma.features[secondary]) {
-          if (a.lemma.features[secondary].sortOrder < b.lemma.features[secondary].sortOrder) {
-            return 1
-          } else if (a.lemma.features[secondary].sortOrder > b.lemma.features[secondary].sortOrder) {
-            return -1
-          } else if (a.lemma.features[secondary] && !b.lemma.features[secondary]) {
-            return -1
-          } else if (!a.lemma.features[secondary] && b.lemma.features[secondary]) {
-            return 1
-          } else {
-            return 0
-          }
+          return a.lemma.features[secondary].compareTo(b.lemma.features[secondary])
+        } else if (a.lemma.features[secondary] && !b.lemma.features[secondary]) {
+          return -1
+        } else if (!a.lemma.features[secondary] && b.lemma.features[secondary]) {
+          return 1
         }
       } else if (a.lemma.features[primary] && !b.lemma.features[primary]) {
         return -1

dist/alpheios-data-models.min.js

@@ -39,4 +39,31 @@ describe('Feature object', () => {
     let b = new Feature(Feature.types.note, 'valuea', Constants.LANG_LATIN)
     expect(a.isEqual(b)).toBeFalsy()
   })
+
+  it('expects to Feature a to be sorted after Feature b', () => {
+    let a = new Feature(Feature.types.frequency, [['lower', 1]], Constants.LANG_GREEK)
+    let b = new Feature(Feature.types.frequency, [['higher', 2]], Constants.LANG_GREEK)
+    expect(a.compareTo(b)).toBeGreaterThan(0)
+    expect([a, b].sort((a, b) => a.compareTo(b))).toEqual([b, a])
+  })
+
+  it('expects to Feature a to be sorted before Feature b', () => {
+    let a = new Feature(Feature.types.frequency, [['lower', 3]], Constants.LANG_GREEK)
+    let b = new Feature(Feature.types.frequency, [['higher', 1]], Constants.LANG_GREEK)
+    expect(a.compareTo(b)).toBeLessThan(0)
+    expect([a, b].sort((a, b) => a.compareTo(b))).toEqual([a, b])
+  })
+
+  it('expects to Feature a to be sorted the same as Feature b', () => {
+    let a = new Feature(Feature.types.frequency, [['same', 1]], Constants.LANG_GREEK)
+    let b = new Feature(Feature.types.frequency, [['same', 1]], Constants.LANG_GREEK)
+    expect(a.compareTo(b)).toEqual(0)
+    expect([a, b].sort((a, b) => a.compareTo(b))).toEqual([a, b])
+  })
+  it('expects to multi-valued Features to sort correctly', () => {
+    let a = new Feature(Feature.types.frequency, [['lower', 1], ['highest', 3]], Constants.LANG_GREEK)
+    let b = new Feature(Feature.types.frequency, [['higher', 2]], Constants.LANG_GREEK)
+    expect(a.compareTo(b)).toBeLessThan(0)
+    expect([a, b].sort((a, b) => a.compareTo(b))).toEqual([a, b])
+  })
 })

src/feature.js

@@ -83,7 +83,7 @@ describe('FeatureType', () => {
   test('orderedFeatures() should return type features in an indexed order.', () => {
     expect(featureType.orderedFeatures).toMatchObject([
       {'languageID': Constants.LANG_LATIN, 'type': 'declension', '_data': [{'sortOrder': 1, 'value': 'first'}]},
-      {'languageID': Constants.LANG_LATIN, 'type': 'declension', '_data': [{'sortOrder': 1, 'value': 'second'}, {'sortOrder': 2, 'value': 'third'}]},
+      {'languageID': Constants.LANG_LATIN, 'type': 'declension', '_data': [{'sortOrder': 2, 'value': 'second'}, {'sortOrder': 1, 'value': 'third'}]},
       {'languageID': Constants.LANG_LATIN, 'type': 'declension', '_data': [{'sortOrder': 1, 'value': 'fourth'}]}
     ])
   })

src/lexeme.js

@@ -51,31 +51,41 @@ describe('Lexeme object', () => {
     let mockLexemeOne = {
       lemma: {
         features: {
-          freq: new Feature(Feature.types.frequency, [''], Constants.LANG_GREEK, 5),
-          pofs: new Feature(Feature.types.part, [''], Constants.LANG_GREEK, 5)
+          freq: new Feature(Feature.types.frequency, [['most frequent', 5]], Constants.LANG_GREEK, 1),
+          pofs: new Feature(Feature.types.part, ['least important pofs', 1], Constants.LANG_GREEK, 1)
         }
       }
     }
     let mockLexemeTwo = {
       lemma: {
         features: {
-          freq: new Feature(Feature.types.frequency, [''], Constants.LANG_GREEK, 5),
-          pofs: new Feature(Feature.types.part, [''], Constants.LANG_GREEK, 5)
+          freq: new Feature(Feature.types.frequency, [['less frequent', 3]], Constants.LANG_GREEK, 1),
+          pofs: new Feature(Feature.types.part, [['more important pofs', 6]], Constants.LANG_GREEK, 1)
         }
       }
     }
     let mockLexemeThree = {
       lemma: {
         features: {
-          pofs: new Feature(Feature.types.part, [''], Constants.LANG_GREEK, 7)
+          pofs: new Feature(Feature.types.part, [['most important pofs', 7]], Constants.LANG_GREEK, 1)
+        }
+      }
+    }
+    let mockLexemeFour = {
+      lemma: {
+        features: {
+          freq: new Feature(Feature.types.frequency, [['most frequent', 5]], Constants.LANG_GREEK, 1),
+          pofs: new Feature(Feature.types.part, [['more important pofs', 6]], Constants.LANG_GREEK, 1)
         }
       }
     }
     let lexemes = [ mockLexemeOne, mockLexemeTwo ]
     let sortFunc = Lexeme.getSortByTwoLemmaFeatures('freq', 'pofs')
-    expect(lexemes.sort(sortFunc)).toEqual([mockLexemeTwo, mockLexemeOne])
+    expect(lexemes.sort(sortFunc)).toEqual([mockLexemeOne, mockLexemeTwo])
     lexemes = [ mockLexemeTwo, mockLexemeThree ]
     expect(lexemes.sort(sortFunc)).toEqual([mockLexemeTwo, mockLexemeThree])
+    lexemes = [ mockLexemeOne, mockLexemeFour ]
+    expect(lexemes.sort(sortFunc)).toEqual([mockLexemeFour, mockLexemeOne])
   })
 
   test('isPopulated', () => {