public void TestListCommands() { CRegistery.Clear(); CCommand a11 = new cmd_a11(); CCommand a12 = new cmd_a12(); CCommand b11 = new cmd_b11(); CCommand b12 = new cmd_b12(); CRegistery.Register(a11); CRegistery.Register(a12); CRegistery.Register(b11); CRegistery.Register(b12); IList <CCommand> commands = CRegistery.ListCommands(); AssertTypes(commands, typeof(cmd_a11), typeof(cmd_a12), typeof(cmd_b11), typeof(cmd_b12)); commands = CRegistery.ListCommands("a"); AssertTypes(commands, typeof(cmd_a11), typeof(cmd_a12)); commands = CRegistery.ListCommands("a1"); AssertTypes(commands, typeof(cmd_a11), typeof(cmd_a12)); commands = CRegistery.ListCommands("a11"); AssertTypes(commands, typeof(cmd_a11)); commands = CRegistery.ListCommands("a13"); AssertTypes(commands); }
bool Execute(string prefix = null) { IList <CAliasCommand> cmds = CRegistery.ListAliases(prefix); if (cmds.Count > 0) { if (shortList) { string[] names = Collection.Map(cmds, delegate(CAliasCommand cmd) { return(cmd.Name); }); Print(names); } else { foreach (CAliasCommand cmd in cmds) { PrintIndent("{0} {1}", cmd.Name, cmd.Alias); } } } return(true); }
public void TestListVars() { CRegistery.Clear(); CVar a11 = new CVar("a11", "value"); CVar a12 = new CVar("a12", "value"); CVar b11 = new CVar("b11", "value"); CVar b12 = new CVar("b12", "value"); IList <CVar> vars = CRegistery.ListVars(); AssertList(vars, a11, a12, b11, b12); vars = CRegistery.ListVars("a"); AssertList(vars, a11, a12); vars = CRegistery.ListVars("a1"); AssertList(vars, a11, a12); vars = CRegistery.ListVars("a11"); AssertList(vars, a11); vars = CRegistery.ListVars("a13"); AssertList(vars); }
public void TestListOperationCommands() { Execute("bind mouse0 +bool"); Assert.AreEqual(0, CRegistery.ListCommands("+bool").Count); Assert.AreEqual(0, CRegistery.ListCommands("-bool").Count); }
protected void RegisterCommands(params CCommand[] commands) { foreach (CCommand cmd in commands) { CRegistery.Register(cmd); } }
public void TestListSystemCommands() { Execute("bind mouse0 +bool"); Assert.AreEqual(1, CRegistery.ListCommands("+bool", CCommandListOptions.System).Count); Assert.AreEqual(1, CRegistery.ListCommands("-bool", CCommandListOptions.System).Count); }
public static IList <string> ListAliasesConfig() { return(Collection.Map(CRegistery.ListAliases(), delegate(CAliasCommand alias) { return ToString(alias); })); }
public void SetUp() { base.RunSetUp(); CRegistery.Register(new Cmd_playmode(delegate { AddResult("executed"); })); }
public static void ListAliasesConfig(IList <string> lines) { IList <CAliasCommand> aliases = CRegistery.ListAliases(); for (int i = 0; i < aliases.Count; ++i) { lines.Add(ToString(aliases[i])); } }
internal static void Break() { Debug.Break(); Lunar.RegisterCommand("continue", delegate() { CRegistery.Unregister("continue"); EditorApplication.ExecuteMenuItem("Edit/Pause"); }); }
void Execute(string name, string commands) { CRegistery.AddAlias(name, StringUtils.UnArg(commands)); PostNotification( CCommandNotifications.CAliasesChanged, CCommandNotifications.KeyName, name, CCommandNotifications.KeyManualMode, this.IsManualMode ); }
protected virtual void Clear(bool deleteConfigs = true) { CBindings.Clear(); CRegistery.Clear(); if (deleteConfigs) { CConfigHelper.DeleteConfigs(); } }
void Execute(string name) { if (CRegistery.RemoveAlias(name)) { PostNotification( CCommandNotifications.CAliasesChanged, CCommandNotifications.KeyName, name, CCommandNotifications.KeyManualMode, this.IsManualMode ); } }
public void TestUnregisterDelegateActionCommand() { Lunar.RegisterCommand("action", (string[] args) => { AddResult("action"); }); CRegistery.Unregister("action"); Execute("action", false); AssertResult("action: command not found"); // FIXME }
private string[] ListCommandNames(string prefix, CommandListOptions options) { IList <CCommand> commands = CRegistery.ListCommands(delegate(CCommand cmd) { return(!(cmd is CVarCommand) && CRegistery.ShouldListCommand(cmd, prefix, options)); }); return(Collection.Map(commands, delegate(CCommand cmd) { return C(cmd.Name, cmd.ColorCode); })); }
private static string[] getSuggestions(string commandLine, IList <string> tokens) { Iterator <string> iter = new Iterator <string>(tokens); CCommand cmd = CRegistery.FindCommand(iter.Next()); if (cmd == null) { return(EMPTY_SUGGESTIONS); // no command found } while (iter.HasNext()) { string token = iter.Next(); int iterPos = iter.Position; // store position to revert for the case if option skip fails // first try to parse options if (token.StartsWith("--")) // long option { string optionName = token.Substring(2); if (SkipOption(iter, cmd, optionName)) { continue; } iter.Position = iterPos; return(getSuggestedOptions(iter, cmd, optionName, "--")); } else if (token.StartsWith("-") && !StringUtils.IsNumeric(token)) // short option { string optionName = token.Substring(1); if (SkipOption(iter, cmd, optionName)) { continue; } iter.Position = iterPos; return(getSuggestedOptions(iter, cmd, optionName, "-")); } if (iter.HasNext()) { return(EMPTY_SUGGESTIONS); // TODO: add multiple args suggestion support } return(getSuggestedArgs(commandLine, cmd, token)); } return(getSuggestedArgs(commandLine, cmd, "")); }
internal static IList <string> AutoCompleteArgs(string token) { IList <CAliasCommand> aliases = CRegistery.ListAliases(); if (aliases != null && aliases.Count > 0) { return(Collection.Map(aliases, delegate(CAliasCommand alias) { return alias.Name; })); } return(null); }
internal static IList <string> AutoCompleteArgs(string prefix) { IList <CVar> vars = CRegistery.ListVars(prefix, CCommand.DefaultListOptions); if (vars.Count == 0) { return(null); } return(Collection.Map(vars, delegate(CVar cvar) { return StringUtils.C(cvar.Name, ColorCode.TableVar); })); }
public void TestRegisterMethodsCommands() { CRegistery.Clear(); Lunar.RegisterCommand("del1", Del1); Lunar.RegisterCommand("del2", Del2); Lunar.RegisterCommand("del3", Del3); IList <CCommand> cmds = CRegistery.ListCommands("del"); Assert.AreEqual(3, cmds.Count); Assert.AreEqual("del1", cmds[0].Name); Assert.AreEqual("del2", cmds[1].Name); Assert.AreEqual("del3", cmds[2].Name); }
void Execute(string prefix = null) { IList <CCommand> cmds = CRegistery.ListCommands(prefix); foreach (CCommand cmd in cmds) { CVarCommand cvarCmd = cmd as CVarCommand; if (cvarCmd != null) { cvarCmd.ParentCommand = this; cvarCmd.SetDefault(); cvarCmd.ParentCommand = null; } } }
protected override IList <string> AutoCompleteArgs(string commandLine, string prefix) { IList <CVar> vars = CRegistery.ListVars(delegate(CVarCommand cmd) { return(cmd.IsBool && CRegistery.ShouldListCommand(cmd, prefix, CCommand.DefaultListOptions)); }); if (vars.Count == 0) { return(null); } return(Collection.Map(vars, delegate(CVar cvar) { return StringUtils.C(cvar.Name, ColorCode.TableVar); })); }
bool Execute(string command) { CCommand cmd = CRegistery.FindCommand(command); if (cmd == null) { PrintError("{0}: command not found \"{1}\"", this.Name, command); return(false); } cmd.Delegate = this.Delegate; cmd.PrintUsage(true); cmd.Delegate = null; return(true); }
bool Execute(string name) { CVarCommand cmd = CRegistery.FindCvarCommand(name); if (cmd == null) { PrintError("Can't find cvar: '{0}'", name); return(false); } cmd.ParentCommand = this; cmd.SetDefault(); cmd.ParentCommand = null; return(true); }
bool Execute(string prefix = null) { CommandListOptions options = CCommand.DefaultListOptions; if (includeSystem) { options |= CommandListOptions.System; } // TODO: refactoring IList <CVar> vars = CRegistery.ListVars(prefix, options); if (vars.Count > 0) { if (shortList) { string[] names = Collection.Map(vars, delegate(CVar cvar) { return(StringUtils.C(cvar.Name, ColorCode.TableVar)); }); Print(names); } else { StringBuilder result = new StringBuilder(); for (int i = 0; i < vars.Count; ++i) { CVar cvar = vars[i]; result.AppendFormat(" {0} {1}", StringUtils.C(cvar.Name, ColorCode.TableVar), StringUtils.Arg(cvar.Value)); // TODO: better color highlight if (!cvar.IsDefault) { result.AppendFormat(" {0} {1}", StringUtils.C("default", ColorCode.TableVar), cvar.DefaultValue); } if (i < vars.Count - 1) { result.Append('\n'); } } Print(result.ToString()); } } return(true); }
void Execute(string prefix = null) { IList <CAliasCommand> aliases = CRegistery.ListAliases(prefix); if (aliases.Count > 0) { foreach (CAliasCommand alias in aliases) { CRegistery.RemoveAlias(alias.Name); } PostNotification( CCommandNotifications.CAliasesChanged, CCommandNotifications.KeyManualMode, this.IsManualMode ); } }
protected override IList <string> AutoCompleteArgs(string commandLine, string token) { IList <CCommand> commands = CRegistery.ListCommands(delegate(CCommand command) { return(!(command is CVarCommand) && !(command is CDelegateCommand) && !(command is CAliasCommand) && CRegistery.ShouldListCommand(command, token, CCommand.DefaultListOptions)); }); if (commands.Count == 0) { return(null); } return(Collection.Map(commands, delegate(CCommand cmd) { return StringUtils.C(cmd.Name, cmd.ColorCode); })); }
protected void RegisterCommand(Type type, bool hidden = true) { CCommand command = CClassUtils.CreateInstance <CCommand>(type); if (command == null) { throw new ArgumentException("Can't create class instance: " + type.FullName); } String commandName = type.Name; if (commandName.StartsWith("Cmd_")) { commandName = commandName.Substring("Cmd_".Length); } command.Name = commandName; command.IsHidden = hidden; CRuntimeResolver.ResolveOptions(command); CRegistery.Register(command); }
public void TestRegisterMethodsCommandsFromTheSameObject() { CRegistery.Clear(); Dummy dummy = new Dummy(); CommandAction <string[]> del1 = dummy.Execute; CommandAction <string[]> del2 = dummy.Execute2; Lunar.RegisterCommand("del1", del1); Lunar.RegisterCommand("del2", del2); IList <CCommand> cmds = CRegistery.ListCommands("del"); Assert.AreEqual(2, cmds.Count); Assert.AreEqual(del1, (cmds[0] as CDelegateCommand).ActionDelegate); Assert.AreEqual(del2, (cmds[1] as CDelegateCommand).ActionDelegate); CRegistery.UnregisterAll(dummy); cmds = CRegistery.ListCommands("del"); Assert.AreEqual(0, cmds.Count); }
bool Execute(string cvarName) { CVarCommand cmd = CRegistery.FindCvarCommand(cvarName); if (cmd == null) { PrintError("Can't find cvar '" + cvarName + "'"); return(false); } if (!cmd.IsInt) { PrintError("Can't toggle non-int value"); return(false); } cmd.ParentCommand = this; cmd.SetValue(cmd.BoolValue ? 0 : 1); cmd.ParentCommand = null; return(true); }
private static IList <string> ListCvars() { IList <CVar> cvars = CRegistery.ListVars(delegate(CVarCommand cmd) { return(!cmd.IsDefault && !cmd.HasFlag(CFlags.NoArchive)); }); IList <string> entries = new List <string>(cvars.Count); foreach (CVar cvar in cvars) { if (cvar.Value != null) { entries.Add(string.Format("{0} {1}", cvar.Name, StringUtils.Arg(cvar.Value))); } else { entries.Add("null " + cvar.Name); } } return(entries); }