public override Task ExecuteAsync(CancellationToken cancellationToken)
{
//var parameter = context.Parameter as Parameter ?? throw DynamicException.Factory.CreateDynamicException($"{nameof(Parameter)}Null{nameof(Exception)}", $"Command parameter must not be null.", null);
var commandName = Command is null ? null : SoftKeySet.Create(Command);
if (Command.IsNullOrEmpty())
{
//RenderCommandList(parameter.Commands, parameter.Logger);
}
else
{
var command = _commandRegistrations.SingleOrDefault(c => c.CommandName == commandName);
if (command is null)
{
Logger.Error($"Command {commandName.QuoteWith("'")} not found.");
}
else
{
RenderParameterList(command);
}
}
return(Task.CompletedTask);
}
public static SoftKeySet CreateCommandName([NotNull] Type commadType)
{
if (commadType == null)
{
throw new ArgumentNullException(nameof(commadType));
}
if (!typeof(IConsoleCommand).IsAssignableFrom(commadType))
{
throw new ArgumentException(paramName: nameof(commadType), message: $"'{nameof(commadType)}' needs to be derived from '{nameof(ICommand)}'");
}
var names = GetCommandNames();
var category = commadType.GetCustomAttribute <CategoryAttribute>()?.Category;
if (category.IsNotNull())
{
names = names.Select(n => SoftString.Create($"{category}.{n}"));
}
return(SoftKeySet.Create(names));
IEnumerable <SoftString> GetCommandNames()
{
yield return(GetCommandDefaultName(commadType));
foreach (var name in commadType.GetCustomAttribute <AliasAttribute>() ?? Enumerable.Empty <SoftString>())
{
yield return(name);
}
}
}
public static SoftKeySet CommandName([NotNull] this ICommandLine arguments)
{
// Command-name is the first value.
var commandName = arguments[CommandArgument.CommandNameKey].First();
return(string.IsNullOrEmpty(commandName) ? null : SoftKeySet.Create(commandName));
}
public void Parse_CommandWithArguments_CommandWithArguments()
{
var arguments = Parser.Parse("foo qux -bar baz").ToList().First();
Assert.AreEqual(SoftKeySet.Create("foo"), arguments.CommandName());
//arguments.Verify().SequenceEqual(new[] {});
}
public static SoftString FirstLongest([NotNull] this SoftKeySet keys)
{
if (keys == null)
{
throw new ArgumentNullException(nameof(keys));
}
return(keys.OrderByDescending(key => key.Length).First());
}
public void Add([NotNull] SoftKeySet name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
_arguments.Add(name, new CommandArgument(name));
}
public void ToString_WithKey_Formatted()
{
var arguments = new CommandArgument(SoftKeySet.Create("foo"))
{
"bar",
"baz qux"
};
Assert.AreEqual("-foo:bar, \"baz qux\"", arguments.ToString());
}
public void CommandName_Contains_String()
{
var arguments = new CommandLine
{
{ SoftKeySet.Empty, "baz" },
{ SoftKeySet.Empty, "qux" },
{ SoftKeySet.Create("foo"), "bar" },
};
Assert.AreEqual(SoftKeySet.Create("baz"), arguments.CommandName());
}
public IConsoleCommand CreateCommand(SoftKeySet name, ICommandLine commandLine)
{
if (_commands.TryGetValue(name, out var command))
{
_logger.Debug(() => $"Created command {name.FirstLongest().ToString().QuoteWith("'")}.");
return(_mapper.Map(command, commandLine));
}
else
{
return
(_logger
.Error(() => $"Could not find command {name.First().ToString().QuoteWith("'")}.")
.Return(default(IConsoleCommand)));
}
}
public void ExecuteAsync_PositionalArgument_Mapped()
{
var assertExecuteMock = new Mock <Action <IConsoleCommand> >();
assertExecuteMock.Setup(assert => assert(It.IsAny <TestCommandWithPosition>())).Callback(new Action <IConsoleCommand>(cmd =>
{
var test = cmd as TestCommandWithPosition;
Assert.AreEqual("abc", test.PositionProperty);
}));
var commands = CommandRegistrationContainer.Empty.Register <TestCommandWithPosition>();
using (var local = InitializeCommander(commands, assertExecuteMock.Object))
{
var commandLineString = @"test abc";
var executedCommandNames = local.Executor.ExecuteAsync(commandLineString, CancellationToken.None).GetAwaiter().GetResult();
Assert.That.Collection().AreEqual(new[] { SoftKeySet.Create("test") }, executedCommandNames);
assertExecuteMock.Verify(assert => assert(It.IsAny <IConsoleCommand>()), Times.Once);
}
}
public IEnumerable <CommandLine> Parse(string commandLine)
{
if (commandLine.IsNullOrEmpty())
{
yield break;
}
var tokens = _tokenizer.Tokenize(commandLine);
var arguments = CommandLine.Empty;
var currentArgumentName = SoftKeySet.Empty;
foreach (var token in tokens)
{
switch (token)
{
case "|" when arguments.Any():
yield return(arguments);
arguments = new CommandLine();
break;
// ReSharper disable once PatternAlwaysOfType
case string value when Regex.IsMatch(value, ArgumentPrefix):
currentArgumentName = SoftKeySet.Create(Regex.Replace(token, ArgumentPrefix, string.Empty));
arguments.Add(currentArgumentName);
break;
default:
arguments.Add(currentArgumentName, token);
break;
}
}
if (arguments.Any())
{
yield return(arguments);
}
}
public static SoftKeySet CreatePropertyName([NotNull] PropertyInfo property)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
var names = GetParameterNames();
return(SoftKeySet.Create(names));
IEnumerable <SoftString> GetParameterNames()
{
// Always use the property name as default.
yield return(property.Name);
// Then get alias if any.
foreach (var alias in property.GetCustomAttribute <AliasAttribute>() ?? Enumerable.Empty <SoftString>())
{
yield return(alias);
}
}
}
public void Add([NotNull] SoftKeySet name, [NotNull] string value)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (_arguments.TryGetValue(name, out var argument))
{
argument.Add(value);
}
else
{
_arguments.Add(name, new CommandArgument(name)
{
value
});
}
}
public void ExecuteAsync_VariousArguments_Mapped()
{
var assertExecuteMock = new Mock <Action <IConsoleCommand> >();
assertExecuteMock.Setup(assert => assert(It.IsAny <TestCommandWithVariousTypes>())).Callback(new Action <IConsoleCommand>(cmd =>
{
var test = cmd as TestCommandWithVariousTypes;
Assert.AreEqual("abc", test.StringProperty);
Assert.AreEqual(123, test.Int32Property);
Assert.AreEqual(true, test.BooleanPropertey);
Assert.AreEqual(new DateTime(2017, 5, 1), test.DateTimeProperty);
CollectionAssert.AreEqual(new[] { 4, 5, 6 }, test.Int32ArrayProperty);
}));
var commands = CommandRegistrationContainer.Empty.Register <TestCommandWithVariousTypes>();
using (var local = InitializeCommander(commands, assertExecuteMock.Object))
{
var commandLineString = @"test -stringproperty abc -int32property 123 -datetimeproperty ""2017/5/1"" -booleanproperty false -int32arrayproperty 4 5 6 -justproperty noop";
var executedCommandNames = local.Executor.ExecuteAsync(commandLineString, CancellationToken.None).GetAwaiter().GetResult();
Assert.That.Collection().AreEqual(new[] { SoftKeySet.Create("test") }, executedCommandNames);
assertExecuteMock.Verify(assert => assert(It.IsAny <IConsoleCommand>()), Times.Once);
}
}
internal CommandArgument(SoftKeySet key) => Key = key;
public void Parse_SingleCommand_SingleCommand()
{
var arguments = Parser.Parse("foo").ToList().First();
Assert.AreEqual(SoftKeySet.Create("foo"), arguments.CommandName());
}
public bool Contains(SoftKeySet name) => _arguments.ContainsKey(name);
public IEnumerable <string> this[SoftKeySet name] => _arguments.TryGetValue(name, out var argument) ? argument : Enumerable.Empty <string>();
