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