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