private ArgumentMap Map(object target, PropertyInfo property) { var attribute = ReflectionCompatibility.GetCustomAttribute <ArgumentAttribute>(property); string longName = null; char? shortName = null; string helpText = null; bool showHelpComplement = true; int? position = null; bool hasPosition = false; bool isOptional = true; bool hasDefaultValue = false; object defaultValue = null; if (attribute != null) { longName = attribute.LongName; shortName = attribute.ShortName; helpText = attribute.Help; showHelpComplement = attribute.ShowHelpComplement; hasPosition = attribute.HasPosition; position = (int?)attribute.Position; hasDefaultValue = attribute.HasDefaultValue; defaultValue = attribute.DefaultValue; isOptional = !attribute.IsRequired; } return(Map(target, property, property.Name, property.PropertyType, longName, shortName, hasPosition, position, helpText, showHelpComplement, isOptional, hasDefaultValue, defaultValue)); }
private ArgumentMap Map(object target, ParameterInfo parameter) { var attribute = ReflectionCompatibility.GetCustomAttribute <ArgumentAttribute>(parameter); string longName = null; char? shortName = null; string helpText = null; bool showHelpComplement = true; int? position = null; bool hasPosition = false; bool isOptional = parameter.IsOptional; bool hasDefaultValue = parameter.HasDefaultValue; object defaultValue = parameter.HasDefaultValue ? parameter.DefaultValue : null; if (attribute != null) { longName = attribute.LongName; shortName = attribute.ShortName; helpText = attribute.Help; showHelpComplement = attribute.ShowHelpComplement; hasPosition = attribute.HasPosition; position = (int?)attribute.Position; } return(this.Map(target, parameter, parameter.Name, parameter.ParameterType, longName, shortName, hasPosition, position, helpText, showHelpComplement, isOptional, hasDefaultValue, defaultValue)); }
/// <summary> /// Returns all commands except those in the ignore list. /// </summary> /// <returns></returns> public IEnumerable <Type> GetFromAppDomain() { var assemblies = ReflectionCompatibility.GetAssemblies().ToList(); var listOfCommands = (from domainAssembly in assemblies.Distinct() from assemblyType in domainAssembly.GetTypes() where typeof(Command).IsAssignableFrom(assemblyType) && assemblyType.IsInterface() == false && assemblyType.IsAbstract() == false select assemblyType).ToList(); listOfCommands.RemoveAll(f => this.IgnoredCommands.Contains(f)); return(listOfCommands); }
/// <summary> /// Create a map of arguments from the specific target object /// </summary> /// <param name="target">Object to be mapped</param> /// <param name="properties">Properties to be mapped</param> /// <param name="onlyWithAttribute">Ignore all properties that do not have the ArgumentAttribute</param> /// <returns>List of ArgumentMap</returns> public IEnumerable <ArgumentMap> Map(object target, PropertyInfo[] properties, bool onlyWithAttribute = false) { var maps = new List <ArgumentMap>(); foreach (PropertyInfo property in properties) { var attribute = ReflectionCompatibility.GetCustomAttribute <ArgumentAttribute>(property); if (onlyWithAttribute && attribute == null) { continue; } var map = Map(target, property); maps.Add(map); } Validate(maps, target.GetType().Name); return(SortByPosition(maps)); }
/// <summary> /// Create a map of actions from the specific target object /// </summary> /// <param name="target">Object to be mapped</param> /// <param name="methods">Methods to be mapped</param> /// <param name="onlyWithAttribute">Ignore all methods that do not have the ActionAttribute</param> /// <param name="usePrefixInAllMethods">Determine whether the methods are prefixed</param> /// <param name="prefix">Prefix text is enabled</param> /// <returns>List of ActionMap</returns> public IEnumerable <ActionMap> Map(object target, MethodInfo[] methods, bool onlyWithAttribute = false, bool usePrefixInAllMethods = false, string prefix = null) { var maps = new List <ActionMap>(); foreach (var method in methods) { var attribute = ReflectionCompatibility.GetCustomAttribute <ActionAttribute>(method); var isMainMethod = method.Name.ToLower() == Executor.MAIN_METHOD_NAME; var countParameters = method.GetParameters().Length; // the main method, with zero arguments, can't be a action if (isMainMethod && countParameters == 0 && attribute == null) { continue; } else if (isMainMethod && countParameters == 0 && attribute != null) { throw new Exception("The main method, with zero arguments, can be se a action. This method is reserved to be aways invoked in action. it is defined."); } var ignoredByWithoutAttr = onlyWithAttribute && attribute == null && !isMainMethod; var ignoredByMethod = attribute != null && attribute.Ignore; if (ignoredByWithoutAttr || ignoredByMethod) { continue; } string actionNameRaw; string actionName; if (attribute != null && !string.IsNullOrWhiteSpace(attribute.Name)) { actionNameRaw = attribute.Name; } else { actionNameRaw = argumentMapper.GetLongName(method.Name); } var usePrefix = attribute == null ? true : attribute.UsePrefix; var usePrefixFinal = usePrefixInAllMethods && usePrefix; if (usePrefixFinal) { if (string.IsNullOrWhiteSpace(prefix)) { prefix = argumentMapper.GetPrefixByType(target.GetType()); } actionName = prefix + "-" + actionNameRaw; } else { actionName = actionNameRaw; } var isDefaultAction = false; if (isMainMethod || (attribute != null && attribute.IsDefault)) { isDefaultAction = true; } var helpText = attribute == null ? null : attribute.Help; var enablePositionalArgs = attribute == null ? true : attribute.EnablePositionalArgs; var argsMaps = this.argumentMapper.GetFromMethod(target, method); maps.Add(new ActionMap(target, method, actionName, prefix, actionNameRaw, usePrefixFinal, helpText, isDefaultAction, enablePositionalArgs, argsMaps)); } return(maps); }