public bool TryExtractObjectPropertyIntoCommandLineArgument(object o, CommandLineArgument argument, string[] staticMappings, out string commandLineKey, out string commandLineValue)
{
if (o is JObject == false)
{
throw new ArgumentException("Type not supported, must be JObject: " + o.GetType().FullName);
}
var dynamicObject = (IDictionary<string,JProperty>)o;
var mapCandidates = argument.Aliases.Union(staticMappings).Select(a => a.Replace("-", ""));
var mapSuccessCandidate = (from member in dynamicObject.Keys
where mapCandidates.Contains(member, StringComparer.Create(System.Globalization.CultureInfo.InvariantCulture, true))
select member).FirstOrDefault();
if (mapSuccessCandidate != null)
{
commandLineKey = "-" + argument.DefaultAlias;
commandLineValue = dynamicObject[mapSuccessCandidate] + "";
return true;
}
else
{
commandLineKey = null;
commandLineValue = null;
return false;
}
}
internal bool TryExtractObjectPropertyIntoCommandLineArgument(object o, CommandLineArgument argument, out string commandLineKey, out string commandLineValue)
{
if (ArgPipelineObjectMapper.CurrentMapper == null || ArgPipelineObjectMapper.CurrentMapper.TryExtractObjectPropertyIntoCommandLineArgument(o, argument, StaticMappings, out commandLineKey, out commandLineValue) == false)
{
return TryDefaultShredStaticObjectPropertyIntoCommandLineArgument(o, argument, out commandLineKey, out commandLineValue);
}
else
{
return true;
}
}
public void exception_is_thrown_when_argments_are_not_valid()
{
parser.IsValid = false;
CommandLineArgument<int> arg = new CommandLineArgument<int>(parser, "shortName", "longName", "description", true);
int value;
Error.Expect<InvalidOperationException>(() =>
{
value = arg.Value;
});
}
public void value_is_take_from_the_parser()
{
CommandLineArgument<int> arg = new CommandLineArgument<int>(parser, "shortName", "longName", "description", true);
parser.GetValue = (a) =>
{
if (a == arg)
return 7;
return -1;
};
Assert.That(arg.Value, Is.EqualTo(7));
}
private static bool NeedsSingleLetterExpansion(CommandLineArgument argument)
{
return argument.IsQualifier &&
argument.Modifier == "-" &&
argument.Name.Length > 1;
}
private static void ExpandSingleLetterArguments(List<CommandLineArgument> receiver, int index)
{
var qualifiers = receiver[index].Name;
receiver.RemoveAt(index);
foreach (var c in qualifiers)
{
var singleLetterName = char.ToString(c);
var expandedArgument = new CommandLineArgument("-", singleLetterName, null);
receiver.Insert(index, expandedArgument);
index++;
}
}
public static IReadOnlyList<CommandLineArgument> Parse(IEnumerable<string> commandLineArguments)
{
var result = new List<CommandLineArgument>();
// We'll split the arguments into command line argument objects.
//
// CommandLineArgument objects combine modifier (/, -, --), the qualifier
// name, and the qualifier value.
//
// Please note that this code doesn't combine arguments. It only provides
// some pre-processing over the arguments to split out the modifier,
// qualifier, and value:
//
// { "--out", "out.exe" } ==> { new CommandLineArgument("--", "out", null),
// new CommandLineArgument(null, null, "out.exe") }
//
// {"--out:out.exe" } ==> { new CommandLineArgument("--", "out", "out.exe") }
//
// The code also handles the special -- argument which indicates that the following
// arguments shouldn't be considered qualifiers.
var hasSeenDashDash = false;
foreach (var argument in ExpandReponseFiles(commandLineArguments))
{
if (!hasSeenDashDash && argument == "--")
{
hasSeenDashDash = true;
continue;
}
string modifier;
string remainder;
bool isModifier;
if (!hasSeenDashDash)
{
isModifier = TryExtractModifer(argument, out modifier, out remainder);
}
else
{
modifier = null;
remainder = argument;
isModifier = false;
}
if (!isModifier)
remainder = argument;
string key;
string value;
if (!isModifier || !TrySplitKeyValue(remainder, out key, out value))
{
key = remainder;
value = null;
}
var parsedArgument = new CommandLineArgument(modifier, key, value);
result.Add(parsedArgument);
}
// Single letter options can be combined, for example the following two
// forms are considered equivalent:
//
// (1) -xdf
// (2) -x -d -f
//
// In order to free later phases from handling this case, we simply expand
// single letter options to the second form.
for (var i = result.Count - 1; i >= 0; i--)
{
if (NeedsSingleLetterExpansion(result[i]))
ExpandSingleLetterArguments(result, i);
}
return result.ToArray();
}
private static bool IsCompatible(object o, CommandLineArgument directMappingTarget)
{
var oType = o.GetType();
if (oType == directMappingTarget.ArgumentType) return true;
if (oType.GetInterfaces().Contains(directMappingTarget.ArgumentType)) return true;
if (oType.IsSubclassOf(directMappingTarget.ArgumentType)) return true;
return false;
}
private bool TryDefaultShredStaticObjectPropertyIntoCommandLineArgument(object o, CommandLineArgument argument, out string commandLineKey, out string commandLineValue)
{
var mapCandidates = argument.Aliases.Union(StaticMappings).Select(a => a.Replace("-", ""));
var mapSuccessCandidate = (from p in o.GetType().GetProperties()
where mapCandidates.Contains(p.Name, StringComparer.Create(System.Globalization.CultureInfo.InvariantCulture, true))
select p).FirstOrDefault();
if (mapSuccessCandidate != null)
{
commandLineKey = "-" + argument.DefaultAlias;
commandLineValue = mapSuccessCandidate.GetValue(o, null) + "";
return true;
}
else
{
commandLineKey = null;
commandLineValue = null;
return false;
}
}
