public virtual void SetupCommand(IShellCommand cmd)
{
if (cmd != null)
{
commands[cmd.Name] = cmd;
}
}
private static void InvokeTestOptions(Shell shell, IShellCommand shellCommand, string[] args)
{
var prefixes = new[] { "--", "-", "/" };
var optionsArgs = args
.TakeWhile(x => prefixes.Any(p => x.StartsWith(p) && x.Length > p.Length))
.ToList();
var parser = new OptionSet();
var options = (dynamic)new ExpandoObject();
options.Verbosity = 0;
parser
.Add("c|config=", "Set config path", s => { if (!string.IsNullOrWhiteSpace(s)) options.ConfigPath = s; })
.Add("v|verbose", "increase verbosity level", s => { if (s != null) options.Verbosity++; });
var arguments = new List<string>(parser.Parse(optionsArgs));
arguments.AddRange(args.Skip(optionsArgs.Count));
options.Arguments = arguments;
Console.WriteLine("Options:");
Console.WriteLine(JsonConvert.SerializeObject(options, Formatting.Indented));
}
public virtual Shell AddCommand(IShellCommand command)
{
lock (_lock)
{
_container.AddCommand(command);
}
return(this);
}
public void AddCommand(IShellCommand command)
{
if (command == null) throw new ArgumentNullException(nameof(command));
TreeAdd(command);
_commandsDescriptions.Add(command.Pattern, command.Description);
}
public void AddCommand(IShellCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
TreeAdd(command);
_commandsDescriptions.Add(command.Pattern, command.Description);
}
public void RunShell()
{
_readline = new Readline.Readline(History)
{
CtrlCInterrupts = CtrlCInterrupts,
CtrlDIsEOF = CtrlDIsEOF,
CtrlZIsEOF = CtrlZIsEOF
};
_readline.WritePrompt += ReadlineOnWritePrompt;
_readline.Interrupt += (sender, args) => ShellInterrupt?.Invoke(this, EventArgs.Empty);
_readline.TabComplete += ReadlineOnTabComplete;
_readline.PrintAlternatives += (sender, args) => OnPrintAlternatives(args);
while (true)
{
var input = _readline.ReadLine();
if (string.IsNullOrWhiteSpace(input))
{
continue;
}
input = input.Trim();
var allTokens = ShellCommandTokenizer.Tokenize(input);
foreach (var cmdTokens in allTokens)
{
try
{
var tokenArr = cmdTokens.ToArray();
IShellCommand command = null;
lock (_lock)
{
command = _container.FindCommand(this, tokenArr);
}
BeforeCommandExecute?.Invoke(this, new CommandExecuteEventArgs(input, null, command));
ExecuteCommand(tokenArr);
AfterCommandExecute?.Invoke(this, new CommandExecuteEventArgs(input, CommandResult, command));
}
catch (ShellCommandNotFoundException)
{
OnShellCommandNotFound(input);
}
}
History.AddUnique(input);
}
}
private void TreeAdd(IShellCommand command)
{
var tokens = new Queue <string>(ShellCommandTokenizer.Tokenize(command.Pattern));
var treeLevel = _commandsTree;
while (tokens.Any())
{
var token = tokens.Dequeue();
object leaf;
treeLevel.TryGetValue(token, out leaf);
if (tokens.Count == 0)
{
if (leaf == null)
{
leaf = command;
treeLevel.Add(token, leaf);
}
if (leaf != command)
{
throw new NotSupportedException("Already have handler for command");
}
}
else
{
if (leaf == null)
{
leaf = new SortedDictionary <string, object>(StringComparer.OrdinalIgnoreCase);
treeLevel.Add(token, leaf);
}
treeLevel = leaf as SortedDictionary <string, object>;
if (treeLevel == null)
{
throw new InvalidOperationException("Tree leaf must be Dictionary");
}
}
}
}
private static void InvokeTestOptions(Shell shell, IShellCommand shellCommand, string[] args)
{
var prefixes = new[] { "--", "-", "/" };
var optionsArgs = args
.TakeWhile(x => prefixes.Any(p => x.StartsWith(p) && x.Length > p.Length))
.ToList();
var parser = new OptionSet();
var options = (dynamic) new ExpandoObject();
options.Verbosity = 0;
parser
.Add("c|config=", "Set config path", s => { if (!string.IsNullOrWhiteSpace(s))
{
options.ConfigPath = s;
}
})
.Add("v|verbose", "increase verbosity level", s => { if (s != null)
{
options.Verbosity++;
}
});
var arguments = new List <string>(parser.Parse(optionsArgs));
arguments.AddRange(args.Skip(optionsArgs.Count));
options.Arguments = arguments;
Console.WriteLine("Options:");
Console.WriteLine(JsonConvert.SerializeObject(options, Formatting.Indented));
}
private static object DetermineImageSourceForCommand(IShellCommand shellCommand, ImageStates imageState)
{
PlaceholderCommand command = shellCommand as PlaceholderCommand;
if (command != null)
{
return GetIconUriForMethod(command.ScreenMethodName, shellCommand, imageState);
}
if (shellCommand == null)
{
return null;
}
IScreenCommand executableObject = shellCommand.ExecutableObject as IScreenCommand;
if (executableObject != null)
{
return GetIconUriForMethod(executableObject.GetModel().Name, shellCommand, imageState);
}
if (shellCommand.Group == ShellCommandGroupNames.Customize)
{
return GetIconUriForMethod("CustomizeScreen", shellCommand, imageState);
}
if (shellCommand.Image == null)
{
return GetIconUriForMethod("Placeholder", shellCommand, imageState);
}
return shellCommand.Image;
}
public override void ExecuteCommand(IShellCommand command)
{
}
/// <summary>
/// Executes the command.
/// Searches the command with its command key on the internal command collection.
/// Cross checks the result command by verifying its argument count.
/// Then executes the command.
/// </summary>
/// <param name="commandKey">The command key</param>
/// <param name="parameters">The parameters</param>
/// <returns>Boolean indicating status of the execution</returns>
private static async Task <bool> Execute(string commandKey, string[] parameters)
{
IShellCommand command = await Init.GetCommandWithKeyAsync <IShellCommand>(commandKey).ConfigureAwait(false);
if (command == null)
{
ShellIO.Error("Command doesn't exist. use 'help' to check all available commands!");
return(false);
}
try {
if (!command.IsInitSuccess)
{
await command.InitAsync().ConfigureAwait(false);
}
if (!command.IsCurrentCommandContext(command.CommandKey, parameters.Length))
{
ShellIO.Error("Command doesn't match the syntax. Please retype.");
return(false);
}
if (!command.HasParameters && parameters.Length > 0)
{
ShellIO.Info($"'{command.CommandName}' doesn't require any arguments.");
string args = string.Empty;
for (int i = 0; i < parameters.Length; i++)
{
if (!string.IsNullOrEmpty(parameters[i]))
{
args += parameters[i] + ",";
}
}
ShellIO.Info($"Entered arguments '{args}' will be trimmed out.");
parameters = new string[0];
}
if (parameters.Length > command.MaxParameterCount)
{
ShellIO.Info($"'{command.CommandName}' only supports a maximum of '{command.MaxParameterCount}' arguments. You have entered '{parameters.Length}'");
string args = string.Empty;
for (int i = (parameters.Length - command.MaxParameterCount) - 1; i > parameters.Length - command.MaxParameterCount; i--)
{
parameters[i] = null;
}
ShellIO.Info($"'{parameters.Length - command.MaxParameterCount}' arguments will be trimmed out.");
return(false);
}
await Notifications.Notify(Notifications.NotificationType.NotifyShort).ConfigureAwait(false);
await command.ExecuteAsync(new Parameter(commandKey, parameters)).ConfigureAwait(false);
return(true);
}
finally {
command.Dispose();
}
}
private static void RegisterCommandBuilder(IShellCommand commandBuilder)
{
CommandBuilders.Add(commandBuilder.Key.ToUpper(), commandBuilder);
}
private void TreeAdd(IShellCommand command)
{
var tokens = new Queue<string>(ShellCommandTokenizer.Tokenize(command.Pattern));
var treeLevel = _commandsTree;
while (tokens.Any())
{
var token = tokens.Dequeue();
object leaf;
treeLevel.TryGetValue(token, out leaf);
if (tokens.Count == 0)
{
if (leaf == null)
{
leaf = command;
treeLevel.Add(token, leaf);
}
if (leaf != command)
{
throw new NotSupportedException("Already have handler for command");
}
}
else
{
if (leaf == null)
{
leaf = new SortedDictionary<string, object>(StringComparer.OrdinalIgnoreCase);
treeLevel.Add(token, leaf);
}
treeLevel = leaf as SortedDictionary<string, object>;
if (treeLevel == null)
{
throw new InvalidOperationException("Tree leaf must be Dictionary");
}
}
}
}
public async Task ExecuteAsync(Parameter parameter)
{
if (!IsInitSuccess)
{
return;
}
if (parameter.Parameters.Length > MaxParameterCount)
{
ShellIO.Error("Too many arguments.");
return;
}
await Sync.WaitAsync().ConfigureAwait(false);
try {
if (OnExecuteFunc != null)
{
if (OnExecuteFunc.Invoke(parameter))
{
return;
}
}
switch (parameter.ParameterCount)
{
case 0:
foreach (KeyValuePair <string, IShellCommand> cmd in Interpreter.Commands)
{
if (string.IsNullOrEmpty(cmd.Value.CommandKey) || string.IsNullOrEmpty(cmd.Value.CommandName))
{
continue;
}
cmd.Value.OnHelpExec(true);
}
return;
case 1 when !string.IsNullOrEmpty(parameter.Parameters[0]) && parameter.Parameters[0].Equals("all", StringComparison.OrdinalIgnoreCase):
PrintAll();
return;
case 1 when !string.IsNullOrEmpty(parameter.Parameters[0]):
IShellCommand shellCmd = await Interpreter.Init.GetCommandWithKeyAsync <IShellCommand>(parameter.Parameters[0]).ConfigureAwait(false);
if (shellCmd == null)
{
ShellIO.Error("Command doesn't exist. use ' help -all ' to check all available commands!");
return;
}
shellCmd.OnHelpExec(false);
return;
default:
ShellIO.Error("Command seems to be in incorrect syntax.");
return;
}
}
catch (Exception e) {
ShellIO.Exception(e);
return;
}
finally {
Sync.Release();
}
}
/// <summary> /// Executes a command on the context menu. /// </summary> /// <param name="command"></param> public abstract void ExecuteCommand(IShellCommand command);
private static object GetIconUriForMethod(string methodName, IShellCommand command, ImageStates imageState)
{
switch (methodName)
{
case "Save":
if (imageState == ImageStates.MouseOver)
{
return IconSaveLargeHover;
}
if (imageState == ImageStates.SmallMouseOver)
{
return IconSaveSmallHover;
}
if ((imageState != ImageStates.Small) && (imageState != ImageStates.SmallDisabled))
{
return IconSaveLarge;
}
return IconSaveSmall;
case "Refresh":
if (imageState == ImageStates.MouseOver)
{
return IconRefreshLargeHover;
}
if (imageState == ImageStates.SmallMouseOver)
{
return IconRefreshSmallHover;
}
if ((imageState != ImageStates.Small) && (imageState != ImageStates.SmallDisabled))
{
return IconRefreshLarge;
}
return IconRefreshSmall;
case "CustomizeScreen":
if (imageState == ImageStates.MouseOver)
{
return IconCustomizeLargeHover;
}
if (imageState == ImageStates.SmallMouseOver)
{
return IconCustomizeSmallHover;
}
if ((imageState != ImageStates.Small) && (imageState != ImageStates.SmallDisabled))
{
return IconCustomizeLarge;
}
return IconCustomizeSmall;
}
if (command.Image != null)
{
return command.Image;
}
if (imageState == ImageStates.MouseOver)
{
return IconPlaceholderLargeHover;
}
if (imageState == ImageStates.SmallMouseOver)
{
return IconPlaceholderSmallHover;
}
if ((imageState != ImageStates.Small) && (imageState != ImageStates.SmallDisabled))
{
return IconPlaceholderLarge;
}
return IconPlaceholderSmall;
}
public Shell AddCommand(IShellCommand command)
{
lock (_lock)
{
_container.AddCommand(command);
}
return this;
}
//SECTION 2 - Command Button Handling Code
private void GeneralCommandHandler(object sender, RoutedEventArgs e)
{
IShellCommand command = (IShellCommand)((Button)sender).DataContext;
command.ExecutableObject.ExecuteAsync();
}
/// <summary>
/// Adds a new command to the queue.
/// </summary>
/// <param name="command">The command to add to the execution queue.</param>
public void AddCommand(IShellCommand command)
{
CommandQueue.Enqueue(command);
}
/// <inheritdoc/>
public override void ExecuteCommand(IShellCommand command)
{
command.Execute(null);
ClearCommands();
}
public CommandExecuteEventArgs(string userInput, object result, IShellCommand cmd = null)
{
UserInput = userInput;
Result = result;
Command = cmd;
}
private void RegisterCommand(IShellCommand command)
{
shellCommands.Add(command.Key, command);
}
private static void Exit(Shell shell, IShellCommand shellCommand, string[] strings)
{
throw new ApplicationExitException();
}
private static void Exit(Shell shell, IShellCommand shellCommand, string[] strings)
{
throw new ApplicationExitException();
}
static void RegisterCommand(IShellCommand command)
{
Commands.Add(command.Key, command);
}
private static void RegsiterCommand(IShellCommand command)
{
ShellCommands.Add(command.Key, command);
}
