v3.2.1-beta :: fix null bug of god()

Author: Chinory

README.md

@@ -112,7 +112,7 @@ parse(argv, i, req, res, err)
 ```
 
 - **argv**: Array of command line arguments (usually `process.argv`)
-- **i**: Starting index for parsing (usually 2)
+- **i**: Starting index for parsing (usually `2`)
 - **req**: Configuration object defining your command structure
 - **res**: Object that will be populated with parsed results
 - **err**: Error handler function, receives `{msg, i, opt, key, val}` and returns boolean
@@ -142,10 +142,12 @@ The function returns either:
 }
 ```
 
-Option definitions can be:
-- A string: `'--option'`
-- An array of strings: `['--option', '-o']`
-- Include `null` in an array to use the variable name as an option: `[null, '-o']`
+Option definitions can be:  
+- A string: `'--option'`  
+- An array: `['--option', '-o']`  
+- `null` (refers to the variable name)  
+
+Note: `undefined` is not supported. While it may work like `null` in `OptKit`, this is unintended. At `ExitKit`, `undefined` behaves differently from `null`.  
 
 ## ⚡ Powerful Features
 
@@ -178,8 +180,7 @@ files: {
   set: ['-i', '--input'] // -i 1.txt --input 2.txt -i3.txt --input=4.txt
 }
 
-// '--' automatically collects all the anonymous arguments. 
-// If you write it out, it collects all the rest arguments.
+// Special option '--' collects all the anonymous arguments. 
 allFiles: {
   def: [],
   set: ['--', '-i'] // -i 1.txt 2.txt -- --this-will-be-collected-too
@@ -211,12 +212,11 @@ files: {
 }
 ```
 
-Note: Inverting a boolean value is not supported now. 
+Note: Inverting a boolean value is not supported. 
 
 ### Combined Short Options
 
 ```javascript
-// -abc is equivalent to -a -b -c
 const res = {};
 parse(['node', 'app.js', '-abc'], 2, {
   a: { def: false, set: '-a' },
@@ -225,6 +225,16 @@ parse(['node', 'app.js', '-abc'], 2, {
 }, res, errorHandler);
 // res = { a: true, b: true, c: true }
 ```
+```javascript
+const res = {};
+parse(['node', 'app.js', '-abcd'], 2, {
+  a: { def: false, set: '-a' },
+  b: { def: [], set: '-b' },
+  c: { def: false, set: '-c' },
+  d: { def: false, set: '-d' }
+}, res, errorHandler);
+// { a: true, b: [ 'cd' ], c: false, d: false }
+```
 
 ## 🔄 Subcommand Handling
 

index.js

@@ -21,8 +21,8 @@ const isA = Array.isArray;
  * @returns {boolean} Whether the parsing should continue (false) or quit (true)
  * @typedef {Record<OptStr, VarKey>} OptKeyMap internal type
  */
-/** @param {OptKit} ok */
-const god = ok => typeof ok === 'string' ? [ok] : isA(ok) ? ok : [];
+/** Get OD! @param {OptKit} ok */
+const god = ok => ok === undefined ? [] : isA(ok) ? ok : [ok];
 /**
  * Command line argument parser function
  * @param {string[]} argv Command line arguments array, e.g. `process.argv`
@@ -51,8 +51,9 @@ export default function parse(argv, i, req, res, err) {
 			res[key] = !def;
 			return false;
 		 } return true;
-	}, exit = () => ({ i: i + 1, key, opt }),
-	ask = (msg, val) => err({msg, i, opt, key, val});
+	}, k = o => o == null ? key : o, // split undefined? really?
+	ask = (msg, val) => err({msg, i, opt, key, val}),
+	exit = () => ({ i: i + 1, key, opt });
 	// prepare
 	/** @type {OptKeyMap} */
 	const set_ = {}, rst_ = {}, exit_ = {};
@@ -63,17 +64,17 @@ export default function parse(argv, i, req, res, err) {
 		X: { let xk; // stricter than god()
 			switch (typeof vk) {
 				case 'object':
-					if (vk === null) xk = [key];
+					if (vk === null) xk = [vk];
 					else if (isA(vk)) xk = vk; 
 					else break X; break;
 				case 'string': xk = [vk]; break;
 				default: continue; }
-			for (const o of xk) if (o!=='--') exit_[o||key] = key; else _key = key, _exit = true;
+			for (const o of xk) if (o!=='--') exit_[k(o)] = key; else _key = key, _exit = true;
 			continue; }
 		const def = vk.def;
 		res[key] = isA(def) ? def.slice() : def;
-		for (const o of god(vk.set)) if (o!=='--') set_[o||key] = key; else _key = key, _exit = false;
-		for (const o of god(vk.rst)) if (o!=='--') rst_[o||key] = key;
+		for (const o of god(vk.set)) if (o!=='--') set_[k(o)] = key; else _key = key, _exit = false;
+		for (const o of god(vk.rst)) if (o!=='--') rst_[k(o)] = key;
 	}
 	// process
 	let ext = false;
@@ -114,8 +115,8 @@ export default function parse(argv, i, req, res, err) {
 		}
 		// --opt
 		if (s.length > 2) {
-			const k = s.indexOf('=');
-			if (k < 0) {
+			const J = s.indexOf('=');
+			if (J < 0) {
 				// --opt ...
 				if (key = set_[opt = s]) ext = noB();
 				else if (key = rst_[opt]) rst();
@@ -124,8 +125,8 @@ export default function parse(argv, i, req, res, err) {
 				continue;
 			} 
 			// --opt=val
-			let t; opt = s.slice(0, k);
-			const v = s.slice(k + 1);
+			let t; opt = s.slice(0, J);
+			const v = s.slice(J + 1);
 			if (key = set_[opt])
 				switch (t = typeof res[key]) {
 					case 'boolean': break;

test.js

@@ -216,17 +216,65 @@ runTest('Default naming', () => {
   assert.strictEqual(ret1.key, 'help');
   assert.strictEqual(ret1.opt, 'help');
 
-  // Test using null in array for direct naming
+  // Test using null for direct naming
   const req2 = {
     verbose: {
       def: false,
-      set: [null] // null in the array means use 'verbose' as option name
+      set: null // null means use 'verbose' as option name
     }
-  };
-  
-  const res2 = {};
+  }, res2 = {};
   parse(['node', 'script.js', 'verbose'], 2, req2, res2, errorHandler);
   assert.strictEqual(res2.verbose, true);
+
+  // Test using null in array for direct naming
+  const req3 = {
+    verbose: {
+      def: false,
+      set: [null] // null means use 'verbose' as option name
+    }
+  }, res3 = {};
+  parse(['node', 'script.js', 'verbose'], 2, req3, res3, errorHandler);
+  assert.strictEqual(res3.verbose, true);  
+
+  const req3a = {
+    verbose: {
+      def: false,
+      set: [null, '-v'] 
+    }
+  }, res3a = {};
+  parse(['node', 'script.js', '-v'], 2, req3a, res3a, errorHandler);
+  assert.strictEqual(res3a.verbose, true);  
+
+  // Test using '' for direct naming
+  const req4 = {
+    verbose: {
+      def: false,
+      set: '' // '' doesn't mean use 'verbose' as option name
+    }
+  }, res4 = {};
+  parse(['node', 'script.js', ''], 2, req4, res4, errorHandler);
+  assert.strictEqual(res4.verbose, true);
+
+  // Test using '' in array for direct naming
+  const req5 = {
+    verbose: {
+      def: false,
+      set: [''] // '' doesn't mean use 'verbose' as option name
+    }
+  }, res5 = {};
+  parse(['node', 'script.js', ''], 2, req5, res5, errorHandler);
+  assert.strictEqual(res5.verbose, true);  
+
+  const req5a = {
+    verbose: {
+      def: false,
+      set: ['', '-v'] 
+    }
+  }, res5a = {};
+  parse(['node', 'script.js', '-v'], 2, req5a, res5a, errorHandler);
+  assert.strictEqual(res5a.verbose, true);  
+
+
 });
 
 // TEST 9: Error handling