command-line-director 1.0.0

package/CHANGELOG

@@ -0,0 +1,10 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+
+## [1.0.0] - 2021-21-09
+
+### Added
+- Initial release

package/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2016 Marco Jonker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software 
+and associated documentation files (the "Software"), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, publish, distribute, 
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is 
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial 
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT 
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,158 @@
+# COMMAND LINE DIRECTOR #
+
+The command line director give direction to you command line arguments. With the command line director you can configure, validate and direct the command line argument supported by your nodejs command line application.
+
+# QUICKSTART #
+
+**STEP 1:** Install
+```
+npm install command-line-director
+```
+
+**STEP 2:** Add the command line director to your application (see chapter 'sample')
+
+**STEP 3:** Run your application
+
+# CONFIGURATION #
+
+The configuration the the command line director exists of 3 classes. The CommandLineDirector that contains a set of CommandLines. Each CommandLine exists of one or more CommandLineArguments.
+
+## Configuring the CommandLineDirector
+
+The command line direction the class that contains all the application's command line and maps the input argument to a specific Command. It also contain a title and a description of the application, which is printed a the top of the generated help. For an example see the chapter 'sample'. The CommandLineDirector has 2 public functions:
+
+* parse(verbose) - To parse the current command line arguments to a specific command. If verbose is true information about why a command is not found is printen at stdout
+* generateHelp - To Generate a help text
+
+## Configuring a CommandLine
+
+A command line the configuration of a set of arguments that defines a specific command. It also contains a title and a description of a CommandLine, which is printed in the generated Help. For an example see the chapter 'sample'.
+
+## Configuring a CommandLineArgument ##
+
+The most used types of argument can be defined using the CommandLineArgument factory. The factory can be used to create a key value argument, a flag argument and a value argument.
+
+### Key value argument ###
+
+A key value argument is a string argument with a key. The key value argument can be define with the following properties:
+
+* propertyName - Name of the property that will contain the value when the command is parsed
+* description - Description of the flag that is displayed in the command line help
+* argumentName - Name of the argument in the command line (exmaple: '--test-flag')
+* alias - Alias for the name of the argument (example: '-tf')
+* required - Value is required or optional
+* allowedValues - Array of allowed values
+* regularExpression - regular expression for validating the value
+
+Sample of creating a value argument:
+
+```
+const argumentFactory = new CommandLineArgumentFactory()
+argumentFactory.keyValueArgument('testValue', 'Used for testing', true, '--test-value', '-tv', ['test1', 'test2'], new RegEx('^A-Z*$'))
+```
+
+### Flag argument ###
+
+A flag argument a boolean argument. If a flag is present in the command line argument the boolean value will be set to true. The flag argument can be define with the following properties:
+
+* propertyName - Name of the property that will contain the value when the command is parsed
+* description - Description of the flag that is displayed in the command line help
+* argumentName - Name of the argument in the command line (exmaple: '--test-flag')
+* alias - Alias for the name of the argument (example: '-tf')
+
+Sample of creating a flag argument:
+
+```
+const argumentFactory = new CommandLineArgumentFactory()
+argumentFactory.flagArgument('testFlag', 'Used for testing', '--test-flag', '-tf')
+```
+
+### Value argument ###
+
+A value argument is a string argument without a key. A value argument can be detected by allowed values, a regex or just by value. A usecase can be passing a file path a last argument. The value argument can be define with the following properties:
+
+* propertyName - Name of the property that will contain the value when the command is parsed
+* description - Description of the flag that is displayed in the command line help
+* required - Value is required or optional
+* allowedValues - Array of allowed values
+* regularExpression - regular expression for validating the value
+
+Sample of creating a value argument:
+
+```
+const argumentFactory = new CommandLineArgumentFactory()
+argumentFactory.valueArgument('testValue', 'Used for testing', true, ['test1', 'test2'], new RegEx('^A-Z*$'))
+```
+
+# Sample #
+This is an example that can handle the following commands:
+* node ./samples/app ?
+* node ./samples/app.js open "from-path"
+* node ./samples/app.js cf --from="from-path" -to="to-path"
+* node ./samples/app.js cf --remove-source --from="from-path" -to="to-path"
+* node ./samples/app.js cf -rs -f="from-path" -t="to-path"
+
+```
+const CommandLineDirector = require('../lib/command-line-director')
+const CommandLine = require('../lib/command-line')
+const CommandLineArgumentFactory = require('../lib/command-line-argument-factory')
+
+class App {
+    constructor() {
+        const argumentFactory = new CommandLineArgumentFactory()
+
+        const commandLines = [
+            // node ./samples/app ?
+            new CommandLine('help-identifier', 'Help', 'Show help', [
+                argumentFactory.valueArgument('command', '?', true, ['?']),
+            ]),
+            // node ./samples/app.js open "from-path"
+            new CommandLine('open-identifier', 'Open', 'Open a file', [
+                argumentFactory.valueArgument('command', 'Open command', true, ['open']),
+                argumentFactory.valueArgument('fileName', 'Name of the file to open', true),
+            ]),
+            // node ./samples/app.js cf --from="from-path" -to="to-path"
+            // node ./samples/app.js cf --remove-source --from="from-path" -to="to-path"
+            // node ./samples/app.js cf -rs -f="from-path" -t="to-path"
+            new CommandLine('copy-file-identifier', 'Copy', 'Copy a file', [
+                argumentFactory.valueArgument('command', 'Copy file command', true, ['cf']),
+                argumentFactory.flagArgument('removeSource', 'Remove the source file', '--remove-source', '-rs'),
+                argumentFactory.keyValueArgument('from', 'From path', true, '--from', '-f'),
+                argumentFactory.keyValueArgument('to', 'To path', true, '--to', '-t'),
+            ]),
+        ]
+
+        this.commandLineDirector = new CommandLineDirector(
+            'File functions', 
+            'A coomand line tool for special file operations', 
+            commandLines)
+    }
+
+    run() {
+        const command = this.commandLineDirector.parse()
+
+        if(command) {
+            switch(command.identifier) {
+                case 'help-identifier':
+                    console.log(this.commandLineDirector.generateHelp())
+                    break
+                case 'open-identifier':
+                    console.log(`Open a file with values: ${JSON.stringify(command.values)}`)
+                    break
+                case 'copy-file-identifier':
+                    console.log(`Copy a file with values: ${JSON.stringify(command.values)}`)
+                    break
+                default:
+                    console.error('unknown command')
+                    break
+            }
+        } else {
+            console.error('unknown command')
+        }
+    }
+}
+
+const app = new App()
+app.run()
+```
+

package/lib/command-line-argument-data-type.js

@@ -0,0 +1,7 @@
+const CommandLineArgumentDataType = {
+  Boolean: 'BOOLEAN',
+  Number: 'NUMBER',
+  String: 'STRING'
+}
+
+module.exports = CommandLineArgumentDataType

package/lib/command-line-argument-factory.js

@@ -0,0 +1,86 @@
+const CommandLineArgumentDataType = require('./command-line-argument-data-type')
+const CommandLineArgumentType = require('./command-line-argument-type')
+const CommandLineArgument = require('./command-line-argument')
+
+class CommandLineArgumentFactory {
+    /**
+     * Create string argument
+     * Examples:
+     * --dir="/var/www/test"
+     * -d="/var/www/test"
+     *
+     * @param propertyName - string
+     * @param description - string
+     * @param required - boolean
+     * @param argumentName - string
+     * @param alias - string
+     * @param defaultValue - string
+     * @param allowedValues
+     * @param regularExpression
+     */
+    keyValueArgument(propertyName, description, required, argumentName, alias, defaultValue, allowedValues, regularExpression) {
+        return new CommandLineArgument(
+            propertyName,
+            required,
+            argumentName,
+            alias,
+            CommandLineArgumentDataType.String,
+            CommandLineArgumentType.KeyValue,
+            defaultValue,
+            allowedValues,
+            regularExpression,
+            description)
+    }
+
+    /**
+     * Create boolean argument
+     * Examples:
+     * --force
+     * -f
+     *
+     * @param propertyName - string
+     * @param description - string
+     * @param argumentName - string
+     * @param alias - string
+     */
+    flagArgument(propertyName, description, argumentName, alias) {
+        return new CommandLineArgument(
+            propertyName,
+            false,
+            argumentName,
+            alias,
+            CommandLineArgumentDataType.Boolean,
+            CommandLineArgumentType.KeyValue,
+            false,
+            null,
+            null,
+            description)
+    }
+
+    /**
+     * Create command
+     * Examples:
+     * init
+     *
+     * @param propertyName - string
+     * @param description
+     * @param required - boolean
+     * @param allowedValues
+     * @param regularExpression
+     */
+    valueArgument(propertyName, description, required, allowedValues, regularExpression) {
+        return new CommandLineArgument(
+            propertyName,
+            required,
+            null,
+            null,
+            CommandLineArgumentDataType.String,
+            CommandLineArgumentType.Value,
+            null,
+            allowedValues,
+            regularExpression,
+            description)
+    }
+}
+
+module.exports = CommandLineArgumentFactory

package/lib/command-line-argument-type.js

@@ -0,0 +1,6 @@
+const CommandLineArgumentType = {
+  KeyValue: 'KEYVALUE',
+  Value: 'VALUE'
+}
+
+module.exports = CommandLineArgumentType

package/lib/command-line-argument.js

@@ -0,0 +1,84 @@
+const CommandLineArgumentDataType = require('./command-line-argument-data-type')
+const CommandLineArgumentType = require('./command-line-argument-type')
+
+class CommandLineArgument {
+  /**
+     * CommandLineArgument Constructor
+     * @param propertyName - string
+     * @param required - boolean
+     * @param argumentName - string
+     * @param alias - string
+     * @param dataType - CommandLineArgumentDataType
+     * @param type - CommandLineArgumentType
+     * @param defaultValue
+     * @param allowedValues
+     * @param regularExpression
+     * @param description
+     */
+  constructor (propertyName, required, argumentName, alias, dataType, type, defaultValue, allowedValues, regularExpression, description) {
+    if (!propertyName) {
+      throw new Error("'propertyName' parameter not defined.")
+    }
+
+    if (required === undefined || required === null) {
+      throw new Error("'required' parameter not defined.")
+    }
+
+    if (type !== CommandLineArgumentType.KeyValue && type !== CommandLineArgumentType.Value) {
+      throw new Error("'type' parameter invalid.")
+    }
+
+    if (!argumentName && type === CommandLineArgumentType.KeyValue) {
+      throw new Error("'argumentName' parameter not defined.")
+    }
+
+    if (allowedValues && Array.isArray(allowedValues) === false) {
+      throw new Error("'allowedValues' parameter should be an array.")
+    }
+
+    this.propertyName = propertyName
+    this.required = Boolean(required)
+    this.argumentName = argumentName
+    this.alias = (alias !== undefined) ? alias : null
+    this.dataType = dataType || CommandLineArgumentDataType.String
+    this.type = type
+    this.defaultValue = defaultValue
+    this.allowedValues = allowedValues || null
+    this.regularExpression = regularExpression || null
+    this.description = description
+  }
+
+  toString () {
+    let help = ''
+    let title = ''
+
+    if (this.argumentName) {
+      title = `  ${this.argumentName},${this.alias}`
+    } else if (this.allowedValues) {
+      title = `  ${this.allowedValues}`
+    } else {
+      title = '  <string>'
+    }
+
+    help += title
+    for (let i = 0; i < 24 - title.length; i++) {
+      help += ' '
+    }
+
+    help += ` ${this.required ? 'R' : 'O'} | ${this.dataType}`
+
+    if (this.argumentName && this.allowedValues) {
+      help += ` | VALUES = ${this.allowedValues}`
+    }
+
+    if (this.regularExpression) {
+      help += ` | PATTERN = ${this.regularExpression.toString()}`
+    }
+
+    help += ` | ${this.description}`
+
+    return help
+  }
+}
+
+module.exports = CommandLineArgument

package/lib/command-line-director.js

@@ -0,0 +1,83 @@
+const Command = require('./command')
+
+class CommandLineDirector {
+  constructor (title, description, commandLines) {
+    this.title = title
+    this.description = description
+    if (Array.isArray(commandLines)) {
+      this.commandLines = commandLines
+    } else {
+      throw new Error("Invalid argument 'commandLines', value should be of type 'array'")
+    }
+  }
+
+  _removeQuotes (text) {
+    return text.replace(/['"]+/g, '')
+  }
+
+  _createArgumentLookupFromProcessArguments (cmdArguments) {
+    const lookup = {
+      values: [],
+      keyValues: {}
+    }
+
+    cmdArguments.forEach((cmdArgument) => {
+      const keyValue = cmdArgument.split('=')
+      // Flag of key value type
+      if (typeof keyValue[0] === 'string' && keyValue[0].charAt(0) === '-') {
+        const value = keyValue.length === 2 ? this._removeQuotes(keyValue[1]) : true
+        const keyName = keyValue[0]
+        lookup.keyValues[keyName] = value
+        // Value type
+      } else {
+        lookup.values.push(this._removeQuotes(cmdArgument))
+      }
+    })
+
+    return lookup
+  }
+
+  parseArguments (cmdArguments, verbose) {
+    const lookup = this._createArgumentLookupFromProcessArguments(cmdArguments)
+    let command = null
+
+    for (let i = 0; i < this.commandLines.length; i++) {
+      const commandLine = this.commandLines[i]
+      try {
+        command = commandLine.commandFromLookup(lookup)
+        break
+      } catch (error) {
+        if (verbose) {
+          console.info(error.message)
+        }
+        command = null
+      }
+    };
+
+    return command
+  }
+
+  parse (verbose) {
+    return this.parseArguments(process.argv.slice(2), verbose)
+  }
+
+  generateHelp () {
+    let help = '\r\n=======================================================================\r\n'
+    help += `\r\n${this.title.toUpperCase()}\r\n${this.description}\r\n\r\n`
+
+    this.commandLines.forEach((commandLine) => {
+      help += '-----------------------------------------------------------------------\r\n'
+      help += `${commandLine.title.toUpperCase()} - ${commandLine.description}\r\n\r\n`
+
+      commandLine.commandLineArguments.forEach((argument) => {
+        help += `${argument.toString()}\r\n`
+      })
+      help += '\r\n'
+    })
+
+    help += '=======================================================================\r\n'
+    return help
+  }
+}
+
+module.exports = CommandLineDirector

package/lib/command-line.js

@@ -0,0 +1,125 @@
+const CommandLineArgumentDataType = require('./command-line-argument-data-type')
+const CommandLineArgumentType = require('./command-line-argument-type')
+const Command = require('./command')
+
+class CommandLine {
+  /**
+     * CommandLine constructor
+     * @param identifier - string
+     * @param commandLineArguments - array
+     * @thows Error
+     */
+  constructor (identifier, title, description, commandLineArguments) {
+    this.identifier = identifier
+    this.title = title
+    this.description = description
+    this.commandLineArguments = []
+    if (Array.isArray(commandLineArguments)) {
+      this.commandLineArguments = commandLineArguments
+    } else {
+      throw new Error("Invalid argument 'commandLineArguments', value should be of type 'array'")
+    }
+  }
+
+  /**
+     * Create lookup table for process arguments
+     * @result object
+     */
+
+  _parseDataType (value, dataType) {
+    let parsedValue = null
+
+    if (value !== undefined && value !== null) {
+      switch (dataType) {
+        case CommandLineArgumentDataType.Boolean:
+          parsedValue = Boolean(value)
+          break
+        case CommandLineArgumentDataType.Number:
+          parsedValue = Number(value)
+          if (isNaN(parsedValue)) {
+            parsedValue = null
+          }
+          break
+        case CommandLineArgumentDataType.String:
+          parsedValue = String(value)
+          break
+        default: {
+          throw new Error(`Unknown data type '${dataType}.`)
+        }
+      }
+
+      if (parsedValue === null) {
+        throw new Error(`Could not parse value '${value}' to data type '${dataType}.`)
+      }
+    }
+
+    return parsedValue
+  }
+
+  /**
+     * Create command from argument lookup
+     * @param argument lookup
+     * @result command
+     * @throws Error
+     */
+  commandFromLookup (argumentLookup) {
+    const result = {}
+    const values = argumentLookup.values
+    const keyValues = argumentLookup.keyValues
+    let valueIndex = 0
+
+    // Check all the arguments
+    this.commandLineArguments.forEach((arg) => {
+      if (arg.type === CommandLineArgumentType.KeyValue) {
+        if (keyValues[arg.argumentName] !== undefined) {
+          result[arg.propertyName] = keyValues[arg.argumentName]
+        } else if (keyValues[arg.alias] !== undefined) {
+          result[arg.propertyName] = keyValues[arg.alias]
+        }
+      } else if (arg.type === CommandLineArgumentType.Value) {
+        if (values.length > valueIndex) {
+          result[arg.propertyName] = values[valueIndex]
+          valueIndex++
+        }
+      } else {
+        throw new Error('Invalid command line argument type')
+      }
+
+      // Set the default value if avaiable
+      if (result[arg.propertyName] === undefined && arg.defaultValue !== undefined) {
+        result[arg.propertyName] = arg.defaultValue
+      }
+
+      // Parse data to the correct data type
+      if (result[arg.propertyName] !== undefined) {
+        result[arg.propertyName] = this._parseDataType(result[arg.propertyName], arg.dataType)
+      }
+    })
+
+    // Check all the arguments
+    this.commandLineArguments.forEach(function (arg) {
+      // Check if required field exists
+      if (arg.required === true && (result[arg.propertyName] === undefined || result[arg.propertyName] === null)) {
+        throw new Error(`Required field '${arg.propertyName}' is missing.`)
+      }
+
+      // Check if value is allowed
+      if (arg.allowedValues && (arg.required === true || (result[arg.propertyName] !== undefined && result[arg.propertyName] !== null))) {
+        if (arg.allowedValues.indexOf(result[arg.propertyName]) === -1) {
+          throw new Error(`Value for field '${arg.propertyName}' is not allowed.`)
+        }
+      };
+
+      // Check if value meets regex
+      if (arg.regularExpression && (arg.required === true || (result[arg.propertyName] !== undefined && result[arg.propertyName] !== null))) {
+        if (!arg.regularExpression.test(result[arg.propertyName])) {
+          throw new Error(`Value for field field '${arg.propertyName}' is invalid.`)
+        }
+      }
+    })
+
+    return new Command(this.identifier, this.commandLineArguments, result)
+  }
+}
+
+module.exports = CommandLine

package/lib/command.js

@@ -0,0 +1,9 @@
+class Command {
+  constructor (identifier, commandLineArguments, values) {
+    this.identifier = identifier
+    this.commandLineArguments = commandLineArguments
+    this.values = values
+  }
+}
+
+module.exports = Command

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "command-line-director",
+  "version": "1.0.0",
+  "description": "Gives direction to you nodejs command line application",
+  "main": "./lib/command-line-director.js",
+  "keywords": [
+    "command line",
+    "command line parser",
+    "command line mapper",
+    "command line arguments",
+    "arguments"
+  ],
+  "bugs": "https://github.com/marcojonker/command-line-director/issues",
+  "license": "MIT",
+  "scripts": {
+    "test": "./node_modules/mocha/bin/mocha"
+  },
+  "author": "Marco Jonker",
+  "files": [
+    "package.json",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG",
+    "lib",
+    "test"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/marcojonker/command-line-director.git"
+  },
+  "homepage": "http://www.cacadu.eu/opensource",
+  "dependencies": {},
+  "devDependencies": {
+    "eslint": "^7.32.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^5.1.0",
+    "mocha": "^9.1.1"
+  },
+  "engines": {
+    "node": ">=12.10.0"
+  }
+}

package/test/integration-test.js

@@ -0,0 +1,198 @@
+var assert = require('assert');
+const CommandLineDirector = require('../lib/command-line-director')
+const CommandLine = require('../lib/command-line')
+const CommandLineArgumentFactory = require('../lib/command-line-argument-factory')
+
+describe('Integration test', function () {
+  const argumentFactory = new CommandLineArgumentFactory();
+
+  it('should handle string key value arguments correct', () => {
+    const commandLines = [
+      new CommandLine('test1', 'title1', 'title1 description', [
+        argumentFactory.keyValueArgument('param1', 'param1 description', true, '--param1', '-p1'),
+        argumentFactory.keyValueArgument('param2', 'param2 description', false, '--param2', '-p2', 'defaultParam2', ['defaultParam2', 'test']),
+        argumentFactory.keyValueArgument('param3', 'param3 description', false, '--param3', '-p3', '100', null, new RegExp('^[0-9]*$')),
+        argumentFactory.keyValueArgument('param4', 'param4 description', false, '--param4', '-p4')
+      ]),
+    ]
+  
+    const commandLineDirector = new CommandLineDirector('title', 'description', commandLines)
+  
+    let command = commandLineDirector.parseArguments([''], true)
+    assert.equal(command, null);
+
+    // required value set
+    command = commandLineDirector.parseArguments(['--param1=test'], true)
+    assert.equal(command.values['param1'], 'test');
+    assert.equal(command.values['param2'], 'defaultParam2');
+    assert.equal(command.values['param3'], '100');
+    assert.equal(command.values['param4'], undefined);
+
+    // allwed values invalid
+    command = commandLineDirector.parseArguments(['--param1=test', '--param2=invalid'], true)
+    assert.equal(command, null);
+
+    // allwed values valid
+    command = commandLineDirector.parseArguments(['--param1=test', '--param2=test'], true)
+    assert.equal(command.values['param1'], 'test');
+    assert.equal(command.values['param2'], 'test');
+
+    // regex invalid
+    command = commandLineDirector.parseArguments(['--param1=test', '--param3=test'], true)
+    assert.equal(command, null);
+
+    // regex valid
+    command = commandLineDirector.parseArguments(['--param1=test', '--param3=200'], true)
+    assert.equal(command.values['param1'], 'test');
+    assert.equal(command.values['param3'], '200');
+
+    // not required param
+    command = commandLineDirector.parseArguments(['--param1=test', '--param4=test'], true)
+    assert.equal(command.values['param1'], 'test');
+    assert.equal(command.values['param4'], 'test');
+
+    // alias
+    command = commandLineDirector.parseArguments(['-p1=test1', '-p2=test', '-p3=300', '-p4=test4'], true)
+    assert.equal(command.values['param1'], 'test1');
+    assert.equal(command.values['param2'], 'test');
+    assert.equal(command.values['param3'], '300');
+    assert.equal(command.values['param4'], 'test4');
+  
+    // strip unknown param
+    command = commandLineDirector.parseArguments(['-p1=test1', '-p2=test', '-p3=300', '-p4=test4', '--param5=test5'], true)
+    assert.equal(command.values['param1'], 'test1');
+    assert.equal(command.values['param2'], 'test');
+    assert.equal(command.values['param3'], '300');
+    assert.equal(command.values['param4'], 'test4');
+    assert.equal(command.values['param5'], undefined);
+  });
+
+  it('should handle flag key value arguments correct', () => {
+    const commandLines = [
+      new CommandLine('test3', 'title3', 'title 3 description', [
+        argumentFactory.flagArgument('param1', 'param1 description', '--param1', '-p1')
+      ]),
+    ]
+  
+    const commandLineDirector = new CommandLineDirector('title', 'description', commandLines)
+  
+    let command = commandLineDirector.parseArguments([''], true)
+    assert.equal(command.values['param1'], false);
+
+    command = commandLineDirector.parseArguments(['--param1'], true)
+    assert.equal(command.values['param1'], true);
+
+    command = commandLineDirector.parseArguments(['-p1'], true)
+    assert.equal(command.values['param1'], true);
+  });
+
+  it('should handle string value arguments correct', () => {
+    const commandLines = [
+      new CommandLine('test4', 'title4', 'title 4 description', [
+        argumentFactory.valueArgument('param1', 'param1 description', true, ['value1', 'value2']),
+        argumentFactory.valueArgument('param2', 'param2 description', true, ['value3', 'value4']),
+        argumentFactory.valueArgument('param3', 'param3 description', false, ['value5', 'value6']),
+        argumentFactory.valueArgument('param4', 'param4 description', false),
+      ]),
+    ]
+  
+    const commandLineDirector = new CommandLineDirector('title', 'description', commandLines)
+  
+    let command = commandLineDirector.parseArguments([''], true)
+    assert.equal(command, null);
+
+    command = commandLineDirector.parseArguments(['value1'], true)
+    assert.equal(command, null);
+
+    command = commandLineDirector.parseArguments(['value1', 'value4'], true)
+    assert.equal(command.values['param1'], 'value1');
+    assert.equal(command.values['param2'], 'value4');
+
+    command = commandLineDirector.parseArguments(['value1', 'value3', 'value6'], true)
+    assert.equal(command.values['param1'], 'value1');
+    assert.equal(command.values['param2'], 'value3');
+    assert.equal(command.values['param3'], 'value6');
+
+    command = commandLineDirector.parseArguments(['value1', 'value3', 'value6', '"http://url.test"'], true)
+    assert.equal(command.values['param1'], 'value1');
+    assert.equal(command.values['param2'], 'value3');
+    assert.equal(command.values['param3'], 'value6');
+    assert.equal(command.values['param4'], 'http://url.test');
+  });  
+
+  it('should generate a help text', () => {
+    const commandLines = [
+      new CommandLine('test1', 'title1', 'title 1 description', [
+        argumentFactory.keyValueArgument('param1', 'param1 description', true, '--param1', '-p1'),
+        argumentFactory.keyValueArgument('param2', 'param2 description', false, '--param2', '-p2', 'defaultParam2', ['defaultParam2', 'test']),
+        argumentFactory.keyValueArgument('param3', 'param3 description', false, '--param3', '-p3', '100', null, new RegExp('^[0-9]*$')),
+        argumentFactory.keyValueArgument('param4', 'param4 description', false, '--param4', '-p4')
+      ]),
+      new CommandLine('test2', 'title2', 'title 2 description', [
+        argumentFactory.keyValueArgument('param1', 'param1 description', true, '--param1', '-p1'),
+        argumentFactory.keyValueArgument('param2', 'param2 description', false, '--param2', '-p2', 200, [200, 201]),
+        argumentFactory.keyValueArgument('param3', 'param3 description', false, '--param3', '-p3')
+      ]),
+      new CommandLine('test3', 'title3', 'title 3 description', [
+        argumentFactory.flagArgument('param1', 'param1 description', '--param1', '-p1')
+      ]),
+      new CommandLine('test4', 'title4', 'title 4 description', [
+        argumentFactory.valueArgument('param1', 'param1 description', true, ['value1', 'value2']),
+        argumentFactory.valueArgument('param2', 'param2 description', true, ['value3', 'value4']),
+        argumentFactory.valueArgument('param3', 'param3 description', false, ['value5', 'value6']),
+        argumentFactory.valueArgument('param4', 'param4 description', false)
+      ]),
+    ]
+
+    const commandLineDirector = new CommandLineDirector('title', 'description', commandLines)
+    const helpText = commandLineDirector.generateHelp();
+
+    assert.equal(helpText.includes('TITLE1'), true)
+    assert.equal(helpText.includes('TITLE2'), true)
+    assert.equal(helpText.includes('TITLE3'), true)
+    assert.equal(helpText.includes('TITLE4'), true)
+    assert.equal(helpText.includes('title 1 description'), true)
+    assert.equal(helpText.includes('param1 descriptio'), true)
+    assert.equal(helpText.includes(' R '), true)
+    assert.equal(helpText.includes('--param1,-p1'), true)
+  });
+
+  it('should handle realworld example correct', () => {
+    const commandLines = [
+      new CommandLine('list-identifier', 'List', 'Create a list of items', [
+        argumentFactory.valueArgument('command', 'command', true, ['list']),
+        argumentFactory.flagArgument('delete', 'delete the list', '--delete', '-d'),
+      ]),
+      new CommandLine('open-identifier', 'Open', 'Open an item', [
+        argumentFactory.valueArgument('command', 'command', true, ['open', 'display']),
+        argumentFactory.flagArgument('all', 'Open all items', '--all', '-a'),
+        argumentFactory.keyValueArgument('id', 'id to open', false, '--identifier', '-id'),
+      ]),
+      new CommandLine('update-identifier', 'Update', 'Updat an item', [
+        argumentFactory.valueArgument('command', 'command', true, ['update']),
+        argumentFactory.flagArgument('all', 'Open all items', '--all', '-a'),
+        argumentFactory.keyValueArgument('id', 'id to open', false, '--identifier', '-id'),
+      ]),
+    ]
+  
+    const commandLineDirector = new CommandLineDirector('File cli', 'file cli description', commandLines)
+    const helpText = commandLineDirector.generateHelp();
+
+    let command = commandLineDirector.parseArguments(['list', '-d'], true)
+    assert.equal(command.identifier, 'list-identifier');
+    assert.equal(command.values['command'], 'list');
+    assert.equal(command.values['delete'], true);
+
+    command = commandLineDirector.parseArguments(['display', '--all', '--identifier=12'], true)
+    assert.equal(command.identifier, 'open-identifier');
+    assert.equal(command.values['command'], 'display');
+    assert.equal(command.values['all'], true);
+    assert.equal(command.values['id'], 12);
+
+    command = commandLineDirector.parseArguments(['update', '-a', '-id=100'], true)
+    assert.equal(command.identifier, 'update-identifier');
+    assert.equal(command.values['command'], 'update');
+    assert.equal(command.values['all'], true);
+    assert.equal(command.values['id'], 100);
+  });    
+});