public Function()
{
if (Arguments.Count(arg => arg is UnlimitedStringArgument) + OptionalArguments.Count(arg => arg is UnlimitedStringArgument) > 1)
{
throw new FormatException($"The {FunctionType} {Name} has more than one unlimited argument! (limit: 1)");
}
}
public void OptionalArguments_2String_Test()
{
var test = new OptionalArguments();
var result = test.LetsUseOptionalArguments("Go", "Brewers");
Assert.AreEqual("Go Brewers", result);
}
public void OptionalArguments_4String_Test()
{
var test = new OptionalArguments();
var result = test.LetsUseOptionalArguments("Let's", "Go", "Brewers", "Not the Cubs");
Assert.AreEqual("Let's Go Brewers!!!", result);
}
public override string ToString()
{
var regularArguments = string.Join(" ", RegularArguments.Select(a => a.ToString())).Trim();
var optionalArguments = string.Join(" ", OptionalArguments.Select(a => a.ToString())).Trim();
var keywordArguments = string.Join(" ", KeywordArguments.Select(a => a.ToString())).Trim();
var auxiliaryArguments = string.Join(" ", AuxiliaryArguments.Select(a => a.ToString())).Trim();
var rest = RestArgument?.ToString();
return(string.Join(" ", new[] { regularArguments, optionalArguments, keywordArguments, auxiliaryArguments, rest }).Trim());
}
public HelpCommand()
{
OptionalArguments.Add(new OptionalCommandArgument()
{
Name = "all", IsFlag = true
});
OptionalArguments.Add(new OptionalCommandArgument()
{
Name = "cmd"
});
}
public override string ToString()
{
var sb = new StringBuilder(Name);
Arguments.ForEach(arg => sb.Append($" [{arg.Name}:{arg.ContentsAsString}]"));
foreach (var arg in OptionalArguments.Where(arg => arg.IsFilled))
{
sb.Append($" ({arg.Name}:{arg.ContentsAsString})");
}
return(sb.ToString());
}
protected override void ExecuteCommand()
{
if (OptionalArguments.First(p => p.Name == "all").IsUsed)
{
DefinedCommands.ForEach(p =>
{
p.Help();
});
}
else
{
var cmd = OptionalArguments.First(p => p.Name == "cmd");
if (cmd.IsUsed)
{
cmd.Value.ThrowExceptionIfNull($"[{nameof(HelpCommand)}]: {cmd.Name} value is not defined!");
var definedCommand = DefinedCommands.FirstOrDefault(p => string.Equals(p.Name, cmd.Value.ToString(), StringComparison.CurrentCultureIgnoreCase));
definedCommand?.Help();
}
}
}
/// <summary>
/// Add an argument with the specified properties to the argument parser.
/// </summary>
/// <param name="name">Name of the argument. If this name starts with the "-" prefix then it will be an optional argument, else it will be a positional argument.</param>
/// <param name="longName">Longer (not necessarily) name of an optional argument, an alias. It can be used for positional arguments, it would only change the key value in the namespace.</param>
/// <param name="action">Action of an optional argument.</param>
/// <param name="defaultValue">Default value of an optional argument if it is not supplied. Default value is `null` by default.</param>
/// <param name="choices">A list of strings indicating the only selectable options for an argument. An error will be thrown if the provided values is not in the list of choices.</param>
/// <param name="required">Determines is an optional argument is required to be supplied. Can be used for positional arguments too but it won't effect anything.</param>
/// <param name="help">Help string to be printed in the help message for the argument. It is empty by default.</param>
/// <param name="constant">Constant value for the argument. This parameter only works for arguments with `StoreConst` and `AppendConst` actions.</param>
public void AddArgument(string name,
string longName = null,
ArgumentAction action = ArgumentAction.Store,
object defaultValue = null,
List <string> choices = null,
bool required = false,
string help = "",
object constant = null)
{
if (name.Contains(" "))
{
throw new InvalidArgumentNameException("An argument name can't contain spaces.");
}
Argument arg = new Argument(name,
longName: longName,
action: action,
defaultValue: defaultValue,
choices: choices,
required: required,
help: help,
constant: constant);
arguments.Add(arg);
if (arg.Name.IsOptionalArgument())
{
Categories[optionalArgsTitle].Add(arg);
OptionalArguments.Add(arg);
}
else
{
Categories[positionalArgsTitle].Add(arg);
PositionalArguments.Add(arg);
}
}
public virtual void ProcessArgs(string[] args)
{
if (args.Length < Arguments.Count)
{
throw new FormatException($"The {FunctionType} {Name} needs at least {Arguments.Count} arguments!");
}
if (Arguments.Any(arg => arg is UnlimitedStringArgument))
{
for (var i = args.Length - Arguments.Count; i > 0; i--)
{
try
{
var arguments = new List <Argument>();
arguments.AddRange(Arguments);
arguments.AddRange(OptionalArguments.GetRange(0, i));
ProcessUnlimited(args, arguments);
}
catch (Exception e) { continue; }
return;
}
ProcessUnlimited(args, Arguments);
}
else if (OptionalArguments.Any(arg => arg is UnlimitedStringArgument))
{
var optArgs = new string[args.Length - Arguments.Count];
for (var i = 0; i < args.Length; i++)
{
if (i < Arguments.Count)
{
Arguments[i].ProcessArgs(new [] { args[i] });
}
else
{
optArgs[i - Arguments.Count] = args[i];
}
}
var list = ArraysUtility.SubArray(OptionalArguments.ToArray(), 0, optArgs.Length).ToList();
//TRIES TO MAXIMIZE OPTIONAL ARGUMENTS ADDED
for (var i = list.Count; i > 0; i--)
{
try
{
ProcessUnlimited(optArgs, list);
}
catch (Exception e)
{
list.RemoveAt(list.Count - 1); //Remove Last Item
continue;
}
return;
}
}
else
{
if (args.Length > Arguments.Count + OptionalArguments.Count)
{
throw new FormatException($"The {FunctionType} {Name} can only take up to {Arguments.Count + OptionalArguments.Count} arguments!");
}
for (var i = 0; i < args.Length; i++)
{
if (i < Arguments.Count)
{
Arguments[i].ProcessArgs(new [] { args[i] });
}
else
{
OptionalArguments[i - Arguments.Count].ProcessArgs(new [] { args[i] });
}
}
}
}
//Clears data from arguments
public virtual void Clear()
{
Arguments.ForEach(arg => arg.Clear());
OptionalArguments.ForEach(arg => arg.Clear());
}