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);
}
