An alternative to UBB.threads
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
FLocal/Patcher/ThirdParty/NConsoler.cs

972 lines
26 KiB

//
// NConsoler 0.9.3
// http://nconsoler.csharpus.com
//
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Diagnostics;
using System.Threading;
namespace NConsoler
{
/// <summary>
/// Entry point for NConsoler applications
/// </summary>
public sealed class Consolery
{
/// <summary>
/// Runs an appropriate Action method.
/// Uses the class this call lives in as target type and command line arguments from Environment
/// </summary>
public static int Run()
{
Type declaringType = new StackTrace().GetFrame(1).GetMethod().DeclaringType;
string[] args = new string[Environment.GetCommandLineArgs().Length - 1];
new List<string>(Environment.GetCommandLineArgs()).CopyTo(1, args, 0, Environment.GetCommandLineArgs().Length - 1);
return Run(declaringType, args);
}
/// <summary>
/// Runs an appropriate Action method
/// </summary>
/// <param name="targetType">Type where to search for Action methods</param>
/// <param name="args">Arguments that will be converted to Action method arguments</param>
public static int Run(Type targetType, string[] args)
{
return Run(targetType, args, new ConsoleMessenger());
}
/// <summary>
/// Runs an appropriate Action method
/// </summary>
/// <param name="targetType">Type where to search for Action methods</param>
/// <param name="args">Arguments that will be converted to Action method arguments</param>
/// <param name="messenger">Uses for writing messages instead of Console class methods</param>
public static int Run(Type targetType, string[] args, IMessenger messenger)
{
try
{
return new Consolery(targetType, args, messenger, false, null).RunAction();
}
catch (NConsolerException e)
{
messenger.Write(e.Message);
return 100;
}
}
/// <summary>
/// Runs an appropriate Action method
/// </summary>
/// <param name="targetObject">Object where to search for Action methods</param>
/// <param name="args">Arguments that will be converted to Action method arguments</param>
public static int RunInstance(object targetObject, string[] args)
{
return RunInstance(targetObject, args, new ConsoleMessenger());
}
/// <summary>
/// Runs an appropriate Action method
/// </summary>
/// <param name="targetObject">Object where to search for Action methods</param>
/// <param name="args">Arguments that will be converted to Action method arguments</param>
/// <param name="messenger">Uses for writing messages instead of Console class methods</param>
public static int RunInstance(object targetObject, string[] args, IMessenger messenger)
{
try
{
return new Consolery(targetObject.GetType(), args, messenger, true, targetObject).RunAction();
}
catch (NConsolerException e)
{
messenger.Write(e.Message);
return 100;
}
}
/// <summary>
/// Validates specified type and throws NConsolerException if an error
/// </summary>
/// <param name="targetType">Type where to search for Action methods</param>
public static void Validate(Type targetType)
{
new Consolery(targetType, new string[] {}, new ConsoleMessenger(), false, null).ValidateMetadata();
}
private readonly Type _targetType;
private readonly string[] _args;
private readonly List<MethodInfo> _actionMethods = new List<MethodInfo>();
private readonly IMessenger _messenger;
private readonly bool _isInstance;
private readonly object _targetObject;
private Consolery(Type targetType, string[] args, IMessenger messenger, bool isInstance, object targetObject)
{
#region Parameter Validation
if (targetType == null)
{
throw new ArgumentNullException("targetType");
}
if (args == null)
{
throw new ArgumentNullException("args");
}
if (messenger == null)
{
throw new ArgumentNullException("messenger");
}
if (isInstance && (targetObject == null))
{
throw new AbandonedMutexException("targetObject");
}
#endregion
_targetType = targetType;
_args = args;
_messenger = messenger;
_isInstance = isInstance;
_targetObject = targetObject;
BindingFlags flags;
if(_isInstance)
{
flags = BindingFlags.Instance;
} else
{
flags = BindingFlags.Static;
}
MethodInfo[] methods = _targetType.GetMethods(BindingFlags.Public | flags);
foreach (MethodInfo method in methods)
{
object[] attributes = method.GetCustomAttributes(false);
foreach (object attribute in attributes)
{
if (attribute is ActionAttribute)
{
_actionMethods.Add(method);
break;
}
}
}
}
static object ConvertValue(string value, Type argumentType)
{
if (argumentType == typeof(int))
{
try
{
return Convert.ToInt32(value);
}
catch (FormatException)
{
throw new NConsolerException("Could not convert \"{0}\" to integer", value);
}
catch (OverflowException)
{
throw new NConsolerException("Value \"{0}\" is too big or too small", value);
}
}
if (argumentType == typeof(string))
{
return value;
}
if (argumentType == typeof(bool))
{
try
{
return Convert.ToBoolean(value);
}
catch (FormatException)
{
throw new NConsolerException("Could not convert \"{0}\" to boolean", value);
}
}
if (argumentType == typeof(string[]))
{
return value.Split('+');
}
if (argumentType == typeof(int[]))
{
string[] values = value.Split('+');
int[] valuesArray = new int[values.Length];
for (int i = 0; i < values.Length; i++)
{
valuesArray[i] = (int)ConvertValue(values[i], typeof(int));
}
return valuesArray;
}
if (argumentType == typeof(DateTime))
{
return ConvertToDateTime(value);
}
throw new NConsolerException("Unknown type is used in your method {0}", argumentType.FullName);
}
private static DateTime ConvertToDateTime(string parameter)
{
string[] parts = parameter.Split('-');
if (parts.Length != 3)
{
throw new NConsolerException("Could not convert {0} to Date", parameter);
}
int day = (int)ConvertValue(parts[0], typeof(int));
int month = (int)ConvertValue(parts[1], typeof(int));
int year = (int)ConvertValue(parts[2], typeof(int));
try
{
return new DateTime(year, month, day);
}
catch (ArgumentException)
{
throw new NConsolerException("Could not convert {0} to Date", parameter);
}
}
private static bool CanBeConvertedToDate(string parameter)
{
try
{
ConvertToDateTime(parameter);
return true;
}
catch(NConsolerException)
{
return false;
}
}
private bool SingleActionWithOnlyOptionalParametersSpecified() {
if (IsMulticommand) return false;
MethodInfo method = _actionMethods[0];
return OnlyOptionalParametersSpecified(method);
}
private static bool OnlyOptionalParametersSpecified(MethodBase method)
{
foreach (ParameterInfo parameter in method.GetParameters())
{
if (IsRequired(parameter))
{
return false;
}
}
return true;
}
private int RunAction()
{
ValidateMetadata();
if (IsHelpRequested())
{
PrintUsage();
return 0;
}
MethodInfo currentMethod = GetCurrentMethod();
if (currentMethod == null)
{
PrintUsage();
throw new NConsolerException("Unknown subcommand \"{0}\"", _args[0]);
}
ValidateInput(currentMethod);
return InvokeMethod(currentMethod);
}
private struct ParameterData
{
public readonly int position;
public readonly Type type;
public ParameterData(int position, Type type)
{
this.position = position;
this.type = type;
}
}
private static bool IsRequired(ICustomAttributeProvider info)
{
object[] attributes = info.GetCustomAttributes(typeof(ParameterAttribute), false);
return attributes.Length == 0 || attributes[0].GetType() == typeof(RequiredAttribute);
}
private static bool IsOptional(ICustomAttributeProvider info)
{
return !IsRequired(info);
}
private static OptionalAttribute GetOptional(ICustomAttributeProvider info)
{
object[] attributes = info.GetCustomAttributes(typeof(OptionalAttribute), false);
return (OptionalAttribute)attributes[0];
}
private bool IsMulticommand
{
get
{
return _actionMethods.Count > 1;
}
}
private bool IsHelpRequested()
{
return (_args.Length == 0 && !SingleActionWithOnlyOptionalParametersSpecified())
|| (_args.Length > 0 && (_args[0] == "/?"
|| _args[0] == "/help"
|| _args[0] == "/h"
|| _args[0] == "help"));
}
private int InvokeMethod(MethodInfo method)
{
try
{
return (int)method.Invoke(_isInstance ? _targetObject : null, BuildParameterArray(method));
}
catch (TargetInvocationException e)
{
if (e.InnerException != null)
{
throw new NConsolerException(e.InnerException.Message, e);
}
throw;
}
}
private object[] BuildParameterArray(MethodInfo method)
{
int argumentIndex = IsMulticommand ? 1 : 0;
List<object> parameterValues = new List<object>();
Dictionary<string, ParameterData> aliases = new Dictionary<string, ParameterData>();
foreach (ParameterInfo info in method.GetParameters())
{
if (IsRequired(info))
{
parameterValues.Add(ConvertValue(_args[argumentIndex], info.ParameterType));
}
else
{
OptionalAttribute optional = GetOptional(info);
foreach (string altName in optional.AltNames)
{
aliases.Add(altName.ToLower(),
new ParameterData(parameterValues.Count, info.ParameterType));
}
aliases.Add(info.Name.ToLower(),
new ParameterData(parameterValues.Count, info.ParameterType));
parameterValues.Add(optional.Default);
}
argumentIndex++;
}
foreach (string optionalParameter in OptionalParameters(method))
{
string name = ParameterName(optionalParameter);
string value = ParameterValue(optionalParameter);
parameterValues[aliases[name].position] = ConvertValue(value, aliases[name].type);
}
return parameterValues.ToArray();
}
private IEnumerable<string> OptionalParameters(MethodInfo method)
{
int firstOptionalParameterIndex = RequiredParameterCount(method);
if (IsMulticommand)
{
firstOptionalParameterIndex++;
}
for (int i = firstOptionalParameterIndex; i < _args.Length; i++)
{
yield return _args[i];
}
}
private static int RequiredParameterCount(MethodInfo method)
{
int requiredParameterCount = 0;
foreach (ParameterInfo parameter in method.GetParameters())
{
if (IsRequired(parameter))
{
requiredParameterCount++;
}
}
return requiredParameterCount;
}
private MethodInfo GetCurrentMethod()
{
if (!IsMulticommand)
{
return _actionMethods[0];
}
return GetMethodByName(_args[0].ToLower());
}
private MethodInfo GetMethodByName(string name)
{
foreach (MethodInfo method in _actionMethods)
{
if (method.Name.ToLower() == name)
{
return method;
}
}
return null;
}
private void PrintUsage(MethodInfo method)
{
PrintMethodDescription(method);
Dictionary<string, string> parameters = GetParametersDescriptions(method);
PrintUsageExample(method, parameters);
PrintParametersDescriptions(parameters);
}
private void PrintUsageExample(MethodInfo method, IDictionary<string, string> parameterList)
{
string subcommand = IsMulticommand ? method.Name.ToLower() + " " : String.Empty;
string parameters = String.Join(" ", new List<string>(parameterList.Keys).ToArray());
_messenger.Write("usage: " + ProgramName() + " " + subcommand + parameters);
}
private void PrintMethodDescription(MethodInfo method)
{
string description = GetMethodDescription(method);
if (description == String.Empty) return;
_messenger.Write(description);
}
private static string GetMethodDescription(MethodInfo method)
{
object[] attributes = method.GetCustomAttributes(true);
foreach (object attribute in attributes)
{
if (attribute is ActionAttribute)
{
return ((ActionAttribute)attribute).Description;
}
}
throw new NConsolerException("Method is not marked with an Action attribute");
}
private static Dictionary<string, string> GetParametersDescriptions(MethodInfo method)
{
Dictionary<string, string> parameters = new Dictionary<string, string>();
foreach (ParameterInfo parameter in method.GetParameters())
{
object[] parameterAttributes =
parameter.GetCustomAttributes(typeof(ParameterAttribute), false);
if (parameterAttributes.Length > 0)
{
string name = GetDisplayName(parameter);
ParameterAttribute attribute = (ParameterAttribute)parameterAttributes[0];
parameters.Add(name, attribute.Description);
}
else
{
parameters.Add(parameter.Name, String.Empty);
}
}
return parameters;
}
private void PrintParametersDescriptions(IEnumerable<KeyValuePair<string, string>> parameters)
{
int maxParameterNameLength = MaxKeyLength(parameters);
foreach (KeyValuePair<string, string> pair in parameters)
{
if (pair.Value != String.Empty)
{
int difference = maxParameterNameLength - pair.Key.Length + 2;
_messenger.Write(" " + pair.Key + new String(' ', difference) + pair.Value);
}
}
}
private static int MaxKeyLength(IEnumerable<KeyValuePair<string, string>> parameters)
{
int maxLength = 0;
foreach (KeyValuePair<string, string> pair in parameters)
{
if (pair.Key.Length > maxLength)
{
maxLength = pair.Key.Length;
}
}
return maxLength;
}
private string ProgramName()
{
Assembly entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly == null)
{
return _targetType.Name.ToLower();
}
return new AssemblyName(entryAssembly.FullName).Name;
}
private void PrintUsage()
{
if (IsMulticommand && !IsSubcommandHelpRequested())
{
PrintGeneralMulticommandUsage();
}
else if (IsMulticommand && IsSubcommandHelpRequested())
{
PrintSubcommandUsage();
}
else
{
PrintUsage(_actionMethods[0]);
}
}
private void PrintSubcommandUsage()
{
MethodInfo method = GetMethodByName(_args[1].ToLower());
if (method == null)
{
PrintGeneralMulticommandUsage();
throw new NConsolerException("Unknown subcommand \"{0}\"", _args[0].ToLower());
}
PrintUsage(method);
}
private bool IsSubcommandHelpRequested()
{
return _args.Length > 0
&& _args[0].ToLower() == "help"
&& _args.Length == 2;
}
private void PrintGeneralMulticommandUsage()
{
_messenger.Write(
String.Format("usage: {0} <subcommand> [args]", ProgramName()));
_messenger.Write(
String.Format("Type '{0} help <subcommand>' for help on a specific subcommand.", ProgramName()));
_messenger.Write(String.Empty);
_messenger.Write("Available subcommands:");
foreach (MethodInfo method in _actionMethods)
{
_messenger.Write(method.Name.ToLower() + " " + GetMethodDescription(method));
}
}
private static string GetDisplayName(ParameterInfo parameter)
{
if (IsRequired(parameter))
{
return parameter.Name;
}
OptionalAttribute optional = GetOptional(parameter);
string parameterName =
(optional.AltNames.Length > 0) ? optional.AltNames[0] : parameter.Name;
if (parameter.ParameterType != typeof(bool))
{
parameterName += ":" + ValueDescription(parameter.ParameterType);
}
return "[/" + parameterName + "]";
}
private static string ValueDescription(Type type)
{
if (type == typeof(int))
{
return "number";
}
if (type == typeof(string))
{
return "value";
}
if (type == typeof(int[]))
{
return "number[+number]";
}
if (type == typeof(string[]))
{
return "value[+value]";
}
if (type == typeof(DateTime))
{
return "dd-mm-yyyy";
}
throw new ArgumentOutOfRangeException(String.Format("Type {0} is unknown", type.Name));
}
#region Validation
private void ValidateInput(MethodInfo method)
{
CheckAllRequiredParametersAreSet(method);
CheckOptionalParametersAreNotDuplicated(method);
CheckUnknownParametersAreNotPassed(method);
}
private void CheckAllRequiredParametersAreSet(MethodInfo method)
{
int minimumArgsLengh = RequiredParameterCount(method);
if (IsMulticommand)
{
minimumArgsLengh++;
}
if (_args.Length < minimumArgsLengh)
{
throw new NConsolerException("Not all required parameters are set");
}
}
private static string ParameterName(string parameter)
{
if (parameter.StartsWith("/-"))
{
return parameter.Substring(2).ToLower();
}
if (parameter.Contains(":"))
{
return parameter.Substring(1, parameter.IndexOf(":") - 1).ToLower();
}
return parameter.Substring(1).ToLower();
}
private static string ParameterValue(string parameter)
{
if (parameter.StartsWith("/-"))
{
return "false";
}
if (parameter.Contains(":"))
{
return parameter.Substring(parameter.IndexOf(":") + 1);
}
return "true";
}
private void CheckOptionalParametersAreNotDuplicated(MethodInfo method)
{
List<string> passedParameters = new List<string>();
foreach (string optionalParameter in OptionalParameters(method))
{
if (!optionalParameter.StartsWith("/"))
{
throw new NConsolerException("Unknown parameter {0}", optionalParameter);
}
string name = ParameterName(optionalParameter);
if (passedParameters.Contains(name))
{
throw new NConsolerException("Parameter with name {0} passed two times", name);
}
passedParameters.Add(name);
}
}
private void CheckUnknownParametersAreNotPassed(MethodInfo method)
{
List<string> parameterNames = new List<string>();
foreach (ParameterInfo parameter in method.GetParameters())
{
if (IsRequired(parameter))
{
continue;
}
parameterNames.Add(parameter.Name.ToLower());
OptionalAttribute optional = GetOptional(parameter);
foreach (string altName in optional.AltNames)
{
parameterNames.Add(altName.ToLower());
}
}
foreach (string optionalParameter in OptionalParameters(method))
{
string name = ParameterName(optionalParameter);
if (!parameterNames.Contains(name.ToLower()))
{
throw new NConsolerException("Unknown parameter name {0}", optionalParameter);
}
}
}
private void ValidateMetadata()
{
CheckAnyActionMethodExists();
IfActionMethodIsSingleCheckMethodHasParameters();
foreach (MethodInfo method in _actionMethods)
{
CheckActionMethodNamesAreNotReserved();
CheckRequiredAndOptionalAreNotAppliedAtTheSameTime(method);
CheckOptionalParametersAreAfterRequiredOnes(method);
CheckOptionalParametersDefaultValuesAreAssignableToRealParameterTypes(method);
CheckOptionalParametersAltNamesAreNotDuplicated(method);
}
}
private void CheckActionMethodNamesAreNotReserved()
{
foreach (MethodInfo method in _actionMethods)
{
if (method.Name.ToLower() == "help")
{
throw new NConsolerException("Method name \"{0}\" is reserved. Please, choose another name", method.Name);
}
}
}
private void CheckAnyActionMethodExists()
{
if (_actionMethods.Count == 0)
{
throw new NConsolerException("Can not find any public static method marked with [Action] attribute in type \"{0}\"", _targetType.Name);
}
}
private void IfActionMethodIsSingleCheckMethodHasParameters()
{
if (_actionMethods.Count == 1 && _actionMethods[0].GetParameters().Length == 0)
{
throw new NConsolerException("[Action] attribute applied once to the method \"{0}\" without parameters. In this case NConsoler should not be used", _actionMethods[0].Name);
}
}
private static void CheckRequiredAndOptionalAreNotAppliedAtTheSameTime(MethodBase method)
{
foreach (ParameterInfo parameter in method.GetParameters())
{
object[] attributes = parameter.GetCustomAttributes(typeof(ParameterAttribute), false);
if (attributes.Length > 1)
{
throw new NConsolerException("More than one attribute is applied to the parameter \"{0}\" in the method \"{1}\"", parameter.Name, method.Name);
}
}
}
private static bool CanBeNull(Type type)
{
return type == typeof(string)
|| type == typeof(string[])
|| type == typeof(int[]);
}
private static void CheckOptionalParametersDefaultValuesAreAssignableToRealParameterTypes(MethodBase method)
{
foreach (ParameterInfo parameter in method.GetParameters())
{
if (IsRequired(parameter))
{
continue;
}
OptionalAttribute optional = GetOptional(parameter);
if (optional.Default != null && optional.Default.GetType() == typeof(string) && CanBeConvertedToDate(optional.Default.ToString()))
{
return;
}
if ((optional.Default == null && !CanBeNull(parameter.ParameterType))
|| (optional.Default != null && !optional.Default.GetType().IsAssignableFrom(parameter.ParameterType)))
{
throw new NConsolerException("Default value for an optional parameter \"{0}\" in method \"{1}\" can not be assigned to the parameter", parameter.Name, method.Name);
}
}
}
private static void CheckOptionalParametersAreAfterRequiredOnes(MethodBase method)
{
bool optionalFound = false;
foreach (ParameterInfo parameter in method.GetParameters())
{
if (IsOptional(parameter))
{
optionalFound = true;
}
else if (optionalFound)
{
throw new NConsolerException("It is not allowed to write a parameter with a Required attribute after a parameter with an Optional one. See method \"{0}\" parameter \"{1}\"", method.Name, parameter.Name);
}
}
}
private static void CheckOptionalParametersAltNamesAreNotDuplicated(MethodBase method)
{
List<string> parameterNames = new List<string>();
foreach (ParameterInfo parameter in method.GetParameters())
{
if (IsRequired(parameter))
{
parameterNames.Add(parameter.Name.ToLower());
}
else
{
if (parameterNames.Contains(parameter.Name.ToLower()))
{
throw new NConsolerException("Found duplicated parameter name \"{0}\" in method \"{1}\". Please check alt names for optional parameters", parameter.Name, method.Name);
}
parameterNames.Add(parameter.Name.ToLower());
OptionalAttribute optional = GetOptional(parameter);
foreach (string altName in optional.AltNames)
{
if (parameterNames.Contains(altName.ToLower()))
{
throw new NConsolerException("Found duplicated parameter name \"{0}\" in method \"{1}\". Please check alt names for optional parameters", altName, method.Name);
}
parameterNames.Add(altName.ToLower());
}
}
}
}
#endregion
}
/// <summary>
/// Used for getting messages from NConsoler
/// </summary>
public interface IMessenger
{
void Write(string message);
}
/// <summary>
/// Uses Console class for message output
/// </summary>
public class ConsoleMessenger : IMessenger
{
public void Write(string message)
{
Console.WriteLine(message);
}
}
/// <summary>
/// Every action method should be marked with this attribute
/// </summary>
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public sealed class ActionAttribute : Attribute
{
public ActionAttribute()
{
}
public ActionAttribute(string description)
{
_description = description;
}
private string _description = String.Empty;
/// <summary>
/// Description is used for help messages
/// </summary>
public string Description
{
get
{
return _description;
}
set
{
_description = value;
}
}
}
/// <summary>
/// Should not be used directly
/// </summary>
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
public class ParameterAttribute : Attribute
{
private string _description = String.Empty;
/// <summary>
/// Description is used in help message
/// </summary>
public string Description
{
get
{
return _description;
}
set
{
_description = value;
}
}
protected ParameterAttribute()
{
}
}
/// <summary>
/// Marks an Action method parameter as optional
/// </summary>
public sealed class OptionalAttribute : ParameterAttribute
{
private string[] _altNames;
public string[] AltNames
{
get
{
return _altNames;
}
set
{
_altNames = value;
}
}
private readonly object _defaultValue;
public object Default
{
get
{
return _defaultValue;
}
}
/// <param name="defaultValue">Default value if client doesn't pass this value</param>
/// <param name="altNames">Aliases for parameter</param>
public OptionalAttribute(object defaultValue, params string[] altNames)
{
_defaultValue = defaultValue;
_altNames = altNames;
}
}
/// <summary>
/// Marks an Action method parameter as required
/// </summary>
public sealed class RequiredAttribute : ParameterAttribute
{
}
/// <summary>
/// Can be used for safe exception throwing - NConsoler will catch the exception
/// </summary>
public sealed class NConsolerException : Exception
{
public NConsolerException()
{
}
public NConsolerException(string message, Exception innerException)
: base(message, innerException)
{
}
public NConsolerException(string message, params string[] arguments)
: base(String.Format(message, arguments))
{
}
}
}