Attempts to sort an already sorted array now return the original array.

Author: Luke Murray

src/seamless-immutable.js

@@ -578,7 +578,7 @@ function immutableInit(config) {
   }
 
   function sortBy(array, sorter) {
-    var result = [], i, length;
+    var result = [], i, length, rearranged;
 
     if (!(array instanceof Array)) {
       throw new TypeError("The first argument to Immutable#sortBy must be an array.");
@@ -589,7 +589,28 @@ function immutableInit(config) {
     }
     result.sort(sorter);
 
-    return makeImmutableArray(result);
+    // Test if elements of the array have been rearranged
+    rearranged = false;
+    for (i = 0, length = array.length; i < length; i++) {
+      if(result[i] !== array[i]) {
+        // Check if both are NaN. Type checks catch cases where isNaN returns true for strings.
+        if(!(typeof result[i] === "number" && isNaN(result[i]) && typeof array[i] === "number" && isNaN(array[i]))) {
+            rearranged = true;
+        }
+      }
+    }
+
+    // If the elements haven't been rearranged, return the original immutable
+    if(rearranged) {
+      return makeImmutableArray(result);
+    } else {
+      // Ensure that the returned array is immutable
+      if(isImmutable(array)) {
+        return array;
+      } else {
+          return makeImmutableArray(array);
+      }
+    }
   }
 
   // Creates plain object to be used for cloning

test/ImmutableArray/test-sortBy.js

@@ -1,46 +1,58 @@
-var JSC          = require("jscheck");
+var JSC = require("jscheck");
 var getTestUtils = require("../TestUtils.js");
+var assert = require("chai").assert;
 
 module.exports = function(config) {
-  var Immutable = config.implementation;
-  var TestUtils = getTestUtils(Immutable);
-  var check     = TestUtils.check;
-
-  function dummySorter(a, b) {
-    if(b > a) {
-      return 1;
-    } else if(b < a) {
-      return -1;
-    } else {
-      return 0;
+    var Immutable = config.implementation;
+    var TestUtils = getTestUtils(Immutable);
+    var check = TestUtils.check;
+
+    function dummySorter(a, b) {
+        if(b > a) {
+            return 1;
+        } else if(b < a) {
+            return -1;
+        } else {
+            return 0;
+        }
     }
-  }
 
-  describe("#sortBy", function() {
-    it("produces a sorted immutable array", function() {
-      check(100, [ JSC.array(JSC.integer(4), JSC.any()) ], function(array) {
-        var immutable = Immutable(array);
-        var mutable = array.slice();
+    describe("#sortBy", function() {
+        it("produces a sorted immutable array", function() {
+            check(100, [JSC.array(JSC.integer(4), JSC.any())], function(array) {
+                var immutable = Immutable(array);
+                var mutable = array.slice();
 
-        var resultImmutable = Immutable.sortBy(immutable);
-        var resultMutable = mutable.slice();
-        resultMutable.sort();
+                var resultImmutable = Immutable.sortBy(immutable);
+                var resultMutable = mutable.slice();
+                resultMutable.sort();
 
-        TestUtils.assertJsonEqual(resultImmutable, resultMutable);
-      });
-    });
+                TestUtils.assertJsonEqual(resultImmutable, resultMutable);
+            });
+        });
+
+        it("produces a sorted immutable array when provided with a sorter function", function() {
+            check(100, [JSC.array(JSC.integer(4), JSC.any())], function(array) {
+                var immutable = Immutable(array);
+                var mutable = array.slice();
+
+                var resultImmutable = Immutable.sortBy(immutable, dummySorter);
+                var resultMutable = mutable.slice();
+                resultMutable.sort(dummySorter);
+
+                TestUtils.assertJsonEqual(resultImmutable, resultMutable);
+            });
+        });
 
-    it("produces a sorted immutable array when provided with a sorter function", function() {
-      check(100, [ JSC.array(JSC.integer(4), JSC.any()) ], function(array) {
-        var immutable = Immutable(array);
-        var mutable = array.slice();
+        it("returns the same array if it is already sorted", function() {
+            check(100, [JSC.array(JSC.integer(4), JSC.any())], function(array) {
+                var mutable = array.slice().sort();
+                var immutable = Immutable(mutable);
 
-        var resultImmutable = Immutable.sortBy(immutable, dummySorter);
-        var resultMutable = mutable.slice();
-        resultMutable.sort(dummySorter);
+                var resultImmutable = Immutable.sortBy(immutable);
 
-        TestUtils.assertJsonEqual(resultImmutable, resultMutable);
-      });
+                assert.strictEqual(resultImmutable, immutable);
+            });
+        });
     });
-  });
 };