public static IEnumerable <OptionError> ValidateAll(
this AppliedOption option) =>
new[] { option.Validate() }
.Concat(
option.AppliedOptions
.SelectMany(ValidateAll))
.Where(o => o != null);
public static string Diagram(this AppliedOption option)
{
var stringbuilder = new StringBuilder();
stringbuilder.Diagram(option);
return(stringbuilder.ToString());
}
public static bool HasOption(
this AppliedOption option,
string alias)
{
if (option == null)
{
throw new ArgumentNullException(nameof(option));
}
return(option.AppliedOptions.Contains(alias));
}
internal static IEnumerable <AppliedOption> AllOptions(
this AppliedOption option)
{
if (option == null)
{
throw new ArgumentNullException(nameof(option));
}
yield return(option);
foreach (var item in option.AppliedOptions.FlattenBreadthFirst(o => o.AppliedOptions))
{
yield return(item);
}
}
internal static IEnumerable <AppliedOption> AllOptions(
this AppliedOption option)
{
if (option == null)
{
yield break;
}
yield return(option);
foreach (var item in option.AppliedOptions.FlattenBreadthFirst(o => o.AppliedOptions))
{
yield return(item);
}
}
public OptionError(
string message,
string token,
AppliedOption option = null)
{
if (string.IsNullOrWhiteSpace(message))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(message));
}
if (string.IsNullOrWhiteSpace(token))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(token));
}
Message = message;
Option = option;
Token = token;
}
private static void Diagram(
this StringBuilder builder,
AppliedOption option)
{
builder.Append("[ ");
builder.Append(option.Option);
foreach (var childOption in option.AppliedOptions)
{
builder.Append(" ");
builder.Diagram(childOption);
}
foreach (var arg in option.Arguments)
{
builder.Append(" <");
builder.Append(arg);
builder.Append(">");
}
builder.Append(" ]");
}
internal ParseResult Parse(
IReadOnlyCollection <string> rawArgs,
bool isProgressive)
{
var unparsedTokens = new Queue <Token>(
NormalizeRootCommand(rawArgs)
.Lex(configuration));
var rootAppliedOptions = new AppliedOptionSet();
var allAppliedOptions = new List <AppliedOption>();
var errors = new List <OptionError>();
var unmatchedTokens = new List <string>();
while (unparsedTokens.Any())
{
var token = unparsedTokens.Dequeue();
if (token.Value == "--")
{
// stop parsing further tokens
break;
}
if (token.Type != TokenType.Argument)
{
var definedOption =
DefinedOptions.SingleOrDefault(o => o.HasAlias(token.Value));
if (definedOption != null)
{
var appliedOption = allAppliedOptions
.LastOrDefault(o => o.HasAlias(token.Value));
if (appliedOption == null)
{
appliedOption = new AppliedOption(definedOption, token.Value);
rootAppliedOptions.Add(appliedOption);
}
else
{
appliedOption.OptionWasRespecified();
}
allAppliedOptions.Add(appliedOption);
continue;
}
}
var added = false;
foreach (var appliedOption in Enumerable.Reverse(allAppliedOptions))
{
var option = appliedOption.TryTakeToken(token);
if (option != null)
{
allAppliedOptions.Add(option);
added = true;
break;
}
}
if (!added)
{
unmatchedTokens.Add(token.Value);
}
}
if (rootAppliedOptions.Command()?.TreatUnmatchedTokensAsErrors == true)
{
errors.AddRange(
unmatchedTokens.Select(UnrecognizedArg));
}
return(new ParseResult(
rawArgs,
rootAppliedOptions,
isProgressive,
unparsedTokens.Select(t => t.Value).ToArray(),
unmatchedTokens,
errors));
}
internal object Materialize(AppliedOption appliedOption) => materialize?.Invoke(appliedOption);
public string Validate(AppliedOption option) => validate(option);
internal ParseResult Parse(
IReadOnlyCollection <string> rawArgs,
bool isProgressive)
{
var validTokens = DefinedOptions
.FlattenBreadthFirst()
.SelectMany(o => o.Aliases)
.Distinct()
.ToArray();
var unparsedTokens = new Queue <string>(Normalize(rawArgs).Lex(validTokens));
var appliedOptions = new OptionSet <AppliedOption>();
var errors = new List <OptionError>();
var unmatchedTokens = new List <string>();
AppliedOption currentOption = null;
string arg;
while (unparsedTokens.Any())
{
arg = unparsedTokens.Dequeue();
if (arg == "--")
{
// stop parsing further args
break;
}
if (DefinedOptions.Any(o => o.HasAlias(arg)))
{
var option = appliedOptions.SingleOrDefault(o => o.HasAlias(arg));
var alreadySeen = option != null;
if (!alreadySeen)
{
option = new AppliedOption(
DefinedOptions.Single(s => s.HasAlias(arg)),
arg);
appliedOptions.Add(option);
}
if (!option.Option.IsCommand || !alreadySeen)
{
currentOption = option;
continue;
}
}
unmatchedTokens.Add(arg);
if (currentOption != null)
{
unmatchedTokens = currentOption
.TryTakeTokens(unmatchedTokens.ToArray())
.ToList();
}
}
errors.AddRange(
unmatchedTokens.Select(UnrecognizedArg));
return(new ParseResult(
this,
rawArgs,
appliedOptions,
isProgressive,
unparsedTokens,
unmatchedTokens,
errors));
}
