private IParsingResultsDictionary parseConfigFromCommandLine()
{
var arguments = new Queue <string>(_source.Args);
var plainValueCounter = 0;
var resultsBuilder = new ParsingResultsBuilder(_source.DuplicateKeyBehavior);
var lastArgumentString = _source.Args.First();
while (arguments.Any())
{
var currentArgumentString = arguments.Dequeue();
var parsedArgument = ArgumentType.CreateFrom(currentArgumentString);
switch (parsedArgument)
{
case ArgumentType.SingleDash dashArgument:
handleSingleDashArgument(resultsBuilder, arguments, dashArgument);
break;
case ArgumentType.DoubleDash doubleDashArgument:
handleDoubledashArgument(resultsBuilder, arguments, doubleDashArgument);
break;
case ArgumentType.Assignment assignment:
if (_source.AllowDirectAssignments)
{
resultsBuilder.Add(assignment.Key, assignment.Value);
}
else
{
resultsBuilder.Error(new NotSupportedException($"Invalid argument '{assignment.Argument}' as direct assignments are not allowed."));
}
break;
case ArgumentType.Invalid invalid:
resultsBuilder.Error(new ParsingException("Invalid argument.", $"Argument somewhere near: '{lastArgumentString.Limit(16)}'"));
break;
case ArgumentType.Plain plain:
if (plainValueCounter < _valueDefinitions.Count)
{
resultsBuilder.Add(_valueDefinitions[plainValueCounter], plain.Argument);
}
else
{
resultsBuilder.Error(new IndexOutOfRangeException($"No more than {_valueDefinitions.Count} value arguments are allowed."));
}
plainValueCounter++;
break;
}
lastArgumentString = currentArgumentString;
}
if (_valueDefinitions.Count > plainValueCounter)
{
resultsBuilder.Error(new ValueRequiredException(string.Empty, $"Not all required values have been provided. Expected: {_valueDefinitions.Count}, Provided: {plainValueCounter}"));
}
return(resultsBuilder.GetResults());
}
private static Unit addValueOptionToResults(ParsingResultsBuilder result,
Queue <string> arguments,
ArgumentDefinition.ValueOptionDefinition valueOption,
Func <ArgumentDefinition.ValueOptionDefinition, string> argumentNameSelector)
=> arguments.Any()
? result.Add(valueOption.ConfigurationKey, arguments.Dequeue())
: result.ErrorArgumentRequiresValue($"{argumentNameSelector(valueOption)}", $"The argument '{argumentNameSelector(valueOption)}' requires an additional value.");
private Unit handleDoubledashArgument(ParsingResultsBuilder result, Queue <string> arguments, ArgumentType.DoubleDash doubleDashArgument)
{
if (_indexedArgumentDefinitions.TryGetValue(doubleDashArgument.Argument, out ArgumentDefinition currentDefinition))
{
switch (currentDefinition)
{
case ArgumentDefinition.SwitchOptionDefinition switchOption:
return(addSwitchToResults(result, switchOption));
case ArgumentDefinition.ValueOptionDefinition valueOption:
return(addValueOptionToResults(result, arguments, valueOption, p => $"--{p.LongName.GetValue(null)}"));
}
}
// if we're her, it's an error, unknown argument/switch
return(result.ErrorArgumentUnknown($"--{doubleDashArgument.Argument}"));
}
private static IParsingResultsDictionary readIniFromStream(Stream stream, KeyNameBehavior duplicateKeyBehavior)
{
var resultBuilder = new ParsingResultsBuilder(duplicateKeyBehavior);
using (StreamReader streamReader = new StreamReader(stream))
{
var currentKeyPrefix = string.Empty;
int lineCounter = 0;
while (streamReader.Peek() != -1)
{
string currentLine = streamReader.ReadLine();
lineCounter++;
if (iniLineIsNotEmptyOrComment(currentLine))
{
var currentLineIsSectionHeading = getHeadingFromIniLine(currentLine);
currentKeyPrefix = currentLineIsSectionHeading.GetValue(currentKeyPrefix);
if (currentLineIsSectionHeading.IsNothing())
{
int assignmentOperatorPos = currentLine.IndexOf('=');
if (assignmentOperatorPos == 0)
{
resultBuilder.ErrorInvalidParsing($"Line #{lineCounter}", $"Line cannot start with assignment operator.{Environment.NewLine} {currentLine}");
}
else if (assignmentOperatorPos < 0)
{
resultBuilder.Add(currentKeyPrefix + currentLine.Trim(), string.Empty, () => $"Error in line #{lineCounter}:");
}
else
{
string keyFullPathName = $"{currentKeyPrefix}{currentLine.Substring(0, assignmentOperatorPos).Trim()}";
string currentValue = assignmentOperatorPos < currentLine.Trim().Length - 1
? getValueFromPossiblyQuotedString(currentLine.Substring(assignmentOperatorPos + 1).Trim())
: string.Empty;
resultBuilder.Add(keyFullPathName, currentValue, () => $"Error in line #{lineCounter}:");
}
}
}
}
return(resultBuilder.GetResults());
}
}
private Unit handleSingleDashArgument(ParsingResultsBuilder result, Queue <string> arguments, ArgumentType.SingleDash dashArgument)
{
// separate every character of a possible switch-group
var allSwitches = dashArgument.Argument.Select(c => c.ToString()).ToList();
for (int i = 0; i < allSwitches.Count; i++)
{
if (_indexedArgumentDefinitions.TryGetValue(allSwitches[i], out ArgumentDefinition currentDefinition))
{
switch (currentDefinition)
{
case ArgumentDefinition.SwitchOptionDefinition switchOption:
addSwitchToResults(result, switchOption);
break;
case ArgumentDefinition.ValueOptionDefinition valueOption:
if (i == allSwitches.Count - 1)
{
addValueOptionToResults(result, arguments, valueOption, p => $"-{p.ShortName.GetValue(null)}");
}
else
{
// error, value-argument must be last character
string argumentName = $"-{valueOption.ShortName.GetValue(null)}";
return(result.ErrorArgumentRequiresValue(argumentName, $"Argument '-{argumentName}' requires a value and thus must be last character of an argument group."));
}
break;
}
}
else
{
// error, unknown argument/switch
result.ErrorArgumentUnknown($"-{allSwitches[i]}");
}
}
return(Unit.Default);
}
private static Unit addSwitchToResults(ParsingResultsBuilder result, ArgumentDefinition.SwitchOptionDefinition currentDefinition) => result.Add(currentDefinition.ConfigurationKey, currentDefinition.ConfigurationValue);
