@sap/cds-compiler 3.4.4 → 3.5.2

package/lib/base/optionProcessorHelper.js

@@ -1,4 +1,4 @@
-'use strict'
+'use strict';
 
 /**
  * Create a command line option processor and define valid commands, options and parameters.
@@ -46,7 +46,7 @@ function createOptionProcessor() {
     // TODO: Why exported?
     _parseCommandString,
     _parseOptionString,
-  }
+  };
   return optionProcessor;
 
   /**
@@ -55,7 +55,7 @@ function createOptionProcessor() {
    * @param {string[]} [validValues] Array of valid values for the options.
    * @param {object} [options] Further options such as `ignoreCase: true`
    */
-  function option(optString, validValues, options) {
+  function option( optString, validValues, options ) {
     return _addOption(optionProcessor, optString, validValues, options);
   }
 
@@ -63,7 +63,7 @@ function createOptionProcessor() {
    * API: Define the main help text (header and general options)
    * @param {string} text Help text describing all options, etc.
    */
-  function help(text) {
+  function help( text ) {
     optionProcessor.helpText = text;
     return optionProcessor;
   }
@@ -72,7 +72,7 @@ function createOptionProcessor() {
    * API: Define a command
    * @param {string} cmdString Command name, short and long form, e.g. 'S, toSql'
    */
-  function command(cmdString) {
+  function command( cmdString ) {
     /** @type {object} */
     const cmd = {
       options: {},
@@ -83,28 +83,28 @@ function createOptionProcessor() {
         return cmd;
       },
       help: commandHelp,
-      ..._parseCommandString(cmdString)
+      ..._parseCommandString(cmdString),
     };
-    if (optionProcessor.commands[cmd.longName]) {
-      throw new Error(`Duplicate assignment for long command ${cmd.longName}`);
-    }
+    if (optionProcessor.commands[cmd.longName])
+      throw new Error(`Duplicate assignment for long command ${ cmd.longName }`);
+
     optionProcessor.commands[cmd.longName] = cmd;
 
     if (cmd.shortName) {
-      if (optionProcessor.commands[cmd.shortName]) {
-        throw new Error(`Duplicate assignment for short command ${cmd.shortName}`);
-      }
+      if (optionProcessor.commands[cmd.shortName])
+        throw new Error(`Duplicate assignment for short command ${ cmd.shortName }`);
+
       optionProcessor.commands[cmd.shortName] = cmd;
     }
     return cmd;
 
     // Command API: Define a command option
-    function commandOption(optString, validValues, options) {
+    function commandOption( optString, validValues, options ) {
       return _addOption(cmd, optString, validValues, options);
     }
 
     // Command API: Define the command help text
-    function commandHelp(text) {
+    function commandHelp( text ) {
       cmd.helpText = text;
       return cmd;
     }
@@ -120,29 +120,29 @@ function createOptionProcessor() {
    * @param {object[]} argList            Array, to which the parsed arguments will be added.  Default is global scope.
    * @private
    */
-  function _setPositionalArguments(argumentDefinition, argList = optionProcessor.positionalArguments) {
-    if (argList.find((arg) => arg.isDynamic)) {
-      throw new Error(`Can't add positional arguments after a dynamic one`);
-    }
+  function _setPositionalArguments( argumentDefinition, argList = optionProcessor.positionalArguments ) {
+    if (argList.find(arg => arg.isDynamic))
+      throw new Error('Can\'t add positional arguments after a dynamic one');
+
 
-    const registeredNames = argList.map((arg) => arg.name);
+    const registeredNames = argList.map(arg => arg.name);
     const args = argumentDefinition.split(' ');
 
     for (const arg of args) {
       // Remove braces, dots and camelify.
       const argName = arg.replace('<', '').replace('>', '').replace('...', '').replace(/[ -]./g, s => s.substring(1).toUpperCase());
 
-      if (registeredNames.includes(argName)) {
-        throw new Error(`Duplicate positional argument: ${arg}`);
-      }
-      if (!isParam(arg) && !isDynamicPositionalArgument(arg)) {
-        throw new Error(`Unknown positional argument syntax: ${arg}`)
-      }
+      if (registeredNames.includes(argName))
+        throw new Error(`Duplicate positional argument: ${ arg }`);
+
+      if (!isParam(arg) && !isDynamicPositionalArgument(arg))
+        throw new Error(`Unknown positional argument syntax: ${ arg }`);
+
 
       argList.push({
         name: argName,
         isDynamic: isDynamicPositionalArgument(arg),
-        required: true
+        required: true,
       });
 
       registeredNames.push(argName);
@@ -157,7 +157,7 @@ function createOptionProcessor() {
    * @private
    * @see option()
    */
-  function _addOption(cmd, optString, validValues, options) {
+  function _addOption( cmd, optString, validValues, options ) {
     const cliOpt = _parseOptionString(optString, validValues);
     Object.assign(cliOpt, options);
     _addLongOption(cmd, cliOpt.longName, cliOpt);
@@ -180,14 +180,15 @@ function createOptionProcessor() {
    * @private
    * @see _addOption()
    */
-  function _addLongOption(cmd, longName, opt) {
+  function _addLongOption( cmd, longName, opt ) {
     if (cmd.options[longName]) {
-      throw new Error(`Duplicate assignment for long option ${longName}`);
-    } else if (optionProcessor.options[longName]) {
+      throw new Error(`Duplicate assignment for long option ${ longName }`);
+    }
+    else if (optionProcessor.options[longName]) {
       // This path is only taken if optString is for commands
       optionProcessor.optionClashes.push({
         option: longName,
-        description: `Command '${cmd.longName}' has option clash with general options for: ${longName}`
+        description: `Command '${ cmd.longName }' has option clash with general options for: ${ longName }`,
       });
     }
     cmd.options[longName] = opt;
@@ -201,16 +202,17 @@ function createOptionProcessor() {
    * @private
    * @see _addOption()
    */
-  function _addShortOption(cmd, shortName, opt) {
+  function _addShortOption( cmd, shortName, opt ) {
     if (!shortName)
       return;
     if (cmd.options[shortName]) {
-      throw new Error(`Duplicate assignment for short option ${shortName}`);
-    } else if (optionProcessor.options[shortName]) {
+      throw new Error(`Duplicate assignment for short option ${ shortName }`);
+    }
+    else if (optionProcessor.options[shortName]) {
       // This path is only taken if optString is for commands
       optionProcessor.optionClashes.push({
         option: shortName,
-        description: `Command '${cmd.longName}' has option clash with general options for: ${shortName}`
+        description: `Command '${ cmd.longName }' has option clash with general options for: ${ shortName }`,
       });
     }
     cmd.options[shortName] = opt;
@@ -221,7 +223,7 @@ function createOptionProcessor() {
   //   longName: 'toFoo',
   //   shortName: 'F',
   // }
-  function _parseCommandString(cmdString) {
+  function _parseCommandString( cmdString ) {
     let longName;
     let shortName;
 
@@ -237,12 +239,12 @@ function createOptionProcessor() {
         longName = tokens[1];
         break;
       default:
-        throw new Error(`Invalid command description: ${cmdString}`);
+        throw new Error(`Invalid command description: ${ cmdString }`);
     }
     return {
       longName,
       shortName,
-    }
+    };
   }
 
   // Internal: Parse one option string like "-f, --foo-bar <p>". Returns an object like this
@@ -253,7 +255,7 @@ function createOptionProcessor() {
   //   param: '<p>'
   //   validValues
   // }
-  function _parseOptionString(optString, validValues) {
+  function _parseOptionString( optString, validValues ) {
     let longName;
     let shortName;
     let param;
@@ -263,16 +265,17 @@ function createOptionProcessor() {
     switch (tokens.length) {
       case 1:
         // Must be "--foo"
-        if (isLongOption(tokens[0])) {
+        if (isLongOption(tokens[0]))
           longName = tokens[0];
-        }
+
         break;
       case 2:
         // Could be "--foo <bar>", or "-f --foo"
         if (isLongOption(tokens[0]) && isParam(tokens[1])) {
           longName = tokens[0];
           param = tokens[1];
-        } else if (isShortOption(tokens[0]) && isLongOption(tokens[1])) {
+        }
+        else if (isShortOption(tokens[0]) && isLongOption(tokens[1])) {
           shortName = tokens[0];
           longName = tokens[1];
         }
@@ -286,18 +289,18 @@ function createOptionProcessor() {
         }
         break;
       default:
-        throw new Error(`Invalid option description, too many tokens: ${optString}`);
-    }
-    if (!longName) {
-      throw new Error(`Invalid option description, missing long name: ${optString}`);
-    }
-    if (!param && validValues) {
-      throw new Error(`Option description has valid values but no param: ${optString}`);
+        throw new Error(`Invalid option description, too many tokens: ${ optString }`);
     }
+    if (!longName)
+      throw new Error(`Invalid option description, missing long name: ${ optString }`);
+
+    if (!param && validValues)
+      throw new Error(`Option description has valid values but no param: ${ optString }`);
+
     if (validValues) {
       validValues.forEach((value) => {
         if (typeof value !== 'string')
-          throw new Error(`Valid values must be of type string: ${optString}`);
+          throw new Error(`Valid values must be of type string: ${ optString }`);
       });
     }
 
@@ -308,7 +311,7 @@ function createOptionProcessor() {
       param,
       validValues,
       isAlias: false, // default
-    }
+    };
   }
 
   // API: Let the option processor digest a command line 'argv'
@@ -344,17 +347,17 @@ function createOptionProcessor() {
   //   cmdErrors: [],
   //   errors: [],
   // }
-  function processCmdLine(argv) {
+  function processCmdLine( argv ) {
     const result = {
       command: undefined,
       options: { },
       unknownOptions: [],
       args: {
-        length: 0
+        length: 0,
       },
       cmdErrors: [],
       errors: [],
-    }
+    };
 
     // Iterate command line
     let seenDashDash = false;
@@ -363,7 +366,7 @@ function createOptionProcessor() {
       let arg = argv[i];
       // To be compatible with NPM arguments, we need to support `--arg=val` as well.
       if (arg.includes('=')) {
-        argv = [ ...argv.slice(0, i), ...arg.split('='), ...argv.slice(i + 1)];
+        argv = [ ...argv.slice(0, i), ...arg.split('='), ...argv.slice(i + 1) ];
         arg = argv[i];
       }
 
@@ -385,30 +388,32 @@ function createOptionProcessor() {
             // Found as command
             result.command = optionProcessor.commands[arg].longName;
             result.options[result.command] = {};
-          } else {
+          }
+          else {
             // Not found as command, take as arg and stop looking for commands
             processPositionalArgument(arg);
             result.command = null;
           }
-        } else {
+        }
+        else {
           processPositionalArgument(arg);
         }
       }
     }
     // Avoid 'toXyz: {}' for command without options
-    if (result.command && Object.keys(result.options[result.command]).length === 0) {
+    if (result.command && Object.keys(result.options[result.command]).length === 0)
       delete result.options[result.command];
-    }
+
 
     // Complain about first missing positional arguments
-    const missingArg = getCurrentPositionArguments().find((arg) => arg.required && !result.args[arg.name]);
+    const missingArg = getCurrentPositionArguments().find(arg => arg.required && !result.args[arg.name]);
     if (missingArg) {
       const forCommand = result.command ? ` for '${ result.command }'` : '';
-      const errorMsg = `Missing positional argument${forCommand}: <${missingArg.name}${missingArg.isDynamic ? '...' : ''}>`;
+      const errorMsg = `Missing positional argument${ forCommand }: <${ missingArg.name }${ missingArg.isDynamic ? '...' : '' }>`;
       if (forCommand)
-        result.cmdErrors.push(errorMsg)
+        result.cmdErrors.push(errorMsg);
       else
-        result.errors.push(errorMsg)
+        result.errors.push(errorMsg);
     }
 
     return result;
@@ -424,7 +429,7 @@ function createOptionProcessor() {
       return ( cmd && cmd.positionalArguments && cmd.positionalArguments.length ) ? cmd.positionalArguments : optionProcessor.positionalArguments;
     }
 
-    function processPositionalArgument(argumentValue) {
+    function processPositionalArgument( argumentValue ) {
       const argList = getCurrentPositionArguments();
       if ( result.args.length === 0 && argList.length === 0 )
         return;
@@ -433,16 +438,17 @@ function createOptionProcessor() {
       const nextUnsetArgument = argList[lastIndex];
       if (!inBounds && !nextUnsetArgument.isDynamic) {
         if (result.command)
-          result.errors.push(`Too many arguments. '${result.command}' expects ${argList.length}`);
+          result.errors.push(`Too many arguments. '${ result.command }' expects ${ argList.length }`);
         else
-          result.errors.push(`Too many arguments. Expected ${argList.length}`);
+          result.errors.push(`Too many arguments. Expected ${ argList.length }`);
         return;
       }
       result.args.length += 1;
       if (nextUnsetArgument.isDynamic) {
         result.args[nextUnsetArgument.name] = result.args[nextUnsetArgument.name] || [];
         result.args[nextUnsetArgument.name].push(argumentValue);
-      } else {
+      }
+      else {
         result.args[nextUnsetArgument.name] = argumentValue;
       }
     }
@@ -452,7 +458,7 @@ function createOptionProcessor() {
     // Check the option definition to see if a parameter is expected.
     // If so, take it (complain if one is found in 'argv').
     // Populate 'result.options' with the result. Return the number params found (0 or 1).
-    function processOption(i) {
+    function processOption( i ) {
       const arg = argv[i];
       let currentCommand = result.command;
 
@@ -491,18 +497,17 @@ function createOptionProcessor() {
        */
       function reportUnknown() {
         if (currentCommand)
-          result.unknownOptions.push(`Unknown option "${arg}" for the command "${currentCommand}"`);
+          result.unknownOptions.push(`Unknown option "${ arg }" for the command "${ currentCommand }"`);
         else
-          result.unknownOptions.push(`Unknown option "${arg}"`);
+          result.unknownOptions.push(`Unknown option "${ arg }"`);
 
         if (currentCommand) {
           // Not found at all.  We dig into the other cdsc commands in order to check if
           // the option expects a parameter and if so to take the next argument as a value
           const otherCmd = Object.keys(optionProcessor.commands).find(cmd => optionProcessor.commands[cmd].options[arg]);
           const otherCmdOpt = otherCmd && optionProcessor.commands[otherCmd].options[arg];
-          if (otherCmdOpt && hasParamForUnknown(otherCmdOpt)) {
-            return 1
-          }
+          if (otherCmdOpt && hasParamForUnknown(otherCmdOpt))
+            return 1;
         }
 
         if (hasParamForUnknown(null))
@@ -511,7 +516,7 @@ function createOptionProcessor() {
         return 0;
       }
 
-      function setCurrentOption(val) {
+      function setCurrentOption( val ) {
         if (currentCommand) {
           if (!result.options[currentCommand])
             result.options[currentCommand] = {};
@@ -522,20 +527,22 @@ function createOptionProcessor() {
         }
       }
 
-      function reportMissingParam(opt) {
-        let error = `Missing param "${opt.param}" for option "${opt.shortName ? opt.shortName + ', ': ''}${opt.longName}"`;
+      function reportMissingParam( opt ) {
+        const short = opt.shortName ? `${ opt.shortName }, ` : '';
+        let error = `Missing param "${ opt.param }" for option "${ short }${ opt.longName }"`;
         if (currentCommand) {
-          error = `${error} of command "${currentCommand}"`;
+          error = `${ error } of command "${ currentCommand }"`;
           result.cmdErrors.push(error);
-        } else {
+        }
+        else {
           result.errors.push(error);
         }
       }
 
-      function reportInvalidValue(opt, value) {
-        const shortOption = opt.shortName ? `${opt.shortName}, ` : ''
+      function reportInvalidValue( opt, value ) {
+        const shortOption = opt.shortName ? `${ opt.shortName }, ` : '';
         const errors = currentCommand ? result.cmdErrors : result.errors;
-        errors.push(`Invalid value "${value}" for option "${shortOption}${opt.longName}" - use one of [${opt.validValues}]`);
+        errors.push(`Invalid value "${ value }" for option "${ shortOption }${ opt.longName }" - use one of [${ opt.validValues }]`);
       }
 
       /**
@@ -544,17 +551,17 @@ function createOptionProcessor() {
        *
        * @returns {null|*}
        */
-      function paramForOption(opt, reportMissing = true) {
+      function paramForOption( opt, reportMissing = true ) {
         if (i + 1 >= argv.length || argv[i + 1].startsWith('-')) {
           if (reportMissing)
-            reportMissingParam(opt)
+            reportMissingParam(opt);
           return null;
         }
 
         const value = argv[i + 1];
-        if (!isValidOptionValue(opt, value) && reportMissing) {
+        if (!isValidOptionValue(opt, value) && reportMissing)
           reportInvalidValue(opt, value);
-        }
+
         return value;
       }
 
@@ -567,7 +574,7 @@ function createOptionProcessor() {
        * @param {object|null} opt
        * @returns {boolean}
        */
-      function hasParamForUnknown(opt) {
+      function hasParamForUnknown( opt ) {
         return ((!opt || opt.param) && (i + 1) < argv.length && !argv[i + 1].match('(^[.-])|[.](csn|cdl|cds|json)$'));
       }
     }
@@ -577,40 +584,40 @@ function createOptionProcessor() {
   // If 'command' is supplied, check only 'options.command', otherwise check
   // only top-level options
   // Return an array of complaints (possibly empty)
-  function verifyOptions(options, commandName = undefined, silent = false) {
+  function verifyOptions( options, commandName = undefined, silent = false ) {
     const result = [];
     let opts;
 
     if ((options.betaMode || options.beta) && !options.testMode && !silent) {
       const mode = options.beta ? 'beta' : 'beta-mode';
-      result.push(`Option --${mode} was used. This option should not be used in productive scenarios!`)
+      result.push(`Option --${ mode } was used. This option should not be used in productive scenarios!`);
     }
 
     if (options) {
       [
         'defaultBinaryLength', 'defaultStringLength',
-        /*'length', 'precision', 'scale'*/
-      ].forEach(facet => {
-        if(options[facet] && isNaN(options[facet])) {
-          result.push(`Invalid value "${options[facet]}" for option "--${facet}" - not an Integer`);
-        } else {
+        /* 'length', 'precision', 'scale' */
+      ].forEach((facet) => {
+        if (options[facet] && isNaN(options[facet]))
+          result.push(`Invalid value "${ options[facet] }" for option "--${ facet }" - not an Integer`);
+        else
           options[facet] = parseInt(options[facet]);
-        }
       });
     }
 
     if (commandName) {
       const cmd = optionProcessor.commands[commandName];
-      if (!cmd) {
-        throw new Error(`Expected existing command: "${cmd}"`);
-      }
+      if (!cmd)
+        throw new Error(`Expected existing command: "${ cmd }"`);
+
       opts = cmd.options;
       options = options[cmd] || {};
       if (typeof options === 'boolean') {
         // Special case: command without options
         options = {};
       }
-    } else {
+    }
+    else {
       opts = optionProcessor.options;
     }
     // Look at each supplied option
@@ -620,42 +627,43 @@ function createOptionProcessor() {
       if (!opt) {
         // Don't report commands in top-level options
         if ((commandName || !optionProcessor.commands[camelName]) && !silent) {
-          error = `Unknown option "${commandName ? commandName + '.' : ''}${camelName}"`;
+          const prefix = commandName ? `${commandName}.` : '';
+          error = `Unknown option "${prefix}${camelName}"`;
         }
-      } else {
+      }
+      else {
         const param = options[camelName];
-        error = verifyOptionParam(param, opt, commandName ? commandName + '.' : '');
+        error = verifyOptionParam(param, opt, commandName ? `${ commandName }.` : '');
       }
-      if (error) {
+      if (error)
         result.push(error);
-      }
     }
     // hard-coded option dependencies (they disappear with command)
     return result;
 
     // Verify parameter value 'param' against option definition 'opt'. Return an error
     // string or false for an accepted param. Use 'prefix' when mentioning the option name.
-    function verifyOptionParam(param, opt, prefix) {
+    function verifyOptionParam( param, opt, prefix ) {
       if (opt.param) {
         // Parameter is required for this option
-        if (typeof param === 'boolean') {
-          return `Missing value for option "${prefix}${opt.camelName}"`;
-        } else if (!isValidOptionValue(opt, param)) {
-          return `Invalid value "${param}" for option "${prefix}${opt.camelName}" - use one of [${opt.validValues}]`;
-        }
+        if (typeof param === 'boolean')
+          return `Missing value for option "${ prefix }${ opt.camelName }"`;
+        else if (!isValidOptionValue(opt, param))
+          return `Invalid value "${ param }" for option "${ prefix }${ opt.camelName }" - use one of [${ opt.validValues }]`;
+
         return false;
-      } else {
-        // Option does not expect a parameter
-        if (typeof param !== 'boolean') {
-          // FIXME: Might be a bit too strict in case of internal sub-options like 'forHana' etc...
-          return `Expecting boolean value for option "${prefix}${opt.camelName}"`;
-        }
       }
+      // Option does not expect a parameter
+      if (typeof param !== 'boolean') {
+        // FIXME: Might be a bit too strict in case of internal sub-options like 'forHana' etc...
+        return `Expecting boolean value for option "${ prefix }${ opt.camelName }"`;
+      }
+
       return false;
     }
   }
 
-  function isValidOptionValue(opt, value) {
+  function isValidOptionValue( opt, value ) {
     // Explicitly convert to string, input 'value' may be boolean
     value = String(value);
     if (!opt.validValues || !opt.validValues.length)
@@ -667,12 +675,12 @@ function createOptionProcessor() {
 
   // Return an array of unique camelNames of the options for the specified command
   // If invalid command -> an empty array
-  function camelOptionsForCommand(cmd) {
+  function camelOptionsForCommand( cmd ) {
     if (!cmd || !optionProcessor.commands[cmd])
-      return []
+      return [];
     cmd = optionProcessor.commands[cmd];
     const names = Object.keys(cmd.options).map(name => cmd.options[name].camelName);
-    return [...new Set(names)];
+    return [ ...new Set(names) ];
   }
 }
 
@@ -682,54 +690,55 @@ function createOptionProcessor() {
  * @param {string[]} argv Argument array
  * @param {number} i Current option index.
  */
-function splitSingleLetterOption(argv, i) {
+function splitSingleLetterOption( argv, i ) {
   const arg = argv[i];
   if (arg.length > 2) { // must be at least `-ab`.
     const rest = argv.slice(i + 1);
     argv.length = i; // trim array
-    argv.push(...arg.split('').slice(1).map(a => `-${a}`), ...rest);
+    argv.push(...arg.split('').slice(1).map(a => `-${ a }`), ...rest);
   }
 }
 
 /**
  * Return a camelCase name "fooBar" for a long option "--foo-bar"
  */
-function camelifyLongOption(opt) {
+function camelifyLongOption( opt ) {
   return opt.substring(2).replace(/-./g, s => s.substring(1).toUpperCase());
 }
 
 /**
  * Return a long option name like "--foo-bar" for a camel-case name "fooBar"
  */
-function uncamelifyLongOption(opt) {
-  return `--${opt.replace(/[A-Z]/g, s => '-' + s.toLowerCase())}`;
+function uncamelifyLongOption( opt ) {
+  const longForm = opt.replace(/[A-Z]/g, s => `-${ s.toLowerCase() }`);
+  return `--${ longForm }`;
 }
 
 /**
  * Check if 'opt' looks like a "-f" short option
  */
-function isShortOption(opt) {
+function isShortOption( opt ) {
   return /^-[a-zA-Z?]$/.test(opt);
 }
 
 /**
  * Check if 'opt' looks like a "--foo-bar" long option
  */
-function isLongOption(opt) {
+function isLongOption( opt ) {
   return /^--[a-zA-Z0-9-]+$/.test(opt);
 }
 
 /**
  * Check if 'opt' looks like a "<foobar>" parameter
  */
-function isParam(opt) {
+function isParam( opt ) {
   return /^<[a-zA-Z-]+>$/.test(opt);
 }
 
 /**
  * Check if 'arg' looks like "<foobar...>"
  */
-function isDynamicPositionalArgument(arg) {
+function isDynamicPositionalArgument( arg ) {
   return /^<[a-zA-Z-]+[.]{3}>$/.test(arg);
 }
 
@@ -738,5 +747,5 @@ module.exports = {
   isShortOption,
   isLongOption,
   isParam,
-  isDynamicPositionalArgument
+  isDynamicPositionalArgument,
 };