/// <summary> /// Called when command line is parsing. /// </summary> /// <param name="name">The name.</param> /// <param name="value">The value.</param> /// <param name="type">The type.</param> /// <returns><c>true</c> if arguments was handled, <c>false</c> otherwise.</returns> protected bool OnCommandLineParsing(string name, string value, CommandLineArgumentType type) { CommandLineParseEventArgs args = new CommandLineParseEventArgs(name, value, type); this.TryInvoke(new Action(() => { this.model.OnCommandLineParsing(args); })); return(args.Handled); }
public CommandLineParseEventArgs(string name, string value, CommandLineArgumentType type) { this.Name = name; this.Value = value; this.Type = type; this.Handled = false; }
public void CommandLineArgumentType_ToArgument_When_BlogUrl_Argument_ReturnsArgument_Test() { const string arg = "-blogurl"; //given CommandLineArgumentType type = CommandLineArgumentType.BlogUrl; //when string value = type.ToArgument(); //then value.Should().Be(arg); }
public void CommandLineArgumentType_ToArgument_When_OutputDir_Argument_ReturnsArgument_Test() { const string arg = "-outputdir"; //given CommandLineArgumentType type = CommandLineArgumentType.OutputDir; //when string value = type.ToArgument(); //then value.Should().Be(arg); }
public CommandLineArgument Parse(string[] args, CommandLineArgumentType type) { string arg = type.ToArgument(); int index = Array.IndexOf(args, arg); if (index == -1) { return(null); } if (index + 1 > args.Length - 1) { return(null); } return(new CommandLineArgument(type, args[index + 1])); }
public Argument(CommandLineArgumentAttribute attribute, FieldInfo field, ErrorReporter reporter) { this.longName = CommandLineArgumentParser.LongName(attribute, field); this.description = CommandLineArgumentParser.Description(attribute); this.explicitShortName = CommandLineArgumentParser.ExplicitShortName(attribute); this.shortName = CommandLineArgumentParser.ShortName(attribute, field); this.elementType = ElementType(field); this.flags = Flags(attribute, field); this.field = field; this.seenValue = false; this.reporter = reporter; this.isDefault = (attribute != null) && (attribute is DefaultCommandLineArgumentAttribute); if (this.IsCollection) { this.collectionValues = new ArrayList(); } Debug.Assert( !string.IsNullOrEmpty(this.longName), "The long name must be provided for the argument."); Debug.Assert( !this.IsCollection || this.AllowMultiple, "Collection arguments must have allow multiple"); Debug.Assert( !this.Unique || this.IsCollection, "Unique only applicable to collection arguments"); Debug.Assert( IsValidElementType(this.Type) || IsCollectionType(this.Type), "The argument type is not valid."); Debug.Assert( (this.IsCollection && IsValidElementType(this.elementType)) || (!this.IsCollection && this.elementType == null), "The argument type is not valid."); }
/// <summary> /// Fills in the switchArguments and nonSwitchArguments data structures /// </summary> /// <param name="switchArguments">switch arguments - i.e. ones that have a -, --, or / in front, and their corresponding values</param> /// <param name="nonSwitchArguments">all non switch arguments</param> internal void Parse(Dictionary <string, List <string> > switchArguments, List <string> nonSwitchArguments) { bool parsing = true; while (this.currentIndex < this.args.Length) { try { string arg = this.args[this.currentIndex]; string orginalArg = arg; CommandLineArgumentType argumentType = this.GetCommandLineArgumentType(ref arg); if (argumentType == CommandLineArgumentType.EndSwitchMarker) { parsing = false; this.currentIndex++; continue; } List <string> valueList = new List <string>(); string value = string.Empty; if (parsing && argumentType == CommandLineArgumentType.Switch) { string[] keyValue = this.SplitIntoKeyAndValue(arg); string key = keyValue[0]; if (key.StartsWith(this.context.Settings.NoPrefix)) { key = key.Replace(this.context.Settings.NoPrefix, string.Empty); value = false.ToString(CultureInfo.CurrentCulture); } ArgumentDescriptor ar = this.context.GetDescriptor(key); if (ar == null || ar.IsHidden) { ++this.currentIndex; throw new CommandLineException(key, keyValue.Length > 1 ? keyValue[1] : string.Empty, "Unknown command line switch: " + key); } // if target is a bool then: // 1. if argument begins 'no-' it is always false, and should have no value // 2. if argument does not begin 'no-', and has a value separated by a defined separator, it takes that value // 3. it is true if (ar.MemberType == typeof(bool)) { if (string.IsNullOrWhiteSpace(value)) { // I am unclear about localization of string representations of bool: see http://stackoverflow.com/a/20620119 value = keyValue.Length > 1 ? keyValue[1] : true.ToString(CultureInfo.CurrentCulture); } else if (keyValue.Length > 1) { // this is a no-... switch, not allowed to have a value throw new CommandLineException(orginalArg, keyValue[1], "Value not allowed on a 'no-...' bool switch"); } } else { if (keyValue.Length > 1) { value = keyValue[1]; } else if (this.currentIndex + 1 < this.args.Length) { string v = this.args[this.currentIndex + 1]; if (!this.LooksLikeASwitch(v)) { value = v; ++this.currentIndex; } } } while (true) { valueList.Add(value); if (!ar.IsList || (this.currentIndex + 1 >= this.args.Length) || this.LooksLikeASwitch(this.args[this.currentIndex + 1])) { break; } value = this.args[++this.currentIndex]; } switchArguments[key] = valueList; } else { nonSwitchArguments.Add(arg); } ++this.currentIndex; } catch (Exception ex) { this.context.Exceptions.Add(ex); } } }
/// <summary> /// Initializes a new instance of the <see cref="DefaultCommandLineArgumentAttribute"/> class. /// </summary> /// <param name="type"> Specifies the error checking to be done on the argument. </param> public DefaultCommandLineArgumentAttribute(CommandLineArgumentType type) : base(type) { }
public CommandLineArgument(CommandLineArgumentType type, string value) { Type = type; Value = value; }
/// <summary> /// Initializes a new instance of the <see cref="CommandLineArgumentAttribute"/> class. /// </summary> /// <param name="type"> Specifies the error checking to be done on the argument. </param> public CommandLineArgumentAttribute(CommandLineArgumentType type) { this.type = type; this.Description = null; }
/// <summary> /// Allows control of command line parsing. /// </summary> /// <param name="type"> Specifies the error checking to be done on the argument. </param> public CommandLineArgumentAttribute(CommandLineArgumentType type) { this.type = type; }
public static string ToArgument(this CommandLineArgumentType type) { string arg = $"-{type.ToString().ToLower()}"; return(arg); }
/// <summary> /// Indicates that this argument is the default argument. /// </summary> /// <param name="type"> Specifies the error checking to be done on the argument. </param> public DefaultCommandLineArgumentAttribute(CommandLineArgumentType type) : base(type) { }
/// <summary> /// Allows control of command line parsing. /// </summary> /// <param name="type"> Specifies the error checking to be done on the argument. </param> public CommandLineArgumentAttribute(CommandLineArgumentType type) { this.Type = type; }
public Argument(CommandLineArgumentAttribute attribute, FieldInfo field, ErrorReporter reporter) { this.longName = CommandLineArgumentParser.LongName(attribute, field); this.explicitShortName = CommandLineArgumentParser.ExplicitShortName(attribute); this.shortName = CommandLineArgumentParser.ShortName(attribute, field); this.elementType = ElementType(field); this.flags = Flags(attribute, field); this.field = field; this.seenValue = false; this.reporter = reporter; this.isDefault = attribute != null && attribute is DefaultCommandLineArgumentAttribute; this.description=attribute.Description; if (IsCollection) { this.collectionValues = new ArrayList(); } Debug.Assert(this.longName != null && this.longName.Length > 0); if (IsCollection && !AllowMultiple) ThrowError("Collection arguments must have allow multiple"); Debug.Assert(!Unique || IsCollection, "Unique only applicable to collection arguments"); Debug.Assert(IsValidElementType(Type) || IsCollectionType(Type)); Debug.Assert((IsCollection && IsValidElementType(elementType)) || (!IsCollection && elementType == null)); }
private void ParseCommandLine() { // Get array of arguments based on the system parsing algorithm. string[] args = this.Command.GetCommandLineArgs(); if (args != null) { for (int i = 0; i < args.Length; ++i) { //parseCommand if (args[i].StartsWith("-", StringComparison.InvariantCultureIgnoreCase) || args[i].StartsWith("/", StringComparison.InvariantCultureIgnoreCase)) { string[] param = args[i].Split(new char[] { '=' }, 2); string commandName = param[0].Remove(0, 1); string value = param.Length > 1 ? param[1].Trim() : string.Empty; this.OnCommandLineParsing(commandName, value, CommandLineArgumentType.Command); } else { string[] param = args[i].Split(new char[] { '=' }, 2); string parameter = param[0]; string value = param.Length > 1 ? param[1].Trim() : string.Empty; bool handled = false; bool secured = parameter.StartsWith("~", StringComparison.InvariantCultureIgnoreCase); CommandLineArgumentType type = CommandLineArgumentType.Parameter; if (secured) { type = CommandLineArgumentType.SecuredParameter; parameter = parameter.Remove(0, 1); } handled = this.OnCommandLineParsing(parameter, value, type); if (!handled) { if (secured) { if (this.Engine.SecureStringVariables.Contains(parameter)) { SecureString secString = new SecureString(); foreach (char c in value) { secString.AppendChar(c); } secString.MakeReadOnly(); this.Engine.SecureStringVariables[parameter] = secString; } } else { if (this.Engine.StringVariables.Contains(parameter)) { this.Engine.StringVariables[parameter] = value; } } } } } } }