public void TestMatchArgValuesWithOptionalTokens()
{
ArgumentToken arg1 = new ArgumentToken <int> .Builder().Name("arg1").IsOptional(false).Parser(int.TryParse).Build();
ArgumentToken arg2 = new ArgumentToken <double> .Builder().Name("arg2").IsOptional(false).Parser(double.TryParse).Build();
var tokens = new ICommandToken[]
{
new VerbToken(new Name("verb0")),
new OptionWithArgumentToken.Builder().Name("-o2", "--option2").WithArgument(arg1).WithArgument(arg2).Build(),
};
var builder = new CommandUsage.Builder().Description("test usage");
foreach (var token in tokens)
{
builder.WithToken(token);
}
ICommandUsage usage = builder.Build();
TokenMatchCollection matchCollection = CommandParser.Match(usage.Tokens, "verb0 -o2 1 2.34");
int arg1Value;
bool arg1Exists = matchCollection.TryGetArgValue(arg1, out arg1Value);
double arg2Value;
bool arg2Exists = matchCollection.TryGetArgValue(arg2, out arg2Value);
Assert.True(arg1Exists);
Assert.True(arg2Exists);
Assert.Equal(1, arg1Value);
Assert.Equal(2.34, arg2Value);
}
public override void Execute(ICommandToken commandToken)
{
var token = commandToken as AddNodeCommandToken;
// TODO Test if the connection already exists
var pos = mApp.Graph.Nodes.Count == 0 ? new Point2(0, 0) : mApp.Graph.Nodes.Last().Position + new Point2(200, 0);
var inputs = ImmutableArray <NodeInput> .Empty;
var outputs = ImmutableArray <NodeOutput> .Empty;
var type = ComponentFinder.FindByName(token.Type);
foreach (var attr in ComponentFinder.GetInputAttributes(type))
{
inputs = inputs.Add(new NodeInput(attr.Name, null));
}
foreach (var attr in ComponentFinder.GetOutputAttributes(type))
{
outputs = outputs.Add(new NodeOutput(attr.Name, false));
}
var node = new Node(FindUniqueName(mApp.Graph, token.Type), token.Type, pos,
inputs, outputs);
mApp.SetGraph(mApp.Graph.AddNode(node));
}
[InlineData("-o2 1", false)] //partial match
public void TestTokenIsFullMatch(string input, bool expIsFullMatch)
{
ArgumentToken arg1 = new ArgumentToken <int> .Builder().Name("arg1").IsOptional(false).Parser(int.TryParse).Build();
ArgumentToken arg2 = new ArgumentToken <double> .Builder().Name("arg2").IsOptional(false).Parser(double.TryParse).Build();
var tokens = new ICommandToken[]
{
new OptionWithArgumentToken.Builder().Name("-o2", "--option2").WithArgument(arg1).WithArgument(arg2).Build()
};
var builder = new CommandUsage.Builder()
.Description("test usage");
foreach (var token in tokens)
{
builder.WithToken(token);
}
ICommandUsage usage = builder.Build();
TokenMatchCollection matchCollection = CommandParser.Match(usage.Tokens, input);
Assert.Same(usage.Tokens, matchCollection.MatchableTokens);
Assert.NotEmpty(matchCollection.Matches);
Assert.Equal(1, matchCollection.Matches.Count());
ParserTokenMatch match = matchCollection.Matches.First();
Assert.Equal(expIsFullMatch, match.IsFullMatch);
}
public override void Execute(ICommandToken commandToken)
{
var token = commandToken as AddConnectionCommandToken;
// TODO Test if the connection already exists
mApp.SetGraph(mApp.Graph.AddConnection(token.Connection));
}
public override void Execute(ICommandToken commandToken)
{
var token = commandToken as MoveNodeCommandToken;
// TODO Test if the connection already exists
mApp.SetGraph(mApp.Graph.ReplaceNode(token.Node, token.Node.Move(token.NewPosition)));
}
public object GetDefaultValue(ICommandToken token)
{
if (_defaultValues.ContainsKey(token))
{
return(_defaultValues[token]);
}
return(null);
}
public bool Change <T>(ICommandToken <T> token, ICommandTrigger <T> trigger)
{
var command = _commands[token].Command as ICommand <T>;
Remove(token);
Add(trigger, command, token);
return(true);
}
public string GetDescription(ICommandToken token)
{
if (_descriptions.ContainsKey(token))
{
return(_descriptions[token]);
}
return(String.Empty);
}
public override void Execute(ICommandToken commandToken)
{
var token = commandToken as ToggleNodeOutputIsStreamCommandToken;
// TODO Test if the connection already exists
var newNodeOutput = new NodeOutput(token.NodeOutput.Name, !token.NodeOutput.IsStream);
mApp.SetGraph(mApp.Graph.ReplaceNode(token.Node, token.Node.ReplaceOutput(token.NodeOutput, newNodeOutput)));
}
public override void Execute(ICommandToken commandToken)
{
var token = commandToken as EditNodeInputInitialDataToken;
// TODO Test if the connection already exists
var newNodeInput = new NodeInput(token.NodeInput.Name, token.NewInitialData);
mApp.SetGraph(mApp.Graph.ReplaceNode(token.Node, token.Node.ReplaceInput(token.NodeInput, newNodeInput)));
}
public Builder WithToken(ICommandToken token, string description = "", object defaultValue = null)
{
_tokens.Add(token);
_descriptions.Add(token, description);
if (defaultValue != null)
{
_defaultValues.Add(token, defaultValue);
}
return(this);
}
public ToolDemo(ICommandManager commandManager, IKeyboard keyboard, IConfig <Config> config)
{
CommandA = commandManager.Add(keyboard.OnDown(AK + A),
e => { Logger.LogInformation($"{nameof(ToolDemo)}: Caps+A triggered!!!!!!!"); });
CommandB = (Caps + B).OnDown(e => Logger.LogWarning("Caps+B pressed!!!"));
Logger.LogInformation(config.CurrentValue.Option1);
Logger.LogInformation(config.CurrentValue.Option2.ToString());
RegisterCommands();
}
private static string GetOptionalDisplayName(ICommandToken token)
{
if (token.IsOptional)
{
return($"[{token.DisplayName}]");
}
else
{
return(token.DisplayName);
}
}
public void TestAdjacentTokens(string input, int?prevIdx, int?currentIdx, int?nextIdx)
{
var tokens = new ICommandToken[]
{
new ArgumentToken <int> .Builder()
.Name("name")
.Parser(int.TryParse)
.IsOptional(false)
.Build(),
new VerbToken(new Name("verb1", "alt1")),
new VerbToken(new Name("verb2", "alt2")),
new VerbToken(new Name("verb3", "alt3"))
};
var builder = new CommandUsage.Builder()
.Description("test usage");
foreach (var token in tokens)
{
builder.WithToken(token);
}
ICommandUsage usage = builder.Build();
ICommandToken currentToken = CommandParser.GetCurrentToken(usage, input);
ICommandToken prevToken = CommandParser.GetPreviousToken(usage, input);
ICommandToken nextToken = CommandParser.GetNextToken(usage, input);
if (prevIdx.HasValue)
{
Assert.Same(tokens[prevIdx.Value], prevToken);
}
else
{
Assert.Null(prevToken);
}
if (currentIdx.HasValue)
{
Assert.Same(tokens[currentIdx.Value], currentToken);
}
else
{
Assert.Null(currentToken);
}
if (nextIdx.HasValue)
{
Assert.Same(tokens[nextIdx.Value], nextToken);
}
else
{
Assert.Null(nextToken);
}
}
public override void Execute(ICommandToken commandToken)
{
var token = commandToken as PlayCommandToken;
var scheduler = new Scheduler(mApp.Graph);
try {
scheduler.Run();
} catch (Exception ex) {
MessageBox.Show("Error: " + ex.Message, "Scheduler error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public override void Execute(ICommandToken commandToken)
{
var token = commandToken as UndoRedoCommandToken;
if (token.IsUndoNotRedo)
{
mApp.Undo();
}
else
{
mApp.Redo();
}
}
internal void Remove <T>(ICommandToken <T> token)
{
var command = _commands[token].Command as Command <T>;
var trigger = _commands[token].Trigger as ICommandTrigger <T>;
_commands.Remove(token);
Debug.Assert(command != null, nameof(command) + " != null");
Debug.Assert(trigger != null, nameof(trigger) + " != null");
trigger.CanExecute -= command.CanExecute;
command.CanExecute = null;
trigger.Execute -= command.Execute;
command.Execute = null;
trigger.OnRemove(command);
}
public void StartCommand(ICommandToken token)
{
//1. Realize the command
Func <CommandBase> factory;
if (!mTokenTypeToFactory.TryGetValue(token.GetType(), out factory))
{
// Command not registered
return;
}
//2. Run the command
var command = factory();
command.Execute(token);
}
[InlineData("verb0 verb4 -o1 -o2 1 2.34 -o3", 0, 4)] //All tokens present, wrong order
public void TestMatchWithOptionalTokensWithArgs(string input, params int[] expectedMatchingIndexes)
{
ArgumentToken arg1 = new ArgumentToken <int> .Builder().Name("arg1").IsOptional(false).Parser(int.TryParse).Build();
ArgumentToken arg2 = new ArgumentToken <double> .Builder().Name("arg2").IsOptional(false).Parser(double.TryParse).Build();
var tokens = new ICommandToken[]
{
new VerbToken(new Name("verb0")),
new StandAloneOptionToken(new Name("-o1", "--option1")),
new OptionWithArgumentToken.Builder().Name("-o2", "--option2").WithArgument(arg1).WithArgument(arg2).Build(),
new StandAloneOptionToken(new Name("-o3", "--option3")),
new VerbToken(new Name("verb4")),
};
var builder = new CommandUsage.Builder()
.Description("test usage");
foreach (var token in tokens)
{
builder.WithToken(token);
}
ICommandUsage usage = builder.Build();
TokenMatchCollection matchCollection = CommandParser.Match(usage.Tokens, input);
Assert.Same(usage.Tokens, matchCollection.MatchableTokens);
if (expectedMatchingIndexes.Length > 0)
{
Assert.NotEmpty(matchCollection.Matches);
Assert.Equal(expectedMatchingIndexes.Length, matchCollection.Matches.Count());
//Ensure all that are expected are there
foreach (var expectedMatchingIndex in expectedMatchingIndexes)
{
Assert.True(matchCollection.Matches.Any(x => x.TokenIdx == expectedMatchingIndex));
}
}
else
{
Assert.Empty(matchCollection.Matches);
}
}
public string Translate(ICommandToken commandToken)
{
switch (commandToken?.CommandTokenType)
{
case CommandTokenType.PlaceArmiesResponse:
return(TranslatePlaceArmiesResponse((PlaceArmiesResponseToken)commandToken));
case CommandTokenType.AttackResponse:
return(TranslateAttackResponse((AttackResponseToken)commandToken));
case CommandTokenType.PickStartingRegionsResponse:
return(TranslatePickStartingRegions((PickStartingRegionsResponseToken)commandToken));
case null:
return(null);
default:
throw new ArgumentOutOfRangeException(nameof(commandToken));
}
}
public TokenMatchResult(ICommandToken token, string matchedTokensText, string fullMatchText, MatchOutcome matchOutcome, int charsMatched, int tokensMatched)
{
if (matchedTokensText == null)
{
throw new ArgumentNullException(nameof(matchedTokensText));
}
if (fullMatchText == null)
{
throw new ArgumentNullException(nameof(fullMatchText));
}
if (charsMatched < 0 || charsMatched > matchedTokensText.Length)
{
throw new ArgumentOutOfRangeException($"{nameof(charsMatched)} should be <= {nameof(matchedTokensText)}.Length");
}
ArgumentValues = new ValueBag <ArgumentToken>();
Token = token;
MatchedTokensText = matchedTokensText;
FullMatchText = fullMatchText;
MatchOutcome = matchOutcome;
CharsMatched = charsMatched;
TokensMatched = tokensMatched;
}
[InlineData("1234 verb1 verb2 verb3 verb4", 3)] //Too many tokens
public void TestMatch(string input, int?expectedMatchIdx)
{
var tokens = new ICommandToken[]
{
new ArgumentToken <int> .Builder()
.Name("name")
.Parser(int.TryParse)
.IsOptional(false)
.Build(),
new VerbToken(new Name("verb1", "alt1")),
new VerbToken(new Name("verb2", "alt2")),
new VerbToken(new Name("verb3", "alt3"))
};
var builder = new CommandUsage.Builder()
.Description("test usage");
foreach (var token in tokens)
{
builder.WithToken(token);
}
ICommandUsage usage = builder.Build();
TokenMatchCollection matchCollection = CommandParser.Match(usage.Tokens, input);
Assert.Same(usage.Tokens, matchCollection.MatchableTokens);
if (expectedMatchIdx.HasValue)
{
Assert.NotEmpty(matchCollection.Matches);
Assert.Same(tokens[expectedMatchIdx.Value], matchCollection.Matches.Last(x => x.MatchOutcome == Enums.MatchOutcome.Full).Token);
Assert.Equal(expectedMatchIdx, matchCollection.Matches.Where(x => x.MatchOutcome == Enums.MatchOutcome.Full).Max(x => x.TokenIdx));
}
else
{
Assert.Empty(matchCollection.Matches);
}
}
public override void Execute(ICommandToken commandToken)
{
var token = commandToken as SaveCommandToken;
FbpWriter.Write(mApp.Graph, mApp.CurrentFbpFullFileName);
}
public ICommandToken Execute(ICommandToken commandToken)
{
// dynamically dispatch for the token
return(Execute((dynamic)commandToken));
}
public bool IsDisabled <T>(ICommandToken <T> token)
{
return(_commands[token].Command.Disabled);
}
public void DisableEnable <T>(ICommandToken <T> token, bool disable)
{
_commands[token].Command.Disabled = disable;
}
private ICommandToken <TArgs> Add <TArgs>(ICommandTrigger <TArgs> trigger, ICommand <TArgs> command, ICommandToken <TArgs> token = null)
{
trigger.CanExecute += command.CanExecute;
trigger.Execute += command.Execute;
trigger.OnAdd(command);
token ??= new CommandToken <TArgs>(this);
_commands.Add(token, new Entry(trigger, command));
return(token);
}
public virtual bool HasToken(ICommandToken token)
{
return(_matchCollection.Matches.Any(x => x.IsFullMatch && x.Token.Equals(token)));
}
public override void Execute(ICommandToken commandToken)
{
var token = commandToken as RemoveNodeCommandToken;
mApp.SetGraph(mApp.Graph.RemoveNode(token.Node));
}
public abstract void Execute(ICommandToken token);
