public Attributes(ArgumentAttribute input, TlcModule.RangeAttribute range, bool optional = false) { Contracts.AssertValue(input); Contracts.AssertValueOrNull(range); Input = input; Range = range; Optional = optional; }
public void Constructor_should_default_Position_to_max_int_value() { // act var attr = new ArgumentAttribute(null, null, null); // assert Assert.AreEqual(int.MaxValue, attr.Position); }
private void AddArgument(List <IArgument> args, ArgumentAttribute argAttrib, PropertyInfo pi, string parent) { args.Add( _argTypeMapper.Map( argAttrib, pi, _config.CliConfig, parent)); }
private static void SetDefaults(ArgumentAttribute attr) { // If appending and didn't explicitly set the constraint, // the sane default is to accept AtLeast N parameters. if (!attr.ExplicitlySetConstraint && (attr.Action == ParseAction.Append || attr.Action == ParseAction.AppendConst)) { attr.Constraint = NumArgsConstraint.AtLeast; } }
public void Match(string from, string toExcluding, string version, bool match) { var attribute = new ArgumentAttribute("hi") { From = from, ToExcluding = toExcluding }; var result = attribute.Match(Version.Parse(version)); Assert.Equal(match, result); }
private bool ReadArgument(PropertyInfo pi, Type type, out object value) { value = null; ArgumentAttribute aa = pi.GetCustomAttribute <ArgumentAttribute>( ); if (aa == null) { return(false); } IOption opt = null; if (!string.IsNullOrEmpty(aa.Of)) { opt = GetOptionForName(aa.Of); } string argName = pi.Name; if (opt != null) { argName = argName.Replace( _specDeriverConfig.PropertyNamingStyle.ToString(opt.Name), string.Empty); } IArgument arg = (opt?.Arguments ?? _spec.Arguments).FirstOrDefault(a => a.Name == argName) ?? (_spec.DynamicArgument != null && _spec.DynamicArgument.Name == argName ? _spec.DynamicArgument : _spec.Options.FirstOrDefault(o => o.DynamicArgument != null && o.DynamicArgument.Name == argName) ?.DynamicArgument); if (arg == null) { throw new Exception($"spec does not contain an {nameof( IArgument )} with name {argName}"); } if (arg.IsDynamicArgument) { value = GetValueForDynamicArgument(arg); } else if (type.IsNullableType( )) { value = GetValueForNullableArgument(arg, type); } else { value = GetValueForArgument(arg); } return(true); }
public ArgumentDescriptionRepository() { ClassEnumerator classEnumerator = new ClassEnumerator(typeof(ArgumentAttribute), typeof(IArgumentDescription), typeof(ArgumentAttribute).get_Assembly(), true, false, false); ListView <Type> .Enumerator enumerator = classEnumerator.results.GetEnumerator(); while (enumerator.MoveNext()) { Type current = enumerator.Current; ArgumentAttribute argumentAttribute = current.GetCustomAttributes(typeof(ArgumentAttribute), false)[0] as ArgumentAttribute; IArgumentDescription argumentDescription = Activator.CreateInstance(current) as IArgumentDescription; this.Descriptions.Add(argumentAttribute.order, argumentDescription); } }
public IArgument GetArgument(string propertyName) { PropertyInfo pi = _t.GetProperty(propertyName); if (pi == null) { throw new Exception($"{_t} has no property {propertyName}"); } ArgumentAttribute aa = pi.GetCustomAttribute <ArgumentAttribute>( ); FirstArgumentAttribute fa = pi.GetCustomAttribute <FirstArgumentAttribute>( ); OptionAttribute oa = pi.GetCustomAttribute <OptionAttribute>( ); string argName; if (aa != null) { argName = !string.IsNullOrEmpty(aa.Name) ? aa.Name : string.IsNullOrEmpty(aa.Of) ? propertyName : propertyName.Replace(aa.Of, string.Empty); } else if (fa != null) { argName = !string.IsNullOrEmpty(fa.Name) ? fa.Name : $"{propertyName}{CliSpecDeriver.ImplicitFirstArg}"; } else if (oa != null) { argName = $"{propertyName}{CliSpecDeriver.ImplicitFirstArg}"; } else { throw new Exception($"no argument mapped to property {propertyName}"); } IArgument arg = _spec.Arguments.Union( _spec.Options.SelectMany(o => o.Arguments)) .Union( _spec.Flags.SelectMany(f => f.Arguments)) .FirstOrDefault(a => a.Name == argName); if (arg == null) { throw new Exception($"no argument mapped to property {propertyName}"); } return(arg); }
public void ConstructorTest() { string name = "Some name"; ArgumentAttribute attribute = new ArgumentAttribute(name); Assert.AreEqual(name, attribute.Name); Assert.IsTrue(attribute.Optional); Assert.IsNull(attribute.DefaultValue); Assert.IsFalse(attribute.NeedEncode); attribute.Optional = false; Assert.IsFalse(attribute.Optional); attribute.NeedEncode = true; Assert.IsTrue(attribute.NeedEncode); }
public void Constructor_should_initialize_properties() { // arrange const string name = "name"; const string shortName = "short_name"; const string desc = "description"; // act var attr = new ArgumentAttribute(name, shortName, desc); // assert Assert.AreEqual(name, attr.Name); Assert.AreEqual(shortName, attr.ShortName); Assert.AreEqual(desc, attr.Description); }
private IArgument GetDynamicArgument(CliSpecification spec, Type t, string parent) { foreach (PropertyInfo pi in t.GetProperties( )) { ArgumentAttribute argAttrib = pi.GetCustomAttribute <ArgumentAttribute>( ); FirstArgumentAttribute firstArgAttrib = pi.GetCustomAttribute <FirstArgumentAttribute>( ); if (argAttrib == null && firstArgAttrib == null) { continue; } if (argAttrib != null && (string.Compare(parent, argAttrib.Of, StringComparison.InvariantCulture) != 0 || t.Name.Contains(parent))) { continue; } if (firstArgAttrib != null && string.Compare(parent, pi.Name, StringComparison.InvariantCulture) != 0) { continue; } if (!argAttrib?.Dynamic ?? !firstArgAttrib.Dynamic) { continue; } if (argAttrib != null) { return(_argTypeMapper.Map( argAttrib, pi, _config.CliConfig, parent)); } return(_argTypeMapper.Map( firstArgAttrib, $"{pi.Name}{ImplicitFirstArg}", pi.PropertyType, spec.Config)); } return(null); }
private static void CollectArguments(Type commandType, CommandDescriptor descriptor) { // Build up a list of arguments that will later be used for parsing PropertyInfo[] properties = commandType.GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (PropertyInfo propertyInfo in properties) { if (propertyInfo.IsDefined(typeof(ArgumentAttribute), true)) { ArgumentAttribute attribute = (ArgumentAttribute)Attribute.GetCustomAttribute( propertyInfo, typeof(ArgumentAttribute), true); ArgumentDescriptor argumentDescriptor = new ArgumentDescriptor(); argumentDescriptor.ArgumentType = propertyInfo.PropertyType; argumentDescriptor.PropertyInfo = propertyInfo; argumentDescriptor.Position = attribute.Position; // Add the specified short name if (!string.IsNullOrEmpty(attribute.ShortName)) { argumentDescriptor.ShortNames.Add(attribute.ShortName); } // Add the specified long name if (!string.IsNullOrEmpty(attribute.LongName)) { argumentDescriptor.LongNames.Add(attribute.LongName); } // If this isn't a positional argument, and a short or long name has not been set in the attribute, // then we'll automatically create a long name using the property name if (attribute.Position == -1 && string.IsNullOrEmpty(attribute.ShortName) && string.IsNullOrEmpty(attribute.LongName)) { argumentDescriptor.LongNames.Add(propertyInfo.Name.ToLower()); } descriptor.Arguments.Add(argumentDescriptor); } } }
private static IEnumerable <string> GetEnvironmentVariableAndDefaultValue(ArgumentAttribute attribute, Func <string, string> getEnvironmentVariable = null) { var results = new List <string>(); if (!string.IsNullOrWhiteSpace(attribute.EnvVar)) { var item = (getEnvironmentVariable ?? Environment.GetEnvironmentVariable)(attribute.EnvVar); if (item != null) { results.Add(item); } } if (!string.IsNullOrEmpty(attribute.Default)) { results.Add(attribute.Default); } return(results); }
private void AddArguments(CliSpecification spec, Type t) { foreach (PropertyInfo pi in t.GetProperties( )) { ArgumentAttribute argAttrib = pi.GetCustomAttribute <ArgumentAttribute>( ); if (argAttrib == null) { continue; } if (!string.IsNullOrEmpty(argAttrib.Of)) { continue; } IArgument arg; if (argAttrib.Dynamic) { spec.DynamicArgument = arg = _argTypeMapper.Map( argAttrib, pi, _config.CliConfig, string.Empty); } else { spec.AddArgument( arg = _argTypeMapper.Map( argAttrib, pi, _config.CliConfig, string.Empty)); } foreach (ArgumentConstraintAttribute ca in pi.GetCustomAttributes <ArgumentConstraintAttribute>( )) { ca.Handler.Handle(arg, ca); } } }
private Type GenerateManyToOneColumn(IndentingTextWriter writer, string className, Type columnType, System.Reflection.FieldInfo fieldInfo, ArgumentAttribute inputAttr, Type type, bool isArray) { var fieldName = CSharpGeneratorUtils.Capitalize(inputAttr.Name ?? fieldInfo.Name); var apiName = _generatedClasses.GetApiName(type, ""); writer.WriteLine($"public {className}()"); writer.WriteLine("{"); writer.WriteLine("}"); writer.WriteLine(""); writer.WriteLine($"public {className}(string output{fieldName}, params string[] input{fieldName}s)"); writer.WriteLine("{"); writer.Indent(); writer.WriteLine($"Add{fieldName}(output{fieldName}, input{fieldName}s);"); writer.Outdent(); writer.WriteLine("}"); writer.WriteLine(""); writer.WriteLine($"public void Add{fieldName}(string name, params string[] source)"); writer.WriteLine("{"); writer.Indent(); if (isArray) { writer.WriteLine($"var list = {fieldName} == null ? new List<{apiName}>() : new List<{apiName}>({fieldName});"); writer.WriteLine($"list.Add(ManyToOneColumn<{apiName}>.Create(name, source));"); writer.WriteLine($"{fieldName} = list.ToArray();"); } else { writer.WriteLine($"{fieldName} = ManyToOneColumn<{apiName}>.Create(name, source);"); } writer.Outdent(); writer.WriteLine("}"); writer.WriteLine(); Contracts.Assert(columnType == null); columnType = type; return(columnType); }
public void GetArgumentAttribute_With_InvalidEnum_Return_Null() { ArgumentAttribute argumentAttribute = ((MockEnum)(-1)).GetArgumentAttribute(); Assert.IsNull(argumentAttribute); }
void Bind(object commando, PropertyInfo property, List <CommandLineParameter> parameters, ArgumentAttribute attribute, BindingContext context) { if (attribute is PositionalArgumentAttribute) { BindPositional(commando, property, parameters, (PositionalArgumentAttribute)attribute, context); } else if (attribute is NamedArgumentAttribute) { BindNamed(commando, property, parameters, (NamedArgumentAttribute)attribute, context); } else { throw Ex("Don't know the attribute type {0}", attribute.GetType().Name); } }
public PropArg(PropertyInfo propInfo, ArgumentAttribute argAttribute) { Property = propInfo; Argument = argAttribute; }
private Type GenerateOneToOneColumn(IndentedTextWriter writer, string className, Type columnType, System.Reflection.FieldInfo fieldInfo, ArgumentAttribute inputAttr, Type type, bool isArray) { var fieldName = CSharpGeneratorUtils.Capitalize(inputAttr.Name ?? fieldInfo.Name); var generatedType = _generatedClasses.GetApiName(type, ""); writer.WriteLine($"public {className}()"); writer.WriteLine("{"); writer.WriteLine("}"); writer.WriteLine(""); writer.WriteLine($"public {className}(params string[] input{fieldName}s)"); writer.WriteLine("{"); writer.Indent(); writer.WriteLine($"if (input{fieldName}s != null)"); writer.WriteLine("{"); writer.Indent(); writer.WriteLine($"foreach (string input in input{fieldName}s)"); writer.WriteLine("{"); writer.Indent(); writer.WriteLine($"Add{fieldName}(input);"); writer.Outdent(); writer.WriteLine("}"); writer.Outdent(); writer.WriteLine("}"); writer.Outdent(); writer.WriteLine("}"); writer.WriteLine(""); writer.WriteLine($"public {className}(params (string inputColumn, string outputColumn)[] inputOutput{fieldName}s)"); writer.WriteLine("{"); writer.Indent(); writer.WriteLine($"if (inputOutput{fieldName}s != null)"); writer.WriteLine("{"); writer.Indent(); writer.WriteLine($"foreach (var inputOutput in inputOutput{fieldName}s)"); writer.WriteLine("{"); writer.Indent(); writer.WriteLine($"Add{fieldName}(inputOutput.outputColumn, inputOutput.inputColumn);"); writer.Outdent(); writer.WriteLine("}"); writer.Outdent(); writer.WriteLine("}"); writer.Outdent(); writer.WriteLine("}"); writer.WriteLine(""); writer.WriteLine($"public void Add{fieldName}(string inputColumn)"); writer.WriteLine("{"); writer.Indent(); if (isArray) { writer.WriteLine($"var list = {fieldName} == null ? new List<{generatedType}>() : new List<{generatedType}>({fieldName});"); writer.WriteLine($"list.Add(OneToOneColumn<{generatedType}>.Create(inputColumn));"); writer.WriteLine($"{fieldName} = list.ToArray();"); } else { writer.WriteLine($"{fieldName} = OneToOneColumn<{generatedType}>.Create(inputColumn);"); } writer.Outdent(); writer.WriteLine("}"); writer.WriteLineNoTabs(); writer.WriteLine($"public void Add{fieldName}(string outputColumn, string inputColumn)"); writer.WriteLine("{"); writer.Indent(); if (isArray) { writer.WriteLine($"var list = {fieldName} == null ? new List<{generatedType}>() : new List<{generatedType}>({fieldName});"); writer.WriteLine($"list.Add(OneToOneColumn<{generatedType}>.Create(outputColumn, inputColumn));"); writer.WriteLine($"{fieldName} = list.ToArray();"); } else { writer.WriteLine($"{fieldName} = OneToOneColumn<{generatedType}>.Create(outputColumn, inputColumn);"); } writer.Outdent(); writer.WriteLine("}"); writer.WriteLineNoTabs(); Contracts.Assert(columnType == null); columnType = type; return(columnType); }
public void GetArgumentAttribute_With_ValidArgument_Return_InstanceArgumentAttribute() { ArgumentAttribute argumentAttribute = MockEnum.Mock1.GetArgumentAttribute(); Assert.IsNotNull(argumentAttribute); }
protected override string GetAnnotatedDescription() { ArgumentAttribute descriptionAttribute = AttributeProvider.GetCustomAttribute <ArgumentAttribute>(); return(descriptionAttribute?.Description); }
private void AddArgument(PropertyInfo prop, ArgumentAttribute argumentAttr, ConventionContext convention, SortedList <int, CommandArgument> argOrder, Dictionary <int, PropertyInfo> argPropOrder) { var argument = argumentAttr.Configure(prop); foreach (var attr in prop.GetCustomAttributes().OfType <ValidationAttribute>()) { argument.Validators.Add(new AttributeValidator(attr)); } argument.MultipleValues = prop.PropertyType.IsArray || (typeof(IEnumerable).IsAssignableFrom(prop.PropertyType) && prop.PropertyType != typeof(string)); if (argPropOrder.TryGetValue(argumentAttr.Order, out var otherProp)) { throw new InvalidOperationException( Strings.DuplicateArgumentPosition(argumentAttr.Order, prop, otherProp)); } argPropOrder.Add(argumentAttr.Order, prop); argOrder.Add(argumentAttr.Order, argument); var setter = ReflectionHelper.GetPropertySetter(prop); if (argument.MultipleValues) { convention.Application.OnParsingComplete(r => { var collectionParser = CollectionParserProvider.Default.GetParser( prop.PropertyType, convention.Application.ValueParsers); if (collectionParser == null) { throw new InvalidOperationException(Strings.CannotDetermineParserType(prop)); } if (argument.Values.Count == 0) { return; } if (r.SelectedCommand is IModelAccessor cmd) { setter.Invoke(cmd.GetModel(), collectionParser.Parse(argument.Name, argument.Values)); } }); } else { convention.Application.OnParsingComplete(r => { var parser = convention.Application.ValueParsers.GetParser(prop.PropertyType); if (parser == null) { throw new InvalidOperationException(Strings.CannotDetermineParserType(prop)); } if (argument.Values.Count == 0) { return; } if (r.SelectedCommand is IModelAccessor cmd) { setter.Invoke( cmd.GetModel(), parser.Parse( argument.Name, argument.Value, convention.Application.ValueParsers.ParseCulture)); } }); } }
public void GetArgumentAttribute_With_EnumWIthoutAttribute_Return_Null() { ArgumentAttribute argumentAttribute = MockEnum.Mock4.GetArgumentAttribute(); Assert.IsNull(argumentAttribute); }