chore(deps): bump argparse from 1.0.10 to 2.0.1 (appium#14687)

Bumps [argparse](https://github.com/nodeca/argparse) from 1.0.10 to 2.0.1.
- [Release notes](https://github.com/nodeca/argparse/releases)
- [Changelog](https://github.com/nodeca/argparse/blob/master/CHANGELOG.md)
- [Commits](nodeca/argparse@1.0.10...2.0.1)

Signed-off-by: dependabot-preview[bot] <[email protected]>

Co-authored-by: dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>
Co-authored-by: Mykola Mokhnach <[email protected]>

gulpfile.js

@@ -70,20 +70,20 @@ gulp.task('docs', gulp.series(['transpile']), function parseDocs () {
     const exampleArg = typeof arg[0][1] === 'undefined' ? arg[0][0] : arg[0][1];
     const argOpts = arg[1];
 
-    // --keystore-path defaultValue contains a user-specific path,
+    // --keystore-path default contains a user-specific path,
     // let's replace it with <user>/...
     if (arg[0][0] === '--keystore-path') {
       const userPath = process.env.HOME || process.env.USERPROFILE;
-      argOpts.defaultValue = argOpts.defaultValue.replace(userPath, '&lt;user&gt;');
+      argOpts.default = argOpts.default.replace(userPath, '&lt;user&gt;');
     }
 
     // handle empty objects
-    if (JSON.stringify(argOpts.defaultValue) === '{}') {
-      argOpts.defaultValue = '{}';
+    if (JSON.stringify(argOpts.default) === '{}') {
+      argOpts.default = '{}';
     }
 
     md += '|`' + argNames.join('`, `') + '`';
-    md += '|' + ((typeof argOpts.defaultValue === 'undefined') ? '' : argOpts.defaultValue);
+    md += '|' + ((typeof argOpts.default === 'undefined') ? '' : argOpts.default);
     md += '|' + argOpts.help;
     md += '|' + ((typeof argOpts.example === 'undefined') ? '' : '`' + exampleArg + ' ' + argOpts.example + '`');
     md += '|\n';

lib/appium.js

@@ -254,9 +254,7 @@ class AppiumDriver extends BaseDriver {
   async getSessions () {
     const sessions = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions);
     return _.toPairs(sessions)
-      .map(([id, driver]) => {
-        return {id, capabilities: driver.caps};
-      });
+      .map(([id, driver]) => ({id, capabilities: driver.caps}));
   }
 
   printNewSessionAnnouncement (driverName, driverVersion) {

lib/argsparse-actions.js

@@ -0,0 +1,77 @@
+import { Action } from 'argparse';
+
+
+const DEFAULT_CAPS_ARG = '--default-capabilities';
+
+
+class StoreDeprecatedAction extends Action {
+  constructor (options = {}) {
+    const opts = Object.assign({}, options);
+    let helpPrefix = '[DEPRECATED]';
+    if (opts.deprecated_for) {
+      helpPrefix = `[DEPRECATED, use ${opts.deprecated_for} instead]`;
+      delete opts.deprecated_for;
+    }
+    if (opts.help) {
+      opts.help = `${helpPrefix} - ${opts.help}`;
+    } else {
+      opts.help = helpPrefix;
+    }
+    super(opts);
+  }
+
+  call (parser, namespace, values) {
+    namespace[this.dest] = values;
+  }
+}
+
+
+class StoreDeprecatedTrueAction extends StoreDeprecatedAction {
+  constructor (options = {}) {
+    super(Object.assign({}, options, {const: true, nargs: 0}));
+  }
+
+  call (parser, namespace) {
+    namespace[this.dest] = this.const;
+  }
+}
+
+
+class StoreDeprecatedDefaultCapabilityAction extends StoreDeprecatedAction {
+  constructor (options = {}) {
+    super(Object.assign({}, options, {deprecated_for: DEFAULT_CAPS_ARG}));
+  }
+
+  _writeDefaultCap (namespace, value) {
+    namespace[this.dest] = value;
+    if (value === this.default) {
+      return;
+    }
+
+    if (!namespace.defaultCapabilities) {
+      namespace.defaultCapabilities = {};
+    }
+    namespace.defaultCapabilities[this.dest] = value;
+  }
+
+  call (parser, namespace, values) {
+    this._writeDefaultCap(namespace, values);
+  }
+}
+
+
+class StoreDeprecatedDefaultCapabilityTrueAction extends StoreDeprecatedDefaultCapabilityAction {
+  constructor (options = {}) {
+    super(Object.assign({}, options, {const: true, nargs: 0}));
+  }
+
+  call (parser, namespace) {
+    this._writeDefaultCap(namespace, this.const);
+  }
+}
+
+export {
+  StoreDeprecatedAction, StoreDeprecatedTrueAction,
+  StoreDeprecatedDefaultCapabilityAction, StoreDeprecatedDefaultCapabilityTrueAction,
+  DEFAULT_CAPS_ARG,
+};

lib/config.js

@@ -6,6 +6,9 @@ import { exec } from 'teen_process';
 import { rootDir } from './utils';
 import logger from './logger';
 import semver from 'semver';
+import {
+  StoreDeprecatedDefaultCapabilityAction, DEFAULT_CAPS_ARG,
+} from './argsparse-actions';
 
 
 const npmPackage = require(path.resolve(rootDir, 'package.json'));
@@ -24,6 +27,11 @@ function getNodeVersion () {
   return semver.coerce(process.version);
 }
 
+function isSubClass (candidateClass, superClass) {
+  return _.isFunction(superClass) && _.isFunction(candidateClass)
+    && (candidateClass.prototype instanceof superClass || candidateClass === superClass);
+}
+
 async function updateBuildInfo (useGithubApiFallback = false) {
   const sha = await getGitRev(useGithubApiFallback);
   if (!sha) {
@@ -136,29 +144,29 @@ async function showConfig () {
 }
 
 function getNonDefaultArgs (parser, args) {
-  let nonDefaults = {};
-  for (let rawArg of parser.rawArgs) {
-    let arg = rawArg[1].dest;
-    if (args[arg] && args[arg] !== rawArg[1].defaultValue) {
-      nonDefaults[arg] = args[arg];
+  return parser.rawArgs.reduce((acc, [, {dest, default: defaultValue}]) => {
+    if (args[dest] && args[dest] !== defaultValue) {
+      acc[dest] = args[dest];
     }
-  }
-  return nonDefaults;
+    return acc;
+  }, {});
 }
 
 function getDeprecatedArgs (parser, args) {
   // go through the server command line arguments and figure
   // out which of the ones used are deprecated
-  let deprecated = {};
-  for (let rawArg of parser.rawArgs) {
-    let arg = rawArg[1].dest;
-    let defaultValue = rawArg[1].defaultValue;
-    let isDeprecated = !!rawArg[1].deprecatedFor;
-    if (args[arg] && args[arg] !== defaultValue && isDeprecated) {
-      deprecated[rawArg[0]] = rawArg[1].deprecatedFor;
+  return parser.rawArgs.reduce((acc, [[name], {dest, default: defaultValue, action}]) => {
+    if (!args[dest] || args[dest] === defaultValue) {
+      return acc;
     }
-  }
-  return deprecated;
+
+    if (action?.deprecated_for) {
+      acc[name] = action.deprecated_for;
+    } else if (isSubClass(action, StoreDeprecatedDefaultCapabilityAction)) {
+      acc[name] = DEFAULT_CAPS_ARG;
+    }
+    return acc;
+  }, {});
 }
 
 function checkValidPort (port, portName) {
@@ -197,7 +205,7 @@ function validateServerArgs (parser, args) {
     bootstrapPort: checkValidPort,
     chromedriverPort: checkValidPort,
     robotPort: checkValidPort,
-    backendRetries: (r) => { return r >= 0; }
+    backendRetries: (r) => r >= 0,
   };
 
   const nonDefaultArgs = getNonDefaultArgs(parser, args);

lib/main.js

@@ -111,7 +111,7 @@ async function main (args = null) {
     }
   } else {
     // otherwise parse from CLI
-    args = parser.parseArgs();
+    args = parser.parse_args();
   }
   await logsinkInit(args);
   if (args.logFilters) {