public void Find_registered_type_by_alias() { var SUT = new ParserRegistration(GetBaselineTestTypes(), GetHelpTextForTest); var result = SUT.GetTargetType("test03"); AssertTypeResult(typeof(ParserRegTest03), result); }
public void Find_registered_type_by_name_where_type_name_provided_does_not_match_the_case_of_the_registered_type_name() { var SUT = new ParserRegistration(GetBaselineTestTypes(), GetHelpTextForTest); var result = SUT.GetTargetType("parserregtest02"); AssertTypeResult(typeof(ParserRegTest02), result); }
public void Find_Registered_Type_By_Type_Name_Where_Type_Name_Is_Not_Registered() { var SUT = new ParserRegistration(GetBaselineTestTypes().Where(t => t.Name != "ParserRegTest01").ToArray(), GetHelpTextForTest); var result = SUT.GetTargetType("ParserRegTest01"); AssertTypeResult(null, result); }
public void Construct_with_types_that_have_conflicting_alias_names() { var types = GetBaselineTestTypes().ToList(); types.Add(typeof(ParserRegTest02_Dupe)); var SUT = new ParserRegistration(types.ToArray(), GetHelpTextForTest); var result = SUT.GetTargetType("test02"); Assert.IsNull(result); }
internal ParserRunner(Type type, ParserRegistration parserRegistration) { Debug.Assert(type != null); Type = type; m_registration = parserRegistration; Validate(type, m_registration); }
private void Init() { Debug.Assert(m_types.Any()); Register = new ParserRegistration(m_types, GetHelpString, ValuesFactory.GetValueForParameter); foreach (var type in m_types) { ParserRunner.Validate(type, Register); } }
internal ParserRunner(Type type, ParserRegistration parserRegistration, HelpGeneratorBase helpGenerator) { Debug.Assert(type != null); Type = type; m_registration = parserRegistration; Validate(type, m_registration); m_helpGenerator = helpGenerator; }
private static void ValidateSeparators(IEnumerable<Method> verbs, ParserRegistration registration) { // check non-arrays // var parameters = verbs.SelectMany(v => v.MethodInfo.GetParameters()).ToList(); var nonArrayWithSeparator = parameters.Where(p => !p.ParameterType.IsArray && p.HasAttribute<SeparatorAttribute>()); if (nonArrayWithSeparator.Any()) { throw new NonArrayParameterWithSeparatorException(nonArrayWithSeparator.First()); } // check invalid separators // var separators = parameters. Where(p => p.HasAttribute<SeparatorAttribute>()). Select(p => Pair.Create(p, p.GetAttribute<SeparatorAttribute>().Separator)); var invalidSeparator = separators. FirstOrDefault(pair => string.IsNullOrEmpty(pair.Second) || pair.Second.Contains(" ")); if (invalidSeparator != null) { throw new InvalidSeparatorException(invalidSeparator.First); } var invalidRegisteredHandlers = registration.RegisteredGlobalHandlers. FirstOrDefault(a => a.Value.Type.IsArray && (string.IsNullOrEmpty(a.Value.Separator) || a.Value.Separator.Contains(" "))); }
private static void ValidateDuplicateGlobals(Type type, ParserRegistration registration) { var definedGlobals = type. GetMethodsWith<GlobalAttribute>(). SelectMany(m => { var att = m.GetAttribute<GlobalAttribute>(); var name = att.Name ?? m.Name; return att.Aliases.CommaSplit().Union(new[] { name }).Select(s => s.ToLowerInvariant()); }). ToList(); var globals = registration.RegisteredGlobalHandlers.Keys.Select(k => k.ToLowerInvariant()).ToList(); globals.AddRange(definedGlobals); var counts = globals.Distinct().ToDictionary(g => g, g => globals.Count(name => name == g)); var duplicate = counts.Where(c => c.Value > 1); if (duplicate.Any()) { throw new DuplicateGlobalHandlerException(duplicate.First().Key); } }
internal static void Validate(Type type, ParserRegistration registration) { // no more than one default verb // var verbMethods = type.GetMethodsWith<VerbAttribute>(). Select(m => new Method(m)); var defaultVerbs = verbMethods.Where(m => m.IsDefault); if (defaultVerbs.Count() > 1) { throw new MoreThanOneDefaultVerbException(defaultVerbs.Select(m => m.MethodInfo.Name)); } // no more than one error handler // ValidateDefinedErrorHandlers(type); // validate empty handlers (and empty help handlers) // ValidateDefinedEmptyHandlers(type); // validate pre/post interceptors // ValidateDefinedPreInterceptors(type); ValidateDefinedPostInterceptors(type); // parameters can't have both Default and DefaultProvider // ValidateParameterDefaults(verbMethods); // [Separator] can be applied only to array parameters // ValidateSeparators(verbMethods, registration); // no duplicate globals // ValidateDuplicateGlobals(type, registration); }
private ParserRunner GetMultiTypesParser(string[] args, ParserRegistration registration) { Debug.Assert(args.Any()); var verb = args[0]; // if the first arg is not a verb - throw // if (verb.StartsWith(ParserRunner.ArgumentPrefixes)) { throw new MissingVerbException(); } if (!verb.Contains(s_delimiters)) { throw new MultiParserMissingClassNameException(); } var parts = verb.Split(s_delimiters, StringSplitOptions.RemoveEmptyEntries); if (parts.Length != 2) { throw new InvalidVerbException(); } var typeNameOrAlias = parts[0]; args[0] = args[0].Substring(typeNameOrAlias.Length + 1); var matchingType = registration.GetTargetType(typeNameOrAlias); if (matchingType == null) { throw new UnknownParserTypeException(typeNameOrAlias); } return new ParserRunner(matchingType, registration, HelpGenerator); }
public void Find_registered_type_by_type_name() { var SUT = new ParserRegistration(GetBaselineTestTypes(), GetHelpTextForTest); var result = SUT.GetTargetType("ParserRegTest02"); AssertTypeResult(typeof (ParserRegTest02), result); }
public void Find_registered_type_by_name_where_type_name_provided_does_not_match_the_case_of_the_registered_type_name() { var SUT = new ParserRegistration(GetBaselineTestTypes(), GetHelpTextForTest); var result = SUT.GetTargetType("parserregtest02"); AssertTypeResult(typeof (ParserRegTest02), result); }
private ParserRunner GetMultiTypesParser(string[] args, object obj, ParserRegistration registration) { Debug.Assert(args.Any()); var verb = args[0]; // if the first arg is not a verb - throw // if (verb.StartsWith(ParserRunner.ArgumentPrefixes)) { throw new MissingVerbException(); } if (!verb.Contains(s_delimiters)) { throw new MultiParserMissingClassNameException(); } var parts = verb.Split(s_delimiters, StringSplitOptions.RemoveEmptyEntries); if (parts.Length != 2) { throw new InvalidVerbException(); } var typeName = parts[0]; args[0] = args[0].Substring(typeName.Length + 1); var type = m_types.FirstOrDefault(t => t.Name.Equals(typeName, StringComparison.InvariantCultureIgnoreCase)); if (type == null) { throw new UnknownParserTypeException(typeName); } return new ParserRunner(type, registration, HelpGenerator); }
private ParserRunner GetSingleTypeParser(string[] args, object obj, ParserRegistration registration) { Debug.Assert(m_types.Length == 1); var type = m_types.First(); var verb = args[0]; var parser = new ParserRunner(type, registration, HelpGenerator); // if there is no verb - leave all the args as is // if (verb.StartsWith(ParserRunner.ArgumentPrefixes)) { return parser; } // if the verb contains a delimiter - remove the type name from the arg // if (verb.Contains(s_delimiters)) { var parts = verb.Split(s_delimiters, StringSplitOptions.RemoveEmptyEntries); if (parts.Length != 2) { throw new InvalidVerbException(); } Debug.Assert(parts.Length == 2); var typeName = parts[0]; if (!type.Name.Equals(typeName, StringComparison.InvariantCultureIgnoreCase)) { throw new UnknownParserTypeException(typeName); } args[0] = args[0].Substring(typeName.Length + 1); } return parser; }