internal static bool IsActionImplementation(PropertyInfo property)
{
return property.Name.EndsWith(Constants.ActionArgConventionSuffix) &&
property.HasAttr<ArgIgnoreAttribute>() == false &&
ArgAction.GetActionProperty(property.DeclaringType) != null;
}
internal static CommandLineAction Create(PropertyInfo actionProperty, List<string> knownAliases)
{
var ret = PropertyInitializer.CreateInstance<CommandLineAction>();
ret.ActionMethod = ArgAction.ResolveMethod(actionProperty.DeclaringType, actionProperty);
ret.Source = actionProperty;
ret.Arguments.AddRange(new CommandLineArgumentsDefinition(actionProperty.PropertyType).Arguments);
ret.IgnoreCase = true;
if (actionProperty.DeclaringType.HasAttr<ArgIgnoreCase>() && actionProperty.DeclaringType.Attr<ArgIgnoreCase>().IgnoreCase == false)
{
ret.IgnoreCase = false;
}
if (actionProperty.HasAttr<ArgIgnoreCase>() && actionProperty.Attr<ArgIgnoreCase>().IgnoreCase == false)
{
ret.IgnoreCase = false;
}
ret.Metadata.AddRange(actionProperty.Attrs<IArgMetadata>().AssertAreAllInstanceOf<ICommandLineActionMetadata>());
// This line only calls into CommandLineArgument because the code to strip 'Args' off the end of the
// action property name lives here. This is a pre 2.0 hack that's only left in place to support apps that
// use the 'Args' suffix pattern.
ret.Aliases.AddRange(CommandLineArgument.FindDefaultShortcuts(actionProperty, knownAliases, ret.IgnoreCase));
return ret;
}
internal static CommandLineArgument Create(PropertyInfo property, List<string> knownAliases)
{
var ret = PropertyInitializer.CreateInstance<CommandLineArgument>();
ret.DefaultValue = property.HasAttr<DefaultValueAttribute>() ? property.Attr<DefaultValueAttribute>().Value : null;
ret.Position = property.HasAttr<ArgPosition>() ? property.Attr<ArgPosition>().Position : -1;
ret.Source = property;
ret.ArgumentType = property.PropertyType;
ret.IgnoreCase = true;
if (property.DeclaringType.HasAttr<ArgIgnoreCase>() && property.DeclaringType.Attr<ArgIgnoreCase>().IgnoreCase == false)
{
ret.IgnoreCase = false;
}
if (property.HasAttr<ArgIgnoreCase>() && property.Attr<ArgIgnoreCase>().IgnoreCase == false)
{
ret.IgnoreCase = false;
}
ret.Aliases.AddRange(FindDefaultShortcuts(property, knownAliases, ret.IgnoreCase));
// TODO - I think the first generic call can just be more specific
ret.Metadata.AddRange(property.Attrs<IArgMetadata>().AssertAreAllInstanceOf<ICommandLineArgumentMetadata>());
return ret;
}
internal static bool IsArgument(PropertyInfo property)
{
if (property.HasAttr<ArgIgnoreAttribute>()) return false;
if (CommandLineAction.IsActionImplementation(property)) return false;
if (property.Name == Constants.ActionPropertyConventionName &&
property.HasAttr<ArgPosition>() &&
property.Attr<ArgPosition>().Position == 0 &&
property.HasAttr<ArgRequired>())
{
return false;
}
return true;
}
private static void SetPropertyFromTextValue(ParserContext context, ConsoleControl control, PropertyInfo property, string textValue)
{
bool isObservable = textValue.StartsWith("{") && textValue.EndsWith("}");
if (isObservable)
{
var observablePropertyName = textValue.Substring(1, textValue.Length - 2);
var viewModelObservable = context.CurrentViewModel as ObservableObject;
if (viewModelObservable == null) throw new InvalidOperationException("View model is not observable");
new ViewModelBinding(control, property, viewModelObservable, observablePropertyName);
}
else if(property.HasAttr<MarkupPropertyAttribute>())
{
property.Attr<MarkupPropertyAttribute>().Processor.Process(context);
}
else if (property.PropertyType == typeof(string))
{
property.SetValue(control, textValue);
}
else if (property.PropertyType == typeof(ConsoleString))
{
property.SetValue(control, new ConsoleString(textValue));
}
else if (property.PropertyType.IsEnum)
{
var enumVal = Enum.Parse(property.PropertyType, textValue);
property.SetValue(control, enumVal);
}
else if (property.PropertyType == typeof(Event))
{
Event ev = property.GetValue(control) as Event;
var target = context.CurrentViewModel;
Action handler = () =>
{
var method = target.GetType().GetMethod(textValue, new Type[0]);
if (method != null)
{
method.Invoke(target, new object[0]);
}
else
{
var action = target.GetType().GetProperty(textValue);
if (action == null || action.PropertyType != typeof(Action))
{
throw new InvalidOperationException("Not a method or action");
}
((Action)action.GetValue(target)).Invoke();
}
};
ev.SubscribeForLifetime(handler, control.LifetimeManager);
}
else
{
var parseMethod = property.PropertyType.GetMethod("Parse", new Type[] { typeof(string) });
var parsed = parseMethod.Invoke(null, new object[] { textValue });
property.SetValue(control, parsed);
}
}