public void OverrideItem(DefinitionCacheItem item)
{
var wasOverridden = false;
// If a script is overriding/appending as alanguage script make it a language script
if (Type == DefinitionCacheItemType.Language || Type == DefinitionCacheItemType.LanguageScript)
{
if (item.Type == DefinitionCacheItemType.Script)
{
item.Type = DefinitionCacheItemType.LanguageScript;
}
}
for (int i = 0; i < _parameters.Count; i++)
{
if (_parameters[i].Name == item.Name)
{
item.Original = _parameters[i];
_parameters[i] = item;
wasOverridden = true;
break;
}
}
if (!wasOverridden)
{
Append(item);
}
}
private DefinitionJson get(DefinitionCacheItem parameter)
{
var json = getDefinition(parameter);
addChildren(json, parameter.Parameters);
return(json);
}
public DefinitionCacheItem GetOldestItem(string location)
{
DefinitionCacheItem oldest = null;
visitAll(
(item) => {
if (location != null && item.Location != location)
{
return;
}
if (oldest == null)
{
oldest = item;
}
else
{
if (oldest.Updated > item.Updated)
{
oldest = item;
}
}
},
_definitions);
return(oldest);
}
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);
}
private DefinitionJson getDefinition(DefinitionCacheItem parameter)
{
var json = new DefinitionJson();
if (parameter.Override)
{
json.Cmd = "[[" + parameter.Name + "]]";
}
else
{
if (parameter.Required)
{
json.Cmd = parameter.Name;
}
else
{
json.Cmd = "[" + parameter.Name + "]";
}
}
json.Type = parameter.Type.ToString().ToLower();
json.Location = parameter.Location;
json.Updated =
string.Format("{0}.{1}.{2} {3}:{4}:{5}",
parameter.Updated.Year,
parameter.Updated.Month.ToString().PadLeft(2, '0'),
parameter.Updated.Day.ToString().PadLeft(2, '0'),
parameter.Updated.Hour.ToString().PadLeft(2, '0'),
parameter.Updated.Minute.ToString().PadLeft(2, '0'),
parameter.Updated.Second.ToString().PadLeft(2, '0'));
json.Description = parameter.Description;
return(json);
}
private void add(DefinitionCache cache, DefinitionCacheItem item, IEnumerable <DefinitionCacheItem> parameters)
{
foreach (var parameter in parameters)
{
add(cache, item, parameter);
}
}
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 void add(DefinitionCache cache, DefinitionCacheItem item, IEnumerable <BaseCommandHandlerParameter> parameters)
{
foreach (var parameter in parameters)
{
if (parameter.Override)
{
overrideCommand(cache, item, parameter);
}
else
{
add(cache, item, parameter);
}
}
}
private void overrideItem(DefinitionCacheItem item)
{
if (item.Parameters.Length == 0)
{
return;
}
var existing = _definitions.FirstOrDefault(x => x.Name == item.Name);
if (existing == null)
{
return;
}
overrideItem(existing, item);
}
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());
_eventDispatcher(string.Format("builtin command ran \"{0}\" {1}", command.Command, new CommandStringParser().GetArgumentString(arguments)));
}
return true;
}
private void addItem(DefinitionCacheItem parent, JToken json)
{
var item =
parent
.Append(
getType(json["type"].ToString()),
json["location"].ToString(),
getTime(json["updated"].ToString()),
json["cmd"].ToString().StartsWith("[["),
!json["cmd"].ToString().StartsWith("["),
json["cmd"].ToString().Replace("[", "").Replace("]", ""),
json["description"].ToString());
foreach (var child in json["arguments"].Children())
addItem(item, child);
}
private DefinitionCacheItem add(DefinitionCacheItem item)
{
addRaw(item);
if (_definitions.Any(x => x.Name == item.Name))
{
if (item.Location == "placehoder-for-language-in-different-location")
{
var original = _definitions.FirstOrDefault(x => x.Name == item.Name && x.Type == DefinitionCacheItemType.Language);
overrideItem(item);
return(original);
}
_definitions.RemoveAll(x => x.Name == item.Name);
}
_definitions.Add(item);
return(item);
}
private void overrideCommand(DefinitionCache cache, DefinitionCacheItem item, BaseCommandHandlerParameter parameter)
{
var command = cache.Add(
item.Type,
item.Location,
item.Updated,
parameter.Override,
parameter.Required,
parameter.Name,
parameter.Description);
foreach (var cmd in parameter.Parameters)
{
add(cache, command, cmd);
}
}
private void addItem(DefinitionCacheItem parent, JToken json)
{
var item =
parent
.Append(
getType(json["type"].ToString()),
json["location"].ToString(),
getTime(json["updated"].ToString()),
json["cmd"].ToString().StartsWith("[["),
!json["cmd"].ToString().StartsWith("["),
json["cmd"].ToString().Replace("[", "").Replace("]", ""),
json["description"].ToString());
foreach (var child in json["arguments"].Children())
{
addItem(item, child);
}
}
private void add(DefinitionCache cache, DefinitionCacheItem item, BaseCommandHandlerParameter parameter)
{
var name = parameter.Name;
var child =
item.Append(
item.Type,
item.Location,
item.Updated,
parameter.Override,
parameter.Required,
name,
parameter.Description);
foreach (var cmd in parameter.Parameters)
{
add(cache, child, cmd);
}
}
private void addRaw(DefinitionCacheItem item)
{
if (item.Type == DefinitionCacheItemType.BuiltIn)
{
_builtIn.Add(item);
}
else if (item.Type == DefinitionCacheItemType.Language)
{
_languages.Add(item);
}
else if (item.Type == DefinitionCacheItemType.LanguageScript)
{
_languageScripts.Add(item);
}
else if (item.Type == DefinitionCacheItemType.Script)
{
_scripts.Add(item);
}
}
private DefinitionCacheItem add(DefinitionCacheItemType type, string location, DateTime updated, bool ovrride, bool required, string name, string description)
{
var item =
new DefinitionCacheItem(parameterAppender)
{
Type = type,
Location = location,
Updated = updated,
Override = ovrride,
Required = required,
Name = name,
Description = description
};
if (item.Override)
{
_definitions.Add(item);
return(item);
}
return(add(item));
}
private void overrideItem(DefinitionCacheItem existing, DefinitionCacheItem item)
{
if (item.Parameters.Length == 0)
{
return;
}
var childItem = item.Parameters[0];
if (!childItem.Override)
{
Logger.Write("Found and overrides command with " + item.Name);
existing.OverrideItem(childItem);
return;
}
var child = existing.Parameters.FirstOrDefault(x => x.Name == childItem.Name);
if (child == null)
{
return;
}
overrideItem(child, childItem);
}
private DefinitionJson getDefinition(DefinitionCacheItem parameter)
{
var json = new DefinitionJson();
if (parameter.Override) {
json.Cmd = "[[" + parameter.Name + "]]";
} else {
if (parameter.Required)
json.Cmd = parameter.Name;
else
json.Cmd = "[" + parameter.Name + "]";
}
json.Type = parameter.Type.ToString().ToLower();
json.Location = parameter.Location;
json.Updated =
string.Format("{0}.{1}.{2} {3}:{4}:{5}",
parameter.Updated.Year,
parameter.Updated.Month.ToString().PadLeft(2, '0'),
parameter.Updated.Day.ToString().PadLeft(2, '0'),
parameter.Updated.Hour.ToString().PadLeft(2, '0'),
parameter.Updated.Minute.ToString().PadLeft(2, '0'),
parameter.Updated.Second.ToString().PadLeft(2, '0'));
json.Description = parameter.Description;
return json;
}
private DefinitionCacheItem get(string[] args, int index, IEnumerable <DefinitionCacheItem> items, DefinitionCacheItem parent)
{
if (index > args.Length - 1)
{
return(parent);
}
if (items.Count() == 0)
{
return(parent);
}
var item = items.FirstOrDefault(x => x.Name == args[index]);
if (item == null)
{
if (isOptionalArgument(args[index], items))
{
return(parent);
}
if (items.Any(x => x.Name == x.Name.ToUpper()))
{
return(parent);
}
return(null);
}
if (args.Length == index + 1)
{
return(item);
}
return(get(args, index + 1, item.Parameters, item));
}
public void OverrideItem(DefinitionCacheItem item)
{
var wasOverridden = false;
// If a script is overriding/appending as alanguage script make it a language script
if (Type == DefinitionCacheItemType.Language || Type == DefinitionCacheItemType.LanguageScript) {
if (item.Type == DefinitionCacheItemType.Script)
item.Type = DefinitionCacheItemType.LanguageScript;
}
for (int i = 0; i < _parameters.Count; i++) {
if (_parameters[i].Name == item.Name) {
item.Original = _parameters[i];
_parameters[i] = item;
wasOverridden = true;
break;
}
}
if (!wasOverridden)
Append(item);
}
public DefinitionCacheItem Append(DefinitionCacheItem parameter)
{
return _parameterAppender(_parameters, parameter);
}
private bool overrideItem(DefinitionCacheItem existing, DefinitionCacheItem item)
{
if (!item.Override)
return true;
if (item.Parameters.Length == 0)
return false;
var childItem = item.Parameters[0];
var child = existing.Parameters.FirstOrDefault(x => x.Name == childItem.Name);
if (child == null)
return false;
if (overrideItem(child, childItem))
existing.OverrideItem(childItem);
return false;
}
private DefinitionCacheItem get(string[] args, int index, IEnumerable<DefinitionCacheItem> items, DefinitionCacheItem parent)
{
if (index > args.Length - 1)
return parent;
if (items.Count() == 0)
return parent;
var item = items.FirstOrDefault(x => x.Name == args[index]);
if (item == null) {
if (isOptionalArgument(args[index], items)) {
return parent;
}
if (items.Any(x => x.Name == x.Name.ToUpper()))
return parent;
return null;
}
if (args.Length == index + 1)
return item;
return get(args, index + 1, item.Parameters, item);
}
private DefinitionCacheItem add(DefinitionCacheItem item)
{
addRaw(item);
if (_definitions.Any(x => x.Name == item.Name))
_definitions.RemoveAll(x => x.Name == item.Name);
_definitions.Add(item);
return item;
}
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;
}
private DefinitionJson get(DefinitionCacheItem parameter)
{
var json = getDefinition(parameter);
addChildren(json, parameter.Parameters);
return json;
}
private void add(DefinitionCache cache, DefinitionCacheItem item, IEnumerable<BaseCommandHandlerParameter> parameters)
{
foreach (var parameter in parameters) {
if (parameter.Override)
overrideCommand(cache, item, parameter);
else
add(cache, item, parameter);
}
}
private void add(DefinitionCache cache, DefinitionCacheItem item, BaseCommandHandlerParameter parameter)
{
var name = parameter.Name;
var child =
item.Append(
item.Type,
item.Location,
item.Updated,
parameter.Override,
parameter.Required,
name,
parameter.Description);
foreach (var cmd in parameter.Parameters)
add(cache, child, cmd);
}
private void overrideCommand(DefinitionCache cache, DefinitionCacheItem item, BaseCommandHandlerParameter parameter)
{
var command = cache.Add(
item.Type,
item.Location,
item.Updated,
parameter.Override,
parameter.Required,
parameter.Name,
parameter.Description);
foreach (var cmd in parameter.Parameters)
add(cache, command, cmd);
}
private DefinitionCacheItem add(DefinitionCacheItem item)
{
addRaw(item);
if (_definitions.Any(x => x.Name == item.Name)) {
if (item.Location == "placehoder-for-language-in-different-location") {
var original = _definitions.FirstOrDefault(x => x.Name == item.Name && x.Type == DefinitionCacheItemType.Language);
overrideItem(item);
return original;
}
_definitions.RemoveAll(x => x.Name == item.Name);
}
_definitions.Add(item);
return item;
}
public void Add(DefinitionCacheItem item)
{
_definitions.Add(item);
}
private DefinitionCacheItem parameterAppender(List <DefinitionCacheItem> parameters, DefinitionCacheItem parameterToAdd)
{
parameters.Add(parameterToAdd);
return(parameterToAdd);
}
private void add(DefinitionCache cache, DefinitionCacheItem item, IEnumerable<DefinitionCacheItem> parameters)
{
foreach (var parameter in parameters)
add(cache, item, parameter);
}
public DefinitionCacheItem Append(DefinitionCacheItem parameter)
{
return(_parameterAppender(_parameters, parameter));
}
private DefinitionCacheItem add(DefinitionCacheItemType type, string location, DateTime updated, bool ovrride, bool required, string name, string description)
{
var item =
new DefinitionCacheItem(parameterAppender) {
Type = type,
Location = location,
Updated = updated,
Override = ovrride,
Required = required,
Name = name,
Description = description
};
if (item.Override) {
_definitions.Add(item);
return item;
}
return add(item);
}
public void OverrideItem(DefinitionCacheItem item)
{
var wasOverridden = false;
for (int i = 0; i < _parameters.Count; i++) {
if (_parameters[i].Name == item.Name) {
item.Original = _parameters[i];
_parameters[i] = item;
wasOverridden = true;
break;
}
}
if (!wasOverridden)
Append(item);
}
private void addRaw(DefinitionCacheItem item)
{
if (item.Type == DefinitionCacheItemType.BuiltIn)
_builtIn.Add(item);
else if (item.Type == DefinitionCacheItemType.Language)
_languages.Add(item);
else if (item.Type == DefinitionCacheItemType.LanguageScript)
_languageScripts.Add(item);
else if (item.Type == DefinitionCacheItemType.Script)
_scripts.Add(item);
}
public static void PrintDefinition(DefinitionCacheItem item)
{
int level = 0;
PrintDefinition(item, ref level);
}
private void overrideItem(DefinitionCacheItem item)
{
if (item.Parameters.Length == 0)
return;
var existing = _definitions.FirstOrDefault(x => x.Name == item.Name);
if (existing == null)
return;
if (overrideItem(existing.Parameters[0], item.Parameters[0]))
existing.OverrideItem(item.Parameters[0]);
}
public void Add(DefinitionCacheItem item)
{
_definitions.Add(item);
}
private DefinitionCacheItem parameterAppender(List<DefinitionCacheItem> parameters, DefinitionCacheItem parameterToAdd)
{
parameters.Add(parameterToAdd);
return parameterToAdd;
}
public static void PrintSingleDefinition(DefinitionCacheItem item)
{
PrintSingleDefinition(item, 0);
}
public void OverrideItem(DefinitionCacheItem item)
{
for (int i = 0; i < _parameters.Count; i++) {
if (_parameters[i].Name == item.Name) {
item.Original = _parameters[i];
_parameters[i] = item;
return;
}
}
}
private void overrideItem(DefinitionCacheItem existing, DefinitionCacheItem item)
{
if (item.Parameters.Length == 0)
return;
var childItem = item.Parameters[0];
if (!childItem.Override) {
Logger.Write("Found and overrides command with "+item.Name);
existing.OverrideItem(childItem);
return;
}
var child = existing.Parameters.FirstOrDefault(x => x.Name == childItem.Name);
if (child == null)
return;
overrideItem(child, childItem);
}
