/// <summary>
/// Runs the application with specified command line and environment variables, and returns the exit code.
/// </summary>
/// <remarks>
/// If a <see cref="CommandException"/>, <see cref="DirectiveException"/>, or <see cref="TypinException"/> is thrown during command execution,
/// it will be handled and routed to the console. Additionally, if the debugger is not attached (i.e. the app is running in production),
/// all other exceptions thrown within this method will be handled and routed to the console as well.
/// </remarks>
public async ValueTask <int> RunAsync(string commandLine, IReadOnlyDictionary <string, string> environmentVariables, bool containsExecutable = false)
{
IEnumerable <string> commandLineArguments = CommandLineSplitter.Split(commandLine)
.Skip(containsExecutable ? 1 : 0);
return(await RunAsync(commandLineArguments, environmentVariables));
}
/// <summary>
/// Gets user input and returns arguments or null if cancelled.
/// </summary>
private async Task <IEnumerable <string> > GetInputAsync(string executableName)
{
IConsole console = _console;
// Print prompt
ConsoleColor promptForeground = _options.PromptForeground;
console.Output.WithForegroundColor(promptForeground, (output) => output.Write(executableName));
string scope = _options.Scope;
bool hasScope = !string.IsNullOrWhiteSpace(scope);
if (hasScope)
{
console.Output.WithForegroundColor(_options.ScopeForeground, (output) =>
{
output.Write(' ');
output.Write(scope);
});
}
console.Output.WithForegroundColor(promptForeground, (output) => output.Write("> "));
// Read user input
console.ForegroundColor = _options.CommandForeground;
string?line = string.Empty; // Can be null when Ctrl+C is pressed to close the app.
if (_autoCompleteInput is null)
{
line = await console.Input.ReadLineAsync();
}
else
{
line = await _autoCompleteInput.ReadLineAsync(console.GetCancellationToken());
}
console.ForegroundColor = ConsoleColor.Gray;
IEnumerable <string> arguments = Enumerable.Empty <string>();
if (!string.IsNullOrWhiteSpace(line))
{
if (hasScope) // handle scoped command input
{
List <string> tmp = CommandLineSplitter.Split(line).ToList();
int lastDirective = tmp.FindLastIndex(x => x.StartsWith('[') && x.EndsWith(']'));
tmp.Insert(lastDirective + 1, scope);
arguments = tmp.ToArray();
}
else // handle unscoped command input
{
arguments = CommandLineSplitter.Split(line);
}
}
return(arguments);
}
/// <summary>
/// Runs the application with specified command line and returns the exit code.
/// Environment variables are retrieved automatically.
/// </summary>
/// <remarks>
/// If a <see cref="CommandException"/>, <see cref="DirectiveException"/>, or <see cref="TypinException"/> is thrown during command execution,
/// it will be handled and routed to the console. Additionally, if the debugger is not attached (i.e. the app is running in production),
/// all other exceptions thrown within this method will be handled and routed to the console as well.
/// </remarks>
public async ValueTask <int> RunAsync(string commandLine, bool containsExecutable = false)
{
IEnumerable <string> commandLineArguments = CommandLineSplitter.Split(commandLine)
.Skip(containsExecutable ? 1 : 0);
return(await RunAsync(commandLineArguments));
}
public void CLS001(string commandLine, string expectedCommand, string expectedArguments)
{
// arrange, act
var result = CommandLineSplitter.Split(commandLine);
// assert
result.Command.Should().Be(expectedCommand);
result.Arguments.Should().Be(expectedArguments);
}
public void ShouldParse(string commandLine, string[] results)
{
//Act
IEnumerable <string> splitted = CommandLineSplitter.Split(commandLine);
//Assert
splitted.Count().Should().Be(results.Length);
splitted.Should().Equal(results);
}
private void VerifyCommandLineSplitter(string commandLine, string[] expected)
{
string[] actual = CommandLineSplitter.SplitCommandLine(commandLine);
Assert.Equal(expected.Length, actual.Length);
for (int i = 0; i < actual.Length; ++i)
{
Assert.Equal(expected[i], actual[i]);
}
}
/// <summary>
/// Runs the application and returns the exit code.
/// Command line arguments and environment variables are retrieved automatically.
/// </summary>
/// <remarks>
/// If a <see cref="CommandException"/> is thrown during command execution, it will be handled and routed to the console.
/// Additionally, if the debugger is not attached (i.e. the app is running in production), all other exceptions thrown within
/// this method will be handled and routed to the console as well.
/// </remarks>
public async ValueTask <int> RunAsync()
{
string line = Environment.CommandLine;
string[] commandLineArguments = CommandLineSplitter.Split(line)
.Skip(1)
.ToArray();
return(await RunAsync(commandLineArguments));
}
public void ShouldParse(string commandLine, string[] results)
{
//Act
IEnumerable <string> split = CommandLineSplitter.Split(commandLine);
_output.WriteLine(commandLine);
_output.WriteLine(JsonConvert.SerializeObject(split));
//Assert
split.Count().Should().Be(results.Length);
split.Should().Equal(results);
}
public static void TestCommandLineParser(ICommandLineParser parser, CommandLineSplitter splitter, string line, CommandLineItem[] expectedItems)
{
var _commandLine = splitter.ParseString(line);
var _actualItems = parser.ParseCommandLine(_commandLine);
for (var _i = 0; _i < expectedItems.Length && _i < _actualItems.Count; _i++)
{
Assert.Equal(expectedItems[_i].ToString(), _actualItems[_i].ToString(), StringComparer.Ordinal);
Assert.Equal(expectedItems[_i], _actualItems[_i]);
}
Assert.Equal(expectedItems.Length, _actualItems.Count);
Assert.True(expectedItems.SequenceEqual(_actualItems));
Assert.Equal(_commandLine.Value, splitter.ParseString(_commandLine.Value).Value);
}
public static void CommandLineIsSplittedLikeWin32Does(string line, CommandLineSplitter parser)
{
var _commandLine = parser.ParseString(line);
var _actualArgs = _commandLine.GetArgs();
var _expectedArgs = Win32CommandLineToArgvW.Split(line);
Assert.True(_commandLine.Equals(_expectedArgs));
Assert.False(_commandLine.Equals(_expectedArgs.Concat(new[] { string.Empty }).ToArray()));
Assert.Equal(string.Join(Environment.NewLine, _expectedArgs), string.Join(Environment.NewLine, _actualArgs));
Assert.Equal(_expectedArgs.Length, _commandLine.Parts.Count);
for (var _i = 0; _i < _expectedArgs.Length; _i++)
{
Assert.Equal(_i, _commandLine.Parts[_i].Index);
Assert.Equal(_expectedArgs[_i], _commandLine.Parts[_i].Value);
Assert.True(_commandLine.Parts[_i].Equals(_expectedArgs[_i]));
}
Assert.Equal(_commandLine.Value, parser.ParseString(_commandLine.Value).Value);
}
private string[]? GetInput(IConsole console, string executableName)
{
string[] arguments;
string? line = string.Empty; // Can be null when Ctrl+C is pressed to close the app.
do
{
// Print prompt
console.WithForegroundColor(_promptForeground, () =>
{
console.Output.Write(executableName);
});
if (!string.IsNullOrWhiteSpace(CliContext.Scope))
{
console.WithForegroundColor(ConsoleColor.Cyan, () =>
{
console.Output.Write(' ');
console.Output.Write(CliContext.Scope);
});
}
console.WithForegroundColor(_promptForeground, () =>
{
console.Output.Write("> ");
});
// Read user input
console.WithForegroundColor(_commandForeground, () =>
{
if (_autoCompleteInput is null)
{
line = console.Input.ReadLine();
}
else
{
line = _autoCompleteInput.ReadLine();
}
});
if (line is null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(CliContext.Scope)) // handle unscoped command input
{
arguments = CommandLineSplitter.Split(line)
.Where(x => !string.IsNullOrWhiteSpace(x))
.ToArray();
}
else // handle scoped command input
{
List <string> tmp = CommandLineSplitter.Split(line)
.Where(x => !string.IsNullOrWhiteSpace(x))
.ToList();
int lastDirective = tmp.FindLastIndex(x => x.StartsWith('[') && x.EndsWith(']'));
tmp.Insert(lastDirective + 1, CliContext.Scope);
arguments = tmp.ToArray();
}
} while (string.IsNullOrWhiteSpace(line)); // retry on empty line
console.ForegroundColor = ConsoleColor.Gray;
return(arguments);
}
public static bool ParseArgs(string argString)
{
return(ParseArgs(CommandLineSplitter.SplitArguments(argString)));
}
public static void RunCommand(string argString)
{
RunCommand(CommandLineSplitter.SplitArguments(argString));
}
