#19: array (feat): CommentArray::sort, untested

array (patch): fixes a bug that CommentArray::reverse could not clean the mess

Author: kaelzhang

package.json

@@ -59,6 +59,7 @@
     "typescript": "^4.0.3"
   },
   "dependencies": {
+    "array-timsort": "^1.0.3",
     "core-util-is": "^1.0.2",
     "esprima": "^4.0.1",
     "has-own-prop": "^2.0.0",

src/array.js

@@ -1,36 +1,17 @@
-const hasOwnProperty = require('has-own-prop')
 const {isArray} = require('core-util-is')
+const {sort} = require('array-timsort')
 
 const {
   SYMBOL_PREFIXES,
 
   UNDEFINED,
 
   symbol,
-  define,
-  copy_comments,
-  copy_all_comments
+  copy_all_comments,
+  swap_comments
 } = require('./common')
 
 
-const swap_comments = (array, from, to) => {
-  if (from === to) {
-    return
-  }
-
-  SYMBOL_PREFIXES.forEach(prefix => {
-    const target_prop = symbol(prefix, to)
-    if (!hasOwnProperty(array, target_prop)) {
-      copy_comments(array, array, to, from, prefix)
-      return
-    }
-
-    const comments = array[target_prop]
-    copy_comments(array, array, to, from, prefix)
-    define(array, symbol(prefix, from), comments)
-  })
-}
-
 const reverse_comments = array => {
   const {length} = array
   let i = 0
@@ -235,6 +216,43 @@ class CommentArray extends Array {
 
     return ret
   }
+
+  sort (...args) {
+    const result = sort(
+      this,
+      // Make sure there is no more than one argument
+      ...args.slice(0, 1)
+    )
+
+    // For example,
+    // if we sort ['c', 'a', 'b', 'd'],
+    // then `result` will be [1, 2, 0, 3], and the array is ['a', 'b', 'c', 'd']
+
+    // First, we swap index 0 and index 1, then the array comments are
+    // ['a.comments', 'c.comments', 'b.comments', 'd.comments']
+
+    // Then swap index 1 and index 2
+    // ['a.comments', 'b.comments', 'c.comments', 'd.comments']
+
+    // And we should not swap index 2 and index 0
+
+    const sorted = new Set()
+
+    result.forEach((new_index, original_index) => {
+      if (new_index === original_index) {
+        return
+      }
+
+      if (sorted.has(new_index) && sorted.has(original_index)) {
+        return
+      }
+
+      sorted.add(new_index)
+      sorted.add(original_index)
+
+      swap_comments(this, new_index, original_index)
+    })
+  }
 }
 
 module.exports = {

src/common.js

@@ -72,6 +72,26 @@ const copy_all_comments = (
   })
 }
 
+const swap_comments = (array, from, to) => {
+  if (from === to) {
+    return
+  }
+
+  SYMBOL_PREFIXES.forEach(prefix => {
+    const target_prop = symbol(prefix, to)
+    if (!hasOwnProperty(array, target_prop)) {
+      copy_comments(array, array, to, from, prefix, true)
+      return
+    }
+
+    const comments = array[target_prop]
+    delete array[target_prop]
+
+    copy_comments(array, array, to, from, prefix, true)
+    define(array, symbol(prefix, from), comments)
+  })
+}
+
 const assign_non_prop_comments = (target, source) => {
   NON_PROP_SYMBOL_KEYS.forEach(key => {
     const comments = source[key]
@@ -125,6 +145,7 @@ module.exports = {
   define,
   copy_comments,
   copy_all_comments,
+  swap_comments,
   assign_non_prop_comments,
 
   assign (target, source, keys) {

test/array.test.js

@@ -29,8 +29,17 @@ const a3 = `[
   0
 ]`
 
-// ret: return value to expect
-const texpect = (t, ret, str, r, rr) => {
+const texpect = (
+  t,
+  // cleaned parsed
+  ret,
+  // stringified value from parsed
+  str,
+  // parsed value
+  r,
+  // real return value
+  rr
+) => {
   if (isObject(ret)) {
     t.deepEqual(r, ret)
   } else {
@@ -110,7 +119,11 @@ const CASES = [
     'slice(-1)',
     a1,
     array => array.slice(- 1),
-    slice([2], `[
+    slice(
+      // cleaned object after parsed and sliced
+      [2],
+      // parse, slice and then stringify
+      `[
   // 2
   2
 ]`)
@@ -181,6 +194,24 @@ const CASES = [
   1,
   // 0
   0
+]`)
+  ],
+  [
+    'reverse, no mess',
+    `[
+  0, // 0
+  // 1
+  1,
+  // 2
+  2
+]`,
+    array => array.reverse(),
+    unshift([2, 1, 0], `[
+  // 2
+  2,
+  // 1
+  1,
+  0 // 0
 ]`)
   ],
   [
@@ -210,11 +241,16 @@ CASES.forEach(([d, a, run, e, s]) => {
 
     expect(
       t,
+      // Cleaned return value
       isArray(ret)
         // clean ret
         ? [...ret]
         : ret,
-      st(parsed), parsed, ret)
+      // Stringified
+      st(parsed),
+      parsed,
+      ret
+    )
   })
 })