public static void Main(string[] args)
{
var parser = new OptionsParser(new ParserConfiguration
{
GenerateHelp = true,
CustomFooterGenerator = () => "All unparsed options will be forwarded to CLI application.",
CustomUsageLineGenerator = usageLine => usageLine + " [script]",
AllowUnexpectedArguments = true
});
var options = new Options();
if(!parser.Parse(options, args))
{
return;
}
var mode = options.Debug ? "Debug" : "Release";
var monoOptions = options.Debug ? "--debug" : string.Empty;
if(options.DebuggerSocketPort != -1)
{
monoOptions += string.Format(" --debugger-agent=transport=dt_socket,address=127.0.0.1:{0},server=y", options.DebuggerSocketPort);
Console.WriteLine("Listening on port {0}", options.DebuggerSocketPort);
}
var rootPath = (options.RootPath == ".") ? Environment.CurrentDirectory : options.RootPath;
Console.WriteLine("Running in {0} mode.\nROOT_PATH={1}", mode, rootPath);
var binaryPath = Path.Combine(rootPath, "output", mode, "CLI.exe");
var optionsToPass = parser.RecreateUnparsedArguments();
if(options.HelpCLI)
{
Console.WriteLine("NOTE: showing help from binary: {0}", binaryPath);
optionsToPass = "******";
}
var process = new Process();
process.StartInfo.FileName = "mono";
process.StartInfo.Arguments = string.Format("{0} {1} {2}", monoOptions, binaryPath, optionsToPass);
if(options.Quiet)
{
process.StartInfo.RedirectStandardError = true;
process.StartInfo.UseShellExecute = false;
}
process.Start();
if(options.Quiet)
{
process.StandardError.Close();
}
process.WaitForExit();
}
public void ShouldNotRecreatedParsedValue()
{
var args = new [] { "--switch", "value" };
var parser = new OptionsParser();
parser.WithOption <string>("switch");
parser.Parse(args);
Assert.AreEqual(1, parser.ParsedOptions.Count());
Assert.AreEqual(args[1], parser.ParsedOptions.First().Value);
Assert.IsEmpty(parser.RecreateUnparsedArguments());
}
public void ShouldRemoveEmptyShortFlagPrefix()
{
var args = new [] { "-AB" };
var parser = new OptionsParser();
parser.WithOption <bool>('A');
parser.WithOption <bool>('B');
parser.Parse(args);
Assert.AreEqual(2, parser.ParsedOptions.Count());
Assert.AreEqual('A', parser.ParsedOptions.First().Flag.ShortName);
Assert.AreEqual('B', parser.ParsedOptions.Last().Flag.ShortName);
Assert.AreEqual(string.Empty, parser.RecreateUnparsedArguments());
}
public void ShouldRecreateMixedShortFlag()
{
var args = new [] { "-AwB" };
var parser = new OptionsParser();
parser.WithOption <bool>('A');
parser.WithOption <bool>('B');
parser.Parse(args);
Assert.AreEqual(2, parser.ParsedOptions.Count());
Assert.AreEqual('A', parser.ParsedOptions.First().Flag.ShortName);
Assert.AreEqual('B', parser.ParsedOptions.Last().Flag.ShortName);
Assert.AreEqual("-w", parser.RecreateUnparsedArguments());
}
public void ShouldHandleIntOptionWithDefaultValueFollowedByString()
{
var args = new [] { "--value", "test" };
var parser = new OptionsParser(new ParserConfiguration {
AllowUnexpectedArguments = true
});
var options = new OptionsWithInt();
parser.Parse(options, args);
Assert.AreEqual(-1, options.Value);
Assert.AreEqual(1, parser.UnexpectedArguments.Count());
Assert.AreEqual("test", parser.UnexpectedArguments.First().Value);
Assert.AreEqual("test", parser.RecreateUnparsedArguments());
}
public void ShouldRecreateUnparsedArgument13()
{
var args = new[] { "-n", "123", "--wrong-arg" };
var parser = new OptionsParser();
parser.WithOption <int>('n');
parser.Parse(args);
Assert.AreEqual(1, parser.ParsedOptions.Count());
Assert.AreEqual('n', parser.ParsedOptions.First().Flag.ShortName);
Assert.AreEqual(123, parser.ParsedOptions.First().Value);
Assert.AreEqual(1, parser.UnexpectedArguments.Count());
Assert.AreEqual("wrong-arg", parser.UnexpectedArguments.ElementAt(0).Value);
Assert.AreEqual("--wrong-arg", parser.RecreateUnparsedArguments());
}
public void ShouldRecreateUnparsedArgument15()
{
var args = new[] { "--port=8888", "--no-xwt" };
var parser = new OptionsParser();
parser.WithOption <int>("port");
parser.Parse(args);
Assert.AreEqual(1, parser.ParsedOptions.Count());
Assert.AreEqual("port", parser.ParsedOptions.First().Flag.LongName);
Assert.AreEqual(8888, parser.ParsedOptions.First().Value);
Assert.AreEqual(1, parser.UnexpectedArguments.Count());
Assert.AreEqual("no-xwt", parser.UnexpectedArguments.ElementAt(0).Value);
Assert.AreEqual("--no-xwt", parser.RecreateUnparsedArguments());
}
public void ShouldNotParseAfterDoubleHyphen()
{
var args = new [] { "--", "--value", "test" };
var parser = new OptionsParser(new ParserConfiguration {
AllowUnexpectedArguments = true
});
var options = new OptionsWithInt();
parser.Parse(options, args);
Assert.AreEqual(-1, options.Value);
Assert.AreEqual(0, parser.ParsedOptions.Count());
Assert.AreEqual(2, parser.UnexpectedArguments.Count());
Assert.AreEqual("--value", parser.UnexpectedArguments.ElementAt(0).Value);
Assert.AreEqual("test", parser.UnexpectedArguments.ElementAt(1).Value);
Assert.AreEqual("--value test", parser.RecreateUnparsedArguments());
}
public void ShouldRecreateUnparsedArgument3()
{
var args = new[] { "positional argument", "-p8888", "--wrong-arg" };
var parser = new OptionsParser();
parser.WithOption <int>('p');
var options = new OptionsWithMultipleArguments();
parser.Parse(options, args);
Assert.AreEqual("positional argument", options.Value);
Assert.AreEqual(1, parser.ParsedOptions.Count());
Assert.AreEqual('p', parser.ParsedOptions.First().Flag.ShortName);
Assert.AreEqual(8888, parser.ParsedOptions.First().Value);
Assert.AreEqual(1, parser.UnexpectedArguments.Count());
Assert.AreEqual("wrong-arg", parser.UnexpectedArguments.ElementAt(0).Value);
Assert.AreEqual("--wrong-arg", parser.RecreateUnparsedArguments());
}
public void ShouldRecreateUnparsedArgument7()
{
var args = new[] { "positional argument", "--port=8888", "--wrong-arg" };
var parser = new OptionsParser();
parser.WithOption <int>("port");
var options = new OptionsWithMultipleArguments();
parser.Parse(options, args);
Assert.AreEqual("positional argument", options.Value);
Assert.AreEqual(1, parser.ParsedOptions.Count());
Assert.AreEqual("port", parser.ParsedOptions.ToArray()[0].Flag.LongName);
Assert.AreEqual(8888, parser.ParsedOptions.ToArray()[0].Value);
Assert.AreEqual(1, parser.UnexpectedArguments.Count());
Assert.AreEqual("wrong-arg", parser.UnexpectedArguments.ElementAt(0).Value);
Assert.AreEqual("--wrong-arg", parser.RecreateUnparsedArguments());
}
public void ShouldAcceptExpectedValues()
{
var args = new [] { "-a", "-b", "value-1", "-c", "value-2", "-d", "value-3" };
var parser = new OptionsParser();
parser.WithValue("val1");
parser.WithValue("val2");
parser.WithOption<bool>('a');
parser.WithOption<bool>('b');
parser.WithOption<bool>('c');
parser.WithOption<bool>('d');
parser.Parse(args);
Assert.AreEqual(4, parser.ParsedOptions.Count());
Assert.AreEqual('a', parser.ParsedOptions.ElementAt(0).Flag.ShortName);
Assert.AreEqual('b', parser.ParsedOptions.ElementAt(1).Flag.ShortName);
Assert.AreEqual('c', parser.ParsedOptions.ElementAt(2).Flag.ShortName);
Assert.AreEqual('d', parser.ParsedOptions.ElementAt(3).Flag.ShortName);
Assert.AreEqual(2, parser.Values.Count());
Assert.AreEqual("value-1", parser.Values.ElementAt(0).Value);
Assert.AreEqual("value-2", parser.Values.ElementAt(1).Value);
Assert.AreEqual("value-3", parser.RecreateUnparsedArguments());
}
public void ShouldRecreateUnparsedArguments()
{
var args = new [] {
"--expected",
"-x",
"value",
"-y1",
"--another-expected",
"-Aw",
"-z'this was unexpected'"
};
var parser = new OptionsParser();
parser.WithOption <bool>("expected");
parser.WithOption <bool>("another-expected");
parser.WithOption <bool>('A');
parser.Parse(args);
Assert.AreEqual(3, parser.ParsedOptions.Count());
Assert.AreEqual("expected", parser.ParsedOptions.First().Flag.LongName);
Assert.AreEqual("another-expected", parser.ParsedOptions.ElementAt(1).Flag.LongName);
Assert.AreEqual(@"-x value -y1 -w ""-z'this was unexpected'""", parser.RecreateUnparsedArguments());
}
public void ShouldAcceptExpectedValues()
{
var args = new [] { "-a", "-b", "value-1", "-c", "value-2", "-d", "value-3" };
var parser = new OptionsParser();
parser.WithValue("val1");
parser.WithValue("val2");
parser.WithOption <bool>('a');
parser.WithOption <bool>('b');
parser.WithOption <bool>('c');
parser.WithOption <bool>('d');
parser.Parse(args);
Assert.AreEqual(4, parser.ParsedOptions.Count());
Assert.AreEqual('a', parser.ParsedOptions.ElementAt(0).Flag.ShortName);
Assert.AreEqual('b', parser.ParsedOptions.ElementAt(1).Flag.ShortName);
Assert.AreEqual('c', parser.ParsedOptions.ElementAt(2).Flag.ShortName);
Assert.AreEqual('d', parser.ParsedOptions.ElementAt(3).Flag.ShortName);
Assert.AreEqual(2, parser.Values.Count());
Assert.AreEqual("value-1", parser.Values.ElementAt(0).Value);
Assert.AreEqual("value-2", parser.Values.ElementAt(1).Value);
Assert.AreEqual("value-3", parser.RecreateUnparsedArguments());
}
public void ShouldHandleIntOptionWithDefaultValueFollowedByString()
{
var args = new [] { "--value", "test" };
var parser = new OptionsParser(new ParserConfiguration { AllowUnexpectedArguments = true });
var options = new OptionsWithInt();
parser.Parse(options, args);
Assert.AreEqual(-1, options.Value);
Assert.AreEqual(1, parser.UnexpectedArguments.Count());
Assert.AreEqual("test", parser.UnexpectedArguments.First().Value);
Assert.AreEqual("test", parser.RecreateUnparsedArguments());
}
public static void Main(string[] args)
{
var basicOptions = new BasicOptions();
var optionsParser = new OptionsParser(new ParserConfiguration
{
GenerateHelp = false,
AllowUnexpectedArguments = true
});
// here we parse only one option - `root-directory`
// the rest will be parsed in the second phase
if (!optionsParser.Parse(basicOptions, args))
{
return;
}
optionsParser = new OptionsParser(new ParserConfiguration
{
GenerateHelp = true,
CustomFooterGenerator = () => "All unparsed options will be forwarded to launched application.",
CustomUsageLineGenerator = usageLine => usageLine + " [script]",
AllowUnexpectedArguments = true
});
var addHelpSwitch = false;
var possibleLaunchees = new List <LaunchDescriptorsGroup>();
var selectedLaunchees = new List <LaunchDescriptorsGroup>();
var interestingBinaries = Scanner.ScanForInterestingBinaries(basicOptions.RootPath).OrderBy(x => x.Priority).ThenBy(x => x.Name).ToArray();
for (var i = 0; i < interestingBinaries.Length; i++)
{
var j = i;
possibleLaunchees.Add(interestingBinaries[i]);
interestingBinaries[i].GenerateSwitches(optionsParser, i == 0);
interestingBinaries[i].SwitchOption.Parsed += (option, value) =>
{
selectedLaunchees.Add(interestingBinaries[j]);
};
if (interestingBinaries[i].HelpOption != null)
{
interestingBinaries[i].HelpOption.Parsed += (option, value) =>
{
addHelpSwitch = true;
};
}
}
// here we parse all of the options again
// as only now we know which launch targets
// and configurations are available in the
// system
var options = new Options();
if (!optionsParser.Parse(options, args))
{
return;
}
var conf = options.Debug ? LaunchDescriptor.Configuration.Debug : LaunchDescriptor.Configuration.Release;
LaunchDescriptorsGroup selectedGroup = null;
LaunchDescriptor selectedLaunchee = null;
if (selectedLaunchees.Count == 0)
{
if (possibleLaunchees.Count == 0)
{
Console.Error.WriteLine("There is no launch target specified. Exiting");
Environment.Exit(1);
}
selectedGroup = possibleLaunchees.OrderBy(x => x.Priority).ThenBy(x => x.Name).First();
}
else if (selectedLaunchees.Count > 1)
{
Console.Error.WriteLine("Only one launch target can be used. Exiting");
Environment.Exit(1);
}
else
{
selectedGroup = selectedLaunchees.First();
}
selectedLaunchee = selectedGroup.ForConfiguration(conf);
if (selectedLaunchee == null)
{
Console.Error.WriteLine("Selected target {0} is not available in {1} configuration.", selectedGroup.Name, conf);
Environment.Exit(1);
}
#if !PLATFORM_WINDOWS
// it is not so easy to remotely debug on .NET, so we do not support it
var monoOptions = options.Debug ? "--debug" : string.Empty;
if (options.DebuggerSocketPort != -1)
{
monoOptions += string.Format(" --debugger-agent=transport=dt_socket,address=127.0.0.1:{0},server=y", options.DebuggerSocketPort);
Console.WriteLine("Listening on port {0}", options.DebuggerSocketPort);
}
#endif
var optionsToPass = optionsParser.RecreateUnparsedArguments();
if (addHelpSwitch)
{
Console.WriteLine("NOTE: showing help from binary: {0}", selectedLaunchee.Name);
optionsToPass = "******";
}
var process = new Process();
#if PLATFORM_WINDOWS
process.StartInfo.FileName = selectedLaunchee.Path;
process.StartInfo.Arguments = optionsToPass;
#else
process.StartInfo.FileName = "mono";
process.StartInfo.Arguments = string.Format("{0} {1} {2}", monoOptions, selectedLaunchee.Path, optionsToPass);
#endif
if (options.Quiet)
{
process.StartInfo.RedirectStandardError = true;
process.StartInfo.UseShellExecute = false;
}
process.Start();
if (options.Quiet)
{
process.StandardError.Close();
}
process.WaitForExit();
}
public static void Main(string[] args)
{
var basicOptions = new BasicOptions();
var optionsParser = new OptionsParser(new ParserConfiguration
{
GenerateHelp = false,
AllowUnexpectedArguments = true
});
// here we parse only one option - `root-directory`
// the rest will be parsed in the second phase
if(!optionsParser.Parse(basicOptions, args))
{
return;
}
optionsParser = new OptionsParser(new ParserConfiguration
{
GenerateHelp = true,
CustomFooterGenerator = () => "All unparsed options will be forwarded to launched application.",
CustomUsageLineGenerator = usageLine => usageLine + " [script]",
AllowUnexpectedArguments = true
});
var addHelpSwitch = false;
var possibleLaunchees = new List<LaunchDescriptorsGroup>();
var selectedLaunchees = new List<LaunchDescriptorsGroup>();
var interestingBinaries = Scanner.ScanForInterestingBinaries(basicOptions.RootPath).OrderBy(x => x.Priority).ThenBy(x => x.Name).ToArray();
for(var i = 0; i < interestingBinaries.Length; i++)
{
var j = i;
possibleLaunchees.Add(interestingBinaries[i]);
interestingBinaries[i].GenerateSwitches(optionsParser, i == 0);
interestingBinaries[i].SwitchOption.Parsed += (option, value) =>
{
selectedLaunchees.Add(interestingBinaries[j]);
};
if(interestingBinaries[i].HelpOption != null)
{
interestingBinaries[i].HelpOption.Parsed += (option, value) =>
{
addHelpSwitch = true;
};
}
}
// here we parse all of the options again
// as only now we know which launch targets
// and configurations are available in the
// system
var options = new Options();
if(!optionsParser.Parse(options, args))
{
return;
}
var conf = options.Debug ? LaunchDescriptor.Configuration.Debug : LaunchDescriptor.Configuration.Release;
LaunchDescriptorsGroup selectedGroup = null;
LaunchDescriptor selectedLaunchee = null;
if(selectedLaunchees.Count == 0)
{
if(possibleLaunchees.Count == 0)
{
Console.Error.WriteLine("There is no launch target specified. Exiting");
Environment.Exit(1);
}
selectedGroup = possibleLaunchees.OrderBy(x => x.Priority).ThenBy(x => x.Name).First();
}
else if(selectedLaunchees.Count > 1)
{
Console.Error.WriteLine("Only one launch target can be used. Exiting");
Environment.Exit(1);
}
else
{
selectedGroup = selectedLaunchees.First();
}
selectedLaunchee = selectedGroup.ForConfiguration(conf);
if(selectedLaunchee == null)
{
Console.Error.WriteLine("Selected target {0} is not available in {1} configuration.", selectedGroup.Name, conf);
Environment.Exit(1);
}
var monoOptions = options.Debug ? "--debug" : string.Empty;
if(options.DebuggerSocketPort != -1)
{
monoOptions += string.Format(" --debugger-agent=transport=dt_socket,address=127.0.0.1:{0},server=y", options.DebuggerSocketPort);
Console.WriteLine("Listening on port {0}", options.DebuggerSocketPort);
}
var optionsToPass = optionsParser.RecreateUnparsedArguments();
if(addHelpSwitch)
{
Console.WriteLine("NOTE: showing help from binary: {0}", selectedLaunchee.Name);
optionsToPass = "******";
}
var process = new Process();
process.StartInfo.FileName = "mono";
process.StartInfo.Arguments = string.Format("{0} {1} {2}", monoOptions, selectedLaunchee.Path, optionsToPass);
if(options.Quiet)
{
process.StartInfo.RedirectStandardError = true;
process.StartInfo.UseShellExecute = false;
}
process.Start();
if(options.Quiet)
{
process.StandardError.Close();
}
process.WaitForExit();
}
public void ShouldRecreateUnparsedArguments()
{
var args = new [] {
"--expected",
"-x",
"value",
"-y1",
"--another-expected",
"-Aw",
"-z'this was unexpected'"
};
var parser = new OptionsParser();
parser.WithOption<bool>("expected");
parser.WithOption<bool>("another-expected");
parser.WithOption<bool>('A');
parser.Parse(args);
Assert.AreEqual(3, parser.ParsedOptions.Count());
Assert.AreEqual("expected", parser.ParsedOptions.First().Flag.LongName);
Assert.AreEqual("another-expected", parser.ParsedOptions.ElementAt(1).Flag.LongName);
Assert.AreEqual(@"-x value -y1 -w ""-z'this was unexpected'""", parser.RecreateUnparsedArguments());
}
public void ShouldRemoveEmptyShortFlagPrefix()
{
var args = new [] { "-AB" };
var parser = new OptionsParser();
parser.WithOption<bool>('A');
parser.WithOption<bool>('B');
parser.Parse(args);
Assert.AreEqual(2, parser.ParsedOptions.Count());
Assert.AreEqual('A', parser.ParsedOptions.First().Flag.ShortName);
Assert.AreEqual('B', parser.ParsedOptions.Last().Flag.ShortName);
Assert.AreEqual(string.Empty, parser.RecreateUnparsedArguments());
}
public void ShouldNotRecreatedParsedValue()
{
var args = new [] { "--switch", "value" };
var parser = new OptionsParser();
parser.WithOption<string>("switch");
parser.Parse(args);
Assert.AreEqual(1, parser.ParsedOptions.Count());
Assert.AreEqual(args[1], parser.ParsedOptions.First().Value);
Assert.IsEmpty(parser.RecreateUnparsedArguments());
}
public void ShouldNotParseAfterDoubleHyphen()
{
var args = new [] { "--", "--value", "test" };
var parser = new OptionsParser(new ParserConfiguration { AllowUnexpectedArguments = true });
var options = new OptionsWithInt();
parser.Parse(options, args);
Assert.AreEqual(-1, options.Value);
Assert.AreEqual(0, parser.ParsedOptions.Count());
Assert.AreEqual(2, parser.UnexpectedArguments.Count());
Assert.AreEqual("--value", parser.UnexpectedArguments.ElementAt(0).Value);
Assert.AreEqual("test", parser.UnexpectedArguments.ElementAt(1).Value);
Assert.AreEqual("--value test", parser.RecreateUnparsedArguments());
}
public void ShouldRecreateMixedShortFlag()
{
var args = new [] { "-AwB" };
var parser = new OptionsParser();
parser.WithOption<bool>('A');
parser.WithOption<bool>('B');
parser.Parse(args);
Assert.AreEqual(2, parser.ParsedOptions.Count());
Assert.AreEqual('A', parser.ParsedOptions.First().Flag.ShortName);
Assert.AreEqual('B', parser.ParsedOptions.Last().Flag.ShortName);
Assert.AreEqual("-w", parser.RecreateUnparsedArguments());
}
