257 autocomplete options in flowr repl

src/cli/common/scripts-info.ts

@@ -36,7 +36,7 @@ export type ScriptInformation = MasterScriptInformation | HelperScriptInformatio
 /**
  * We hold `_scripts` internally, as the modifiable variant and export the readonly scripts
  */
-const _scripts = {
+const _scripts: Record<string, ScriptInformation> = {
 	'slicer': {
 		toolName:     'slicer',
 		target:       'slicer-app',
@@ -97,5 +97,8 @@ const _scripts = {
 	}
 }
 
-export const scripts = _scripts as Record<keyof typeof _scripts, ScriptInformation>
+export const scripts = _scripts satisfies Record<keyof typeof _scripts, ScriptInformation>
 
+export function getScriptInformation(scriptName: string): ScriptInformation | undefined{
+	return scripts[scriptName]
+}

src/cli/repl/core.ts

@@ -9,18 +9,103 @@ import { prompt } from './prompt'
 import type { ReplOutput} from './commands'
 import { commandNames, getCommand, standardReplOutput } from './commands'
 import * as readline from 'node:readline'
-import { splitAtEscapeSensitive } from '../../util/args'
+import { splitAtEscapeSensitive, splitAtEscapeSensitiveWithEmptyParameters } from '../../util/args'
 import { executeRShellCommand } from './commands/execute'
+import { guard } from '../../util/assert'
+import { getScriptInformation} from '../common/scripts-info'
+import type { OptionDefinition } from 'command-line-usage'
 
 const replCompleterKeywords = Array.from(commandNames, s => `:${s}`)
 
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
 export function replCompleter(line: string): [string[], string] {
+	const splitCommandList = splitAtEscapeSensitiveWithEmptyParameters(line)
+	//find command in commandlist
+	const keyword = replCompleterKeywords.find(k => splitCommandList[0] === k)
+	if(keyword !== undefined && keyword.startsWith(':')){
+		const singleCommand = getCommand(keyword.slice(1))
+		guard(singleCommand !== undefined, 'Keyword does not match any command')
+		if(singleCommand.script){
+			const scriptInformation = getScriptInformation(keyword.slice(1))
+			guard(scriptInformation !== undefined, 'script should be in script record')
+			const scriptOptions: OptionDefinition[] = scriptInformation.options
+			const possibleOptions :OptionDefinition[] = getPossibleCommandLineOptions(scriptOptions, splitCommandList)
+			const possibleCliOptionsAsString : string[] = extractCliStringsFromCommandOptions(possibleOptions)
+			//Only command was specified
+			if(splitCommandList.length < 2){
+				possibleCliOptionsAsString.push(' ')
+				return [possibleCliOptionsAsString, line]
+			}
+
+			const lastOptionInProgress = splitCommandList.at(-1)
+			guard(lastOptionInProgress !== undefined, 'splitCommandList cannot be of lenth 0')
+			const matchingOptionsLeft = possibleCliOptionsAsString.filter(o => o.startsWith(lastOptionInProgress))
+			if(matchingOptionsLeft.length === 0){
+				return [[], line]
+			}
+			if(matchingOptionsLeft.length === 1){
+				const commandWithoutLastEntry = splitCommandList.slice(0, -1).join(' ')
+				return [[commandWithoutLastEntry + ' ' + matchingOptionsLeft[0]], line]
+			}
+			matchingOptionsLeft.push(' ')
+			return [matchingOptionsLeft, line]
+		}
+	}
 	return [replCompleterKeywords.filter(k => k.startsWith(line)), line]
 }
 
+export function extractCliStringsFromCommandOptions(options: OptionDefinition[]):string[]{
+	const extractedCliStrings:string[] = []
+	options.forEach(o => {
+		extractedCliStrings.push('--' + o.name)
+		if(o.alias !== undefined){
+			extractedCliStrings.push('-' + o.alias)
+		}
+	})
+	return extractedCliStrings
+}
+
+function getPossibleCommandLineOptions(scriptOptions: OptionDefinition[], splitCommandList: string[]): OptionDefinition[] {
+	const optionUsed: Map<string, boolean> = new Map <string, boolean>()
+	scriptOptions.forEach(o => optionUsed.set(o.name, false))
+	for(let commandLineOptionIndex = 1; commandLineOptionIndex < splitCommandList.length; commandLineOptionIndex++){
+		if(splitCommandList[commandLineOptionIndex].substring(0,1) !== '-'){
+			continue
+		}
+		let cliOptionWithOutLeadingMinus: string = splitCommandList[commandLineOptionIndex].slice(1)
+		if(cliOptionWithOutLeadingMinus.substring(0,1) !== '-'){
+			const option = scriptOptions.find(o => o.alias === cliOptionWithOutLeadingMinus)
+			if(option !== undefined){
+				optionUsed.set(option.name, true)
+			} else {
+				continue
+			}
+		}
+
+		cliOptionWithOutLeadingMinus = cliOptionWithOutLeadingMinus.slice(1)
+		if(cliOptionWithOutLeadingMinus.substring(0,1) !== '-'){
+			if(optionUsed.has(cliOptionWithOutLeadingMinus)){
+				optionUsed.set(cliOptionWithOutLeadingMinus, true)
+			}
+		}
+	}
+	const possibleOptions : OptionDefinition[] = []
+	optionUsed.forEach((usedValue, optionName) => {
+		const newOption = scriptOptions.find(o => o.name === optionName)
+		guard(newOption !== undefined, 'Option contained must be in original Options list')	
+		if(usedValue){
+			if(newOption.multiple !== undefined && newOption.multiple){
+				possibleOptions.push(newOption)
+			}
+		} else {
+			possibleOptions.push(newOption)
+		}
+	})
+	return possibleOptions
+}
+
 export const DEFAULT_REPL_READLINE_CONFIGURATION: readline.ReadLineOptions = {
 	input:                   process.stdin,
 	output:                  process.stdout,

src/util/args.ts

@@ -48,3 +48,52 @@ export function splitAtEscapeSensitive(inputString: string, split = ' '): string
 
 	return args
 }
+
+/**
+ * This splits an input string on the given split string (e.g., ` `) but checks if the string is quoted or escaped.
+ * Also takes into account if you have the splitsymbol at the start and e.g `'  '` converts to  `['', '', '']` and `' a "b c" d '` converts to `['', 'a', 'b c', 'd', '']`
+ * Given an input string like `a "b c" d` with a space character as split this splits the arguments similar to common shell interpreters (i.e., `a`, `b c`, and `d`).
+ *
+ * @param inputString - The string to split
+ * @param split       - The **single** character to split on (can not be the backslash or quote)
+ */
+export function splitAtEscapeSensitiveWithEmptyParameters(inputString: string, split = ' '): string[] {
+	const args = []
+	let current = ''
+	let inQuotes = false
+	let escaped = false
+
+	for(const c of inputString) {
+		if(escaped) {
+			escaped = false
+			switch(c) {
+				case 'n': current += '\n'; break
+				case 't': current += '\t'; break
+				case 'r': current += '\r'; break
+				case 'v': current += '\v'; break
+				case 'f': current += '\f'; break
+				case 'b': current += '\b'; break
+				default: current += c
+			}
+		} else if(c === split && !inQuotes) {
+			args.push(current)
+			current = ''
+		} else if(c === '"' || c === "'") {
+			inQuotes = !inQuotes
+		} else if(c === '\\') {
+			escaped = true
+		} else {
+			current += c
+		}
+	}
+
+	if(current !== '') {
+		args.push(current)
+	}
+
+	if(inputString.slice(-1) === ' '){
+		args.push('')
+	}
+
+	return args
+}

test/functionality/cli/cli.spec.ts

@@ -0,0 +1,3 @@
+describe('CLI', () => {
+	require('./repl-tests')
+})

test/functionality/cli/repl-tests.ts

@@ -0,0 +1,26 @@
+import { assert } from 'chai'
+import { replCompleter } from '../../../src/cli/repl'
+import { benchmarkOptions } from '../../../src/cli/common/options'
+
+describe('Repl', () => {
+	describe('completer', () => {
+		describe('basic find', () =>
+			assert.deepStrictEqual([[':slicer'], ':slice'], replCompleter(':slice'), 'standard replCompleter not producing expected result')
+
+		)
+		describe('find all options', () => {
+			const optionsList: string[] = []
+			for(const [,{name, alias}] of Object.entries(benchmarkOptions)){
+				optionsList.push('--' + name)
+				if(alias !== undefined){
+					optionsList.push('-' + alias)
+				}
+			}
+			optionsList.push(' ')
+			const resultCompleter = replCompleter(':benchmark ')
+			assert.includeMembers(resultCompleter[0], optionsList, 'Additional options that should not be there')
+			assert.includeMembers(optionsList, resultCompleter[0], 'Options missing in the expected Result')
+			assert.strictEqual(resultCompleter[1], ':benchmark ')
+		})
+	})
+})