refactor and extract argv-tools

index.js

@@ -42,7 +42,6 @@ function commandLineArgs (optionDefinitions, options) {
     stopAtFirstUnknown: options.stopAtFirstUnknown
   })
 
-  const optionUtil = require('./lib/option-util')
   const Option = require('./lib/option')
   const OutputClass = optionDefinitions.isGrouped() ? require('./lib/output-grouped') : require('./lib/output')
   const output = new OutputClass(optionDefinitions)
@@ -80,5 +79,6 @@ function commandLineArgs (optionDefinitions, options) {
   }
 
   const result = output.toObject({ skipUnknown: !options.partial })
+  const optionUtil = require('./lib/option-util')
   return options.camelCase ? optionUtil.camelCaseObject(result) : result
 }

lib/argv-parser.js

@@ -1,10 +1,13 @@
 'use strict'
-const optionUtil = require('./option-util')
+const argvTools = require('argv-tools')
 
 /**
  * @module argv-parser
  */
 
+/**
+ * @alias module:argv-parser
+ */
 class ArgvParser {
   /**
    * @param {OptionDefinitions} - Definitions array
@@ -13,29 +16,28 @@ class ArgvParser {
    * @param {boolean} [options.stopAtFirstUnknown] -
    */
   constructor (definitions, options) {
-    this.options = options || {}
+    this.options = Object.assign({}, options)
     const Definitions = require('./option-definitions')
     /**
      * Option Definitions
      */
     this.definitions = Definitions.from(definitions)
 
-    const Argv = require('./argv-array')
     /**
      * Argv
      */
-    this.argv = Argv.from(this.options.argv)
-    if (this.argv.hasShortOptions()) {
+    this.argv = argvTools.ArgvArray.from(this.options.argv)
+    if (this.argv.hasCombinedShortOptions()) {
       const findReplace = require('find-replace')
-      findReplace(this.argv, optionUtil.combined, arg => {
+      findReplace(this.argv, argvTools.re.combinedShort, arg => {
         arg = arg.slice(1)
         return arg.split('').map(letter => ({ origArg: `-${arg}`, arg: '-' + letter }))
       })
     }
   }
 
   /**
-   * Yields one `{ event, name, value, arg, def }` pair for each arg in `process.argv` or the `options.argv`.
+   * Yields one `{ event, name, value, arg, def }` argInfo object for each arg in `process.argv` (or `options.argv`).
    */
   * [Symbol.iterator] () {
     const definitions = this.definitions
@@ -61,7 +63,7 @@ class ArgvParser {
       }
 
       /* handle long or short option */
-      if (optionUtil.isOption(arg)) {
+      if (argvTools.isOption(arg)) {
         def = definitions.get(arg)
         value = undefined
         if (def) {
@@ -72,8 +74,8 @@ class ArgvParser {
         }
 
       /* handle --option-value notation */
-      } else if (optionUtil.isOptionEqualsNotation(arg)) {
-        const matches = arg.match(optionUtil.optEquals)
+    } else if (argvTools.isOptionEqualsNotation(arg)) {
+        const matches = arg.match(argvTools.re.optEquals)
         def = definitions.get(matches[1])
         if (def) {
           if (def.isBoolean()) {
@@ -89,7 +91,7 @@ class ArgvParser {
         }
 
       /* handle value */
-      } else if (optionUtil.isValue(arg)) {
+    } else if (argvTools.isValue(arg)) {
         if (def) {
           value = arg
           event = 'set'

lib/option-definitions.js

@@ -1,6 +1,6 @@
 'use strict'
 const arrayify = require('array-back')
-const option = require('./option-util')
+const argvTools = require('argv-tools')
 const t = require('typical')
 
 /**
@@ -11,10 +11,6 @@ const t = require('typical')
  * @alias module:option-definitions
  */
 class Definitions extends Array {
-  clear () {
-    this.length = 0
-  }
-
   /**
    * validate option definitions
    * @returns {string}
@@ -113,10 +109,10 @@ class Definitions extends Array {
    * @returns {Definition}
    */
   get (arg) {
-    if (option.isOption(arg)) {
-      return option.short.test(arg)
-        ? this.find(def => def.alias === option.short.name(arg))
-        : this.find(def => def.name === option.long.name(arg))
+    if (argvTools.isOption(arg)) {
+      return argvTools.re.short.test(arg)
+        ? this.find(def => def.alias === argvTools.getOptionName(arg))
+        : this.find(def => def.name === argvTools.getOptionName(arg))
     } else {
       return this.find(def => def.name === arg)
     }

lib/option-util.js

@@ -1,20 +1,5 @@
 'use strict'
 
-class ArgRegExp extends RegExp {
-  name (arg) {
-    return arg.match(this)[1]
-  }
-}
-
-class OptEqualsRegExp extends RegExp {
-  name (arg) {
-    return arg.match(this)[1]
-  }
-  value (arg) {
-    return arg.match(this)[2]
-  }
-}
-
 function camelCaseObject (object) {
   const camelCase = require('lodash.camelcase')
   for (const prop of Object.keys(object)) {
@@ -27,12 +12,4 @@ function camelCaseObject (object) {
   return object
 }
 
-exports.short = new ArgRegExp('^-([^\\d-])$')
-exports.long = new ArgRegExp('^--(\\S+)')
-exports.combined = /^-[^\d-]{2,}$/
-exports.isOption = arg => (exports.short.test(arg) || exports.long.test(arg)) && !exports.optEquals.test(arg)
-exports.optEquals = new OptEqualsRegExp('^(--\\S+?)=(.*)')
-exports.isOptionEqualsNotation = arg => exports.optEquals.test(arg)
-exports.isValue = arg => !(exports.isOption() || exports.combined.test(arg) || exports.optEquals.test(arg))
-exports.VALUE_MARKER = 'EXPLICIT-VALUE-MARKER-656a659e9efb-' // must be unique
 exports.camelCaseObject = camelCaseObject

package.json

@@ -32,6 +32,7 @@
     "test-runner": "^0.5.0-1"
   },
   "dependencies": {
+    "argv-tools": "^0.1.1",
     "array-back": "^2.0.0",
     "find-replace": "^2.0.1",
     "lodash.camelcase": "^4.3.0",

test/internals/option-definitions.js

@@ -0,0 +1,28 @@
+'use strict'
+const TestRunner = require('test-runner')
+const a = require('assert')
+const Definitions = require('../../lib/option-definitions')
+
+const runner = new TestRunner()
+
+runner.test('.get(long option)', function () {
+  const definitions = Definitions.from([ { name: 'one' } ])
+  a.strictEqual(definitions.get('--one').name, 'one')
+})
+
+runner.test('.get(short option)', function () {
+  const definitions = Definitions.from([ { name: 'one', alias: 'o' } ])
+  a.strictEqual(definitions.get('-o').name, 'one')
+})
+
+runner.test('.get(name)', function () {
+  const definitions = Definitions.from([ { name: 'one' } ])
+  a.strictEqual(definitions.get('one').name, 'one')
+})
+
+runner.test('.validate()', function () {
+  a.throws(function () {
+    const definitions = new Definitions()
+    definitions.load([ { name: 'one' }, { name: 'one' } ])
+  })
+})