public override bool CanAssist(RichCommandLineContext context)
{
Providers.Clear();
Providers.AddRange(standardProviders);
CommandLineArgument targetArgument = null;
if (context.PreviousNonWhitespaceToken != null && ArgParser.IsDashSpecifiedArgumentIdentifier(context.PreviousNonWhitespaceToken.Value))
{
var candidate = context.PreviousNonWhitespaceToken.Value.Substring(1);
targetArgument = (from a in Definition.AllGlobalAndActionArguments where a.IsMatch(candidate) select a).SingleOrDefault();
}
if (targetArgument != null)
{
foreach (var assistant in targetArgument.Metadata.Metas <ArgContextualAssistant>())
{
var dynamicProvider = assistant.GetContextAssistProvider(Definition);
Providers.Add(dynamicProvider);
}
}
foreach (var provider in Providers)
{
if (provider is PowerArgsContextAwareAssistant)
{
(provider as PowerArgsContextAwareAssistant).TargetArgument = targetArgument;
}
}
var ret = base.CanAssist(context);
return(ret);
}
public static CommandLineArgument FindContextualArgument(FindContextualArgumentArgs args)
{
args.Definition = PassThroughOrTryGetAmbientDefinition(args.Definition);
string currentTokenArgumentNameValue = null;
if (args.PreviousToken != null && ArgParser.IsDashSpecifiedArgumentIdentifier(args.PreviousToken))
{
currentTokenArgumentNameValue = args.PreviousToken.Substring(1);
}
else if (args.PreviousToken != null && args.PreviousToken.StartsWith("/"))
{
currentTokenArgumentNameValue = args.PreviousToken.Substring(1);
}
else
{
// strange behavior outside of this method where we need to look back one if the current token has a non whitespace value
var targetPosition = string.IsNullOrWhiteSpace(args.CurrentToken) ? args.CurrentTokenIndex : args.CurrentTokenIndex - 1;
if (targetPosition < 0)
{
return(null);
}
var positionArg = args.ActionContext == null?
args.Definition.Arguments.Where(a => a.Position == targetPosition).FirstOrDefault() :
args.ActionContext.Arguments.Where(a => a.Position == targetPosition).FirstOrDefault();
var argsArray = Args.Convert(args.CommandLine);
if (positionArg == null)
{
return(positionArg);
}
for (var i = 0; i < Math.Min(argsArray.Length, targetPosition + 1); i++)
{
// positional args must occur before any named args
if (argsArray[i].StartsWith("/") || Regex.IsMatch(argsArray[i], @"^-[^\d]"))
{
return(null);
}
}
return(positionArg);
}
CommandLineArgument currentTokenArgument = null;
if (currentTokenArgumentNameValue != null)
{
currentTokenArgument = args.Definition.Arguments.Where(arg => arg.IsMatch(currentTokenArgumentNameValue) && arg.ArgumentType != typeof(bool)).SingleOrDefault();
if (currentTokenArgument == null && args.ActionContext != null)
{
currentTokenArgument = args.ActionContext.Arguments.Where(arg => arg.IsMatch(currentTokenArgumentNameValue) && arg.ArgumentType != typeof(bool)).SingleOrDefault();
}
}
return(currentTokenArgument);
}
public bool TryComplete(TabCompletionContext context, out string completion)
{
var fixedUpCandidate = context.CompletionCandidate;
if (ArgParser.IsDashSpecifiedArgumentIdentifier(fixedUpCandidate))
{
fixedUpCandidate = fixedUpCandidate.Substring(1);
}
else if (fixedUpCandidate.StartsWith("/"))
{
fixedUpCandidate = fixedUpCandidate.Substring(1);
}
else
{
completion = null;
return(false);
}
var match = definition.Arguments.Where(arg => arg.IsMatch(fixedUpCandidate)).SingleOrDefault();
if (match == null)
{
foreach (var action in definition.Actions)
{
match = action.Arguments.Where(arg => arg.IsMatch(fixedUpCandidate)).SingleOrDefault();
if (match != null)
{
break;
}
}
}
if (match == null)
{
completion = null;
return(false);
}
if (match != argument)
{
completion = null;
return(false);
}
return(TryComplete(new ArgumentAwareTabCompletionContext()
{
InnerContext = context,
Argument = argument
}
, out completion));
}
/// <summary>
/// A helper that detects the argument represented by the current token given a definition.
/// </summary>
/// <param name="contextualAction">An action to inspect for a match if the current token does not match a global argument. Pass null to only check global arguments.</param>
/// <param name="currentToken">The token to inspect. If you pass null you will get null back.</param>
/// <param name="expectMatchingArg">This will be set to true if the current token starts with a '-' or a '/' meaning that the token was an argument indicator, even if it didn't match an argument in the definition.</param>
/// <param name="def">The definition to inspect. If null, the ambient definition will be used. If there is no ambient definition and null is passed then this method throws a NullReferenceException.</param>
/// <returns>An argument that is matched by the given token or null if there was no match</returns>
public static CommandLineArgument FindCurrentTokenArgument(CommandLineAction contextualAction, string currentToken, out bool expectMatchingArg, CommandLineArgumentsDefinition def = null)
{
def = PassThroughOrTryGetAmbientDefinition(def);
if (currentToken == null)
{
expectMatchingArg = false;
return(null);
}
string currentTokenArgumentNameValue = null;
expectMatchingArg = false;
if (ArgParser.IsDashSpecifiedArgumentIdentifier(currentToken))
{
currentTokenArgumentNameValue = currentToken.Substring(1);
expectMatchingArg = true;
}
else if (currentToken.StartsWith("/"))
{
currentTokenArgumentNameValue = currentToken.Substring(1);
expectMatchingArg = true;
}
CommandLineArgument currentTokenArgument = null;
if (currentTokenArgumentNameValue != null)
{
currentTokenArgument = def.Arguments.Where(arg => arg.IsMatch(currentTokenArgumentNameValue)).SingleOrDefault();
if (currentTokenArgument == null && contextualAction != null)
{
currentTokenArgument = contextualAction.Arguments.Where(arg => arg.IsMatch(currentTokenArgumentNameValue)).SingleOrDefault();
}
}
return(currentTokenArgument);
}