refactor from-to

Author: 75lb

dist/index.cjs

@@ -14,51 +14,18 @@ var arrayBack = require('array-back');
  * arr {string[]} - Input array. Only mutated if `options.remove` is set.
  * [options.rtol] {boolean} - Enable right-to-left scans. Either that or pass in a custom iterator. TODO.
  * [options.remove] {boolean} - Remove from source array
- * [options.inclusive] {boolean} - If `true` includes the to item.
- * [options.from] {string[]|function[]}
- * [options.to] {string[]|function[]} - A "Stop Here" function. Set one or more strings as the terminating arg. Or, from the function `fn(arg, index, argv, valueIndex)`, return true for the first arg that is out of range. Set `inclusive` to also include it.
- * [options.toInclude] {string[]|function[]} - From the function `fn(arg, index, argv, valueIndex)`, return true for the first arg that is out of range. Set `inclusive` to also include it.
- * [options.noFurtherThan] {function}
- * [options.toEnd] {boolean}
+ * [options.from] {string[]|function[]} - String literal or a [findIndex](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex) callback function.
+ * [options.to] {string[]|function[]} - A "Stop Here" function. Set one or more strings as the terminating arg. Or, from the function `fn(arg, index, argv, valueIndex)`, return true for the first arg that is out of range. Set `inclusive` to also include it. To will always search to the end of the input array.
  * @returns string[]
  */
-function fromTo (arr, options = {}) {
-  let { from: fromFn, to: toFn, noFurtherThan, remove, inclusive, toEnd } = options;
-
-  if (inclusive === undefined && !noFurtherThan && toFn) {
-    inclusive = true;
-  }
-  toFn = toFn || noFurtherThan;
-  fromFn = arrayBack(fromFn).map(fn => {
-    if (typeof fn === 'string') {
-      return function (val) { return val === fn }
-    } else {
-      return fn
-    }
-  });
-
-  if (fromFn.length === 0) {
-    throw new Error('from required')
-  }
-
-  toFn = arrayBack(toFn).map(fn => {
-    if (typeof fn === 'string') {
-      return function (item) { return item === fn }
-    } else {
-      return fn
-    }
-  });
 
-  let fromIndex;
-  for (const fn of fromFn) {
-    fromIndex = arr.findIndex(fn);
-    if (fromIndex > -1) {
-      break
-    }
-  }
+/* TODO: rename to extractFromTo? Rename `options.remove` to `extract`. */
+function fromTo (arr, options = {}) {
+  const fromIndex = getFromIndex(arr, options.from);
 
-  let toIndex;
-  if (toFn) {
+  const toFn = arrayBack(options.to).map(convertToFunction);
+  let toIndex = -1;
+  if (toFn.length) {
     for (const fn of toFn) {
       toIndex = arr.findIndex((item, index, arr) => {
         if (index > fromIndex) {
@@ -68,54 +35,57 @@ function fromTo (arr, options = {}) {
           return false
         }
       });
+      /* Keep looping until a match is found. */
       if (toIndex > -1) {
         break
       }
     }
   }
 
-  if (remove) {
-    let deleteCount;
-    if (toEnd) {
-      deleteCount = arr.length;
-    }
+  const output = toIndex === -1
+    ? arr.slice(fromIndex) /* Return all to the end */
+    : arr.slice(fromIndex, toIndex);
+
+  if (options.remove) {
     if (toIndex === -1) {
-      /* TODO: If to is not found, should it behave the same as "no to" (just return the from value)? Scanning to the end supports `--option value value` */
-      deleteCount = arr.length;
-    } else if (toIndex === undefined) {
-      /* When to is omitted, just pick the single value at the from index */
-      /* This differs to arr.slice which slices to the end of the array if end is omitted */
-      deleteCount = 1;
+      arr.splice(fromIndex);
     } else {
-      if (inclusive) {
-        deleteCount = toIndex - fromIndex;
-      } else {
-        deleteCount = toIndex - fromIndex - 1;
-      }
+      arr.splice(fromIndex, toIndex - fromIndex);
     }
-    return arr.splice(fromIndex, deleteCount)
-    /* deleteCount: An integer indicating the number of elements in the array to remove from start. */
-    /* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice */
+  }
+
+  return output
+}
+
+function convertToFunction (fn) {
+  if (typeof fn === 'string') {
+    return function (val) { return val === fn }
+  } else if (fn instanceof RegExp) {
+    return function (val) { return fn.test(val) }
   } else {
-    if (toEnd) {
-      toIndex = arr.length + 1;
-    }
-    if (toIndex === -1) {
-      return arr.slice(fromIndex)
-    } else if (toIndex === undefined) {
-      /* When to is omitted, just pick the single value at the from index */
-      /* This differs to arr.slice which slices to the end of the array if end is omitted */
-      return arr.slice(fromIndex, fromIndex + 1)
-    } else {
-      if (inclusive) {
-        return arr.slice(fromIndex, toIndex + 1)
-      } else {
-        return arr.slice(fromIndex, toIndex)
-      }
+    return fn
+  }
+}
+
+/**
+ * Find the first value which matches the supplied `find` definition (one or more string or functions).
+ */
+function getFromIndex (arr, find) {
+  const fromFns = arrayBack(find).map(convertToFunction);
+
+  if (fromFns.length === 0) {
+    throw new Error('from required')
+  }
+
+  let fromIndex;
+  for (const fn of fromFns) {
+    fromIndex = arr.findIndex(fn);
+    if (fromIndex > -1) {
+      break
     }
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice
-    /* End: Zero-based index at which to end extraction. slice() extracts up to but not including end. */
   }
+
+  return fromIndex
 }
 
 class CommandLineArgs {

index.js

@@ -1,4 +1,4 @@
-import fromTo from './lib/from-to.js'
+import { fromTo } from './lib/from-to.js'
 
 class CommandLineArgs {
   constructor (args, optionDefinitions) {

lib/from-to.js

@@ -17,14 +17,11 @@ import arrayBack from 'array-back'
  * @returns string[]
  */
 
-
 /* TODO: rename to extractFromTo? Rename `options.remove` to `extract`. */
 function fromTo (arr, options = {}) {
-  let { from, to: toFn, remove } = options
-
-  const fromIndex = getFromIndex(arr, from)
+  const fromIndex = getFromIndex(arr, options.from)
 
-  toFn = arrayBack(toFn).map(convertToFunction)
+  const toFn = arrayBack(options.to).map(convertToFunction)
   let toIndex = -1
   if (toFn.length) {
     for (const fn of toFn) {
@@ -61,11 +58,16 @@ function fromTo (arr, options = {}) {
 function convertToFunction (fn) {
   if (typeof fn === 'string') {
     return function (val) { return val === fn }
+  } else if (fn instanceof RegExp) {
+    return function (val) { return fn.test(val) }
   } else {
     return fn
   }
 }
 
+/**
+ * Find the first value which matches the supplied `find` definition (one or more string or functions).
+ */
 function getFromIndex (arr, find) {
   const fromFns = arrayBack(find).map(convertToFunction)
 
@@ -84,14 +86,28 @@ function getFromIndex (arr, find) {
   return fromIndex
 }
 
+/**
+ * Return a single item from an array, optionally removing it from the input.
+ */
 function single (arr, item, options = {}) {
   const fromIndex = getFromIndex(arr, item)
 
+  const output = arr.slice(fromIndex, fromIndex + 1)
+  if (options.remove && fromIndex > -1) {
+    arr.splice(fromIndex, 1)
+  }
+  return output
+}
+
+/**
+ * Return a single item by index, optionally removing it from the input.
+ */
+function positional (arr, fromIndex, options = {}) {
   const output = arr.slice(fromIndex, fromIndex + 1)
   if (options.remove) {
     arr.splice(fromIndex, 1)
   }
   return output
 }
 
-export { fromTo, single }
+export { fromTo, single, positional }

lib/option-definition.js

@@ -2,13 +2,8 @@ class OptionDefinition {
   name
   from
   to
-
-  /**
-   * An additional alternative, or replacement, for `to`. Might result in easier code, e.g. "no further than a --option", rather than "stop here if the next item is an option or the end". This is also how slice() works: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice
-   */
-  noFurtherThan
+  single
   type
-  def
 }
 
 export default OptionDefinition