public static SpecificationProperty WithSpecification(this SpecificationProperty specProp, Specification newSpecification) { if (specProp == null) { throw new ArgumentNullException("specProp"); } if (newSpecification == null) { throw new ArgumentNullException("newSpecification"); } return(SpecificationProperty.Create(newSpecification, specProp.Property, specProp.Value)); }
public static SpecificationProperty WithValue(this SpecificationProperty specProp, Maybe <object> newValue) { if (specProp == null) { throw new ArgumentNullException("specProp"); } if (newValue == null) { throw new ArgumentNullException("newValue"); } return(SpecificationProperty.Create(specProp.Specification, specProp.Property, newValue)); }
public static System.Type GetConversionType(this SpecificationProperty specProp) { if (specProp == null) { throw new ArgumentNullException("specProp"); } switch (specProp.Specification.ConversionType.ToDescriptor()) { case DescriptorType.Sequence: return(specProp.Property.PropertyType.GetGenericArguments() .SingleOrDefault() .ToMaybe() .FromJust( new InvalidOperationException("Sequence properties should be of type IEnumerable<T>."))); default: return(specProp.Property.PropertyType); } }
public static ParserResult <T> Build <T>( Func <T> factory, Func <IEnumerable <string>, IEnumerable <OptionSpecification>, StatePair <IEnumerable <Token> > > tokenizer, IEnumerable <string> arguments, StringComparer nameComparer, CultureInfo parsingCulture) { var instance = factory(); if (arguments.Any() && nameComparer.Equals("--help", arguments.First())) { return(ParserResult.Create( ParserResultType.Options, instance, new[] { new HelpRequestedError() })); } var specProps = instance.GetType().GetSpecifications(pi => SpecificationProperty.Create( Specification.FromProperty(pi), pi, Maybe.Nothing <object>())); var optionSpecs = (from pt in specProps select pt.Specification) .ThrowingValidate(SpecificationGuards.Lookup) .OfType <OptionSpecification>(); var tokenizerResult = tokenizer(arguments, optionSpecs); var tokens = tokenizerResult.Value; var partitions = TokenPartitioner.Partition( tokens, name => TypeLookup.GetDescriptorInfo(name, optionSpecs, nameComparer)); var optionSpecProps = OptionMapper.MapValues( (from pt in specProps where pt.Specification.IsOption() select pt), partitions.Item1, (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, parsingCulture), nameComparer); var valueSpecProps = ValueMapper.MapValues( (from pt in specProps where pt.Specification.IsValue() select pt), partitions.Item2, (vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, parsingCulture)); var missingValueErrors = from token in partitions.Item3 select new MissingValueOptionError( NameInfo.FromOptionSpecification(optionSpecs.Single(o => token.Text.MatchName(o.ShortName, o.LongName, nameComparer)))); var specPropsWithValue = optionSpecProps.Value.Concat(valueSpecProps.Value); instance = instance .SetProperties(specPropsWithValue, sp => sp.Value.IsJust(), sp => sp.Value.FromJust()) .SetProperties(specPropsWithValue, sp => sp.Value.IsNothing() && sp.Specification.DefaultValue.IsJust(), sp => sp.Specification.DefaultValue.FromJust()) .SetProperties(specPropsWithValue, sp => sp.Value.IsNothing() && sp.Specification.ConversionType.ToDescriptor() == DescriptorType.Sequence && sp.Specification.DefaultValue.MatchNothing(), sp => sp.Property.PropertyType.GetGenericArguments().Single().CreateEmptyArray()); var validationErrors = specPropsWithValue.Validate(SpecificationPropertyRules.Lookup) .OfType <Just <Error> >().Select(e => e.Value); return(ParserResult.Create( ParserResultType.Options, instance, tokenizerResult.Errors .Concat(missingValueErrors) .Concat(optionSpecProps.Errors) .Concat(valueSpecProps.Errors) .Concat(validationErrors))); }