public bool Run(DefinitionCacheItem cmd, IEnumerable <string> args)
{
var arguments = args.ToList();
Logger.Write("Removing the command name from parameters: " + arguments[0]);
arguments.RemoveAt(0);
if (cmd.Type == DefinitionCacheItemType.Script || cmd.Type == DefinitionCacheItemType.LanguageScript)
{
Logger.Write("Running command as script");
var script = new Script(Bootstrapper.Settings.RootPath, Environment.CurrentDirectory, cmd.Location);
var sb = new StringBuilder();
// On language commands remove the second argument too if
// it matches the command name (oi langcommand vs oi C# langcommand)
if (cmd.Type == DefinitionCacheItemType.LanguageScript &&
arguments.Count > 0 &&
Bootstrapper.Settings.EnabledLanguages.Contains(args.ElementAt(0)))
{
Logger.Write("Removing second parameter from language command as it's a language script prefixed by language: " + arguments[0]);
arguments.RemoveAt(0);
}
for (int i = 0; i < arguments.Count; i++)
{
sb.Append(" \"" + arguments[i] + "\"");
}
script.Run(
sb.ToString(),
(command) => {
Bootstrapper.DispatchAndCompleteMessage(
command,
() => {
Logger.Write("Writing end of command");
script.Write("end-of-command");
});
});
}
else if (cmd.Type == DefinitionCacheItemType.Language)
{
Logger.Write("Running command as language command");
var language = new LanguagePlugin(cmd.Location, Bootstrapper.DispatchMessage);
// If default language command add original parameter
if (args.ElementAt(0) != language.GetLanguage())
{
arguments.Insert(0, args.ElementAt(0));
}
language.Run(arguments.ToArray());
}
else
{
Logger.Write("Running command as built in command");
var command = Bootstrapper.GetDefaultHandlers()
.FirstOrDefault(x => x.Command == args.ElementAt(0));
if (command == null)
{
return(false);
}
command.Execute(arguments.ToArray());
}
return(true);
}
public static void PrintSingleDefinition(DefinitionCacheItem item, int level)
{
var name = item.Name;
if (!item.Required)
{
name = "[" + name + "]";
}
Console.WriteLine("{0}{1} - {2}", "".PadLeft(level, '\t'), name, item.Description);
}
public static void PrintDefinition(DefinitionCacheItem item, ref int level)
{
level++;
PrintSingleDefinition(item, level);
foreach (var child in item.Parameters)
{
PrintDefinition(child, ref level);
}
level--;
}
private IEnumerable <string> getPaths(DefinitionCacheItem x, string path)
{
if (x.Parameters.Count() == 0)
{
return new string[] { path }
}
;
var paths = new List <string>();
x.Parameters.ToList()
.ForEach(y => paths.AddRange(getPaths(y, path + "/" + y.Name)));
return(paths);
}
public static void PrintSingleDefinition(DefinitionCacheItem item)
{
PrintSingleDefinition(item, 0);
}
public static void PrintDefinition(DefinitionCacheItem item)
{
int level = 0;
PrintDefinition(item, ref level);
}
private void dispatchAndCompleteMessage(string command, Action onCommandCompleted)
{
Logger.Write("Dispatching " + command);
if (command.Length == 0)
{
Console.WriteLine();
}
else if (isError(command))
{
printError(command);
}
else if (isWarning(command))
{
printWarning(command);
}
else if (isColorized(command))
{
printColorized(command);
}
else if (isCommand(command) || isEvent(command))
{
lock (_commandProcessLock) {
_commandsInProcessing++;
}
ThreadPool.QueueUserWorkItem((m) => {
Logger.Write("Handling command in background thread");
if (isCommand(command))
{
Logger.Write("Handling as command");
var prefix = getCommandPrefix(command);
var parser = new CommandStringParser();
var args =
parser.Parse(
command.Substring(prefix.Length, command.Length - prefix.Length))
.ToArray();
if (args.Length == 0)
{
Logger.Write("No commands specified for " + command);
}
DefinitionCacheItem cmd = null;
if (prefix == "command|")
{
cmd = GetDefinitionBuilder().Get(args);
}
else if (prefix == "command-builtin|")
{
cmd = GetDefinitionBuilder().GetBuiltIn(args);
}
else if (prefix == "command-language|")
{
cmd = GetDefinitionBuilder().GetLanguage(args);
}
else if (prefix == "command-languagescript|")
{
cmd = GetDefinitionBuilder().GetLanguageScript(args);
}
else if (prefix == "command-script|")
{
cmd = GetDefinitionBuilder().GetScript(args);
}
else if (prefix == "command-original|")
{
cmd = GetDefinitionBuilder().GetOriginal(args);
}
if (cmd != null)
{
new CommandRunner(EventDispatcher)
.Run(cmd, args);
}
else
{
Logger.Write("Could not find handler for " + command);
}
onCommandCompleted();
}
else if (isEvent(command))
{
Logger.Write("Handling as event");
var prefix = "event|";
EventDispatcher()
.Forward(command.Substring(prefix.Length, command.Length - prefix.Length));
}
lock (_commandProcessLock) {
_commandsInProcessing--;
}
}, null);
}
else if (command.StartsWith("raw|"))
{
var msg = command.Substring(4, command.Length - 4);
Console.Write(msg);
}
else
{
Console.WriteLine(command);
}
}
