public async Task TicTacToe(params string[] args)
{
var(options, _) = OptionsParser.ParseFrom(new TicTacToe.Options(), args);
var channel = (ITextChannel)Context.Channel;
await _sem.WaitAsync(1000).ConfigureAwait(false);
try
{
if (_service.TicTacToeGames.TryGetValue(channel.Id, out TicTacToe game))
{
var _ = Task.Run(async() =>
{
await game.Start((IGuildUser)Context.User).ConfigureAwait(false);
});
return;
}
game = new TicTacToe(base.Strings, this._client, channel, (IGuildUser)Context.User, options);
_service.TicTacToeGames.Add(channel.Id, game);
await ReplyConfirmLocalized("ttt_created").ConfigureAwait(false);
game.OnEnded += (g) =>
{
_service.TicTacToeGames.Remove(channel.Id);
_sem.Dispose();
};
}
finally
{
_sem.Release();
}
}
public async Task InternalTrivia(params string[] args)
{
var channel = (ITextChannel)ctx.Channel;
var(opts, _) = OptionsParser.ParseFrom(new TriviaOptions(), args);
var config = _gamesConfig.Data;
if (config.Trivia.MinimumWinReq > 0 && config.Trivia.MinimumWinReq > opts.WinRequirement)
{
return;
}
var trivia = new TriviaGame(Strings, _client, config, _cache, _cs, channel.Guild, channel, opts, Prefix + "tq");
if (_service.RunningTrivias.TryAdd(channel.Guild.Id, trivia))
{
try
{
await trivia.StartGame().ConfigureAwait(false);
}
finally
{
_service.RunningTrivias.TryRemove(channel.Guild.Id, out trivia);
await trivia.EnsureStopped().ConfigureAwait(false);
}
return;
}
await ctx.Channel.SendErrorAsync(GetText("trivia_already_running") + "\n" + trivia.CurrentQuestion)
.ConfigureAwait(false);
}
public void Parse_TooManyArgsProvided_ReturnsFalse()
{
object output;
var parser = new OptionsParser(typeof(OptionsObjectWith1RequiredStringOption));
Assert.IsFalse(parser.Parse(new string[] { "foo", "bar" }, out output, new CommandLineLogger()));
}
public void When_There_Are_Multiple_Option_Bindings_One_Of_Them_Got_Selected()
{
IOptionsParser parser = new OptionsParser();
var optionsObject = (TestOptions)parser.CreatePopulatedOptionsObject(typeof(TestVerb), new ParsedVerb()
{
VerbName = "TestVerb",
Options = new Dictionary <string, List <string> >()
{
{ "fn", new List <string> {
"tarik"
} },
{ "a", new List <string> {
"33"
} },
{ "im", new List <string> {
"true"
} }
}
});
Assert.NotNull(optionsObject);
Assert.Equal("tarik", optionsObject.Name);
Assert.Equal(33, optionsObject.Age);
Assert.True(optionsObject.Male);
}
public void TestParseOneSwitch()
{
String[] args = { "-switch", "1", "2" };
string[] arr = { "1", "2" };
String[] switches = OptionsParser.Parse(args).GetValueOrDefault("-switch");
CollectionAssert.AreEqual(switches, new String[] { "1", "2" });
}
public async Task WarnExpire(int days, params string[] args)
{
if (days < 0 || days > 366)
{
return;
}
var opts = OptionsParser.ParseFrom <WarnExpireOptions>(args);
await Context.Channel.TriggerTypingAsync().ConfigureAwait(false);
await _service.WarnExpireAsync(ctx.Guild.Id, days, opts.Delete).ConfigureAwait(false);
if (days == 0)
{
await ReplyConfirmLocalizedAsync("warn_expire_reset").ConfigureAwait(false);
return;
}
if (opts.Delete)
{
await ReplyConfirmLocalizedAsync("warn_expire_set_delete", Format.Bold(days.ToString())).ConfigureAwait(false);
}
else
{
await ReplyConfirmLocalizedAsync("warn_expire_set_clear", Format.Bold(days.ToString())).ConfigureAwait(false);
}
}
/// <summary>
/// Creates and attaches behaviors specified on the element declaratively.
/// </summary>
/// <param name="element">The element whose behaviors should be created and attached.</param>
private void AttachBehaviors(Element element)
{
string[] behaviorNames = ((string)element.GetAttribute(Application.BehaviorsAttribute)).Split(",");
int behaviorCount = behaviorNames.Length;
for (int i = 0; i < behaviorCount; i++)
{
string name = behaviorNames[i].Trim();
BehaviorRegistration registration = _registeredBehaviors[name];
Debug.Assert(registration != null, "Unknown behavior '" + name + "'");
if (registration != null)
{
Dictionary <string, object> options = OptionsParser.GetOptions(element, name);
// Use the Application's IoC capabilities to create behaviors.
// This allows satisfying dependencies behaviors have to other services,
// and also allows behaviors to provide or register services into the container.
Behavior behavior = (Behavior)GetObject(registration.BehaviorType);
behavior.Initialize(element, options);
if (registration.ServiceType != null)
{
// Special-case the common case where a behavior represents a single
// service type, and auto-register it.
// In the case where a behavior is registering multiple service types
// (not so common), it can do so manually in its Initialize method.
RegisterObject(registration.ServiceType, behavior);
}
}
}
}
public void ShouldSetSwitchWhenSpecified()
{
var parser = new OptionsParser <SwitchOptions>();
var options = parser.Parse(new[] { "--set" });
Assert.True(options.IsSet);
}
public static int Main(string[] args)
{
var options = new Options();
var parser = new OptionsParser();
if(!parser.Parse(options, args))
{
return 1;
}
if(options.Interactive)
{
return HandleInteractive(options.Directories.ToList(), options.BinariesDirectory, options.OutputDirectory, options.GenerateEntryProject);
}
switch(options.Action)
{
case Operation.GenerateAll:
var configuration = GenerateAllProjects(options.BinariesDirectory, options.GenerateEntryProject, options.Directories);
configuration.Save(options.OutputDirectory);
break;
case Operation.Clean:
Cleaner.Clean(options.OutputDirectory);
break;
case Operation.GenerateSolution:
HandleGenerateSolution(options.MainProject, options.BinariesDirectory, options.AdditionalProjects, options.RobotTests, options.OutputDirectory, options.GenerateEntryProject);
break;
case Operation.Scan:
HandleScan(options.Type, options.Directories);
break;
}
return 0;
}
public void FixedPropertyIsPopulated(params string[] array)
{
var options = OptionsParser.Parse <SampleOptions1>(array);
Assert.Equal(array[0], options.Fixed0);
Assert.Equal(array[1], options.Fixed1);
}
public void OptionPropertyIsPopulatedUsingDefaultName(params string[] array)
{
var options = OptionsParser.Parse <SampleOptions2>(array);
Assert.Equal(array[3], options.Optional1);
Assert.Equal(array[3], options.Optional1);
}
public void When_Options_Name_Differ_They_Are_Ignored_During_Parsing()
{
IOptionsParser parser = new OptionsParser();
var optionsObject = (TestOptions)parser.CreatePopulatedOptionsObject(typeof(TestVerb), new ParsedVerb()
{
VerbName = "TestVerb",
Options = new Dictionary <string, List <string> >()
{
{ "Name", new List <string> {
"tarik"
} },
{ "age", new List <string> {
"33"
} },
{ "ismale", new List <string> {
"true"
} }
}
});
Assert.NotNull(optionsObject);
Assert.Equal("tarik", optionsObject.Name);
Assert.Equal(0, optionsObject.Age);
Assert.True(optionsObject.Male);
}
public void When_All_Options_Are_Alias_They_Are_Parsed()
{
IOptionsParser parser = new OptionsParser();
var optionsObject = (TestOptions)parser.CreatePopulatedOptionsObject(typeof(TestVerb), new ParsedVerb()
{
VerbName = "TestVerb",
Options = new Dictionary <string, List <string> >()
{
{ "n", new List <string> {
"tarik"
} },
{ "a", new List <string> {
"33"
} },
{ "m", new List <string> {
"true"
} }
}
});
Assert.NotNull(optionsObject);
Assert.Equal("tarik", optionsObject.Name);
Assert.Equal(33, optionsObject.Age);
Assert.True(optionsObject.Male);
}
public void ThrowWhenNamedOptionUsedAsSwitchWithFollowingOptions()
{
var parser = new OptionsParser <OptionsWithNamed>();
Assert.Throws <InvalidOptionsException>(
() => parser.Parse(new[] { "--value", "--other", "some-value" }));
}
public void ShouldReturnDefaultValue_WhenCollectionOptionNotSpecified()
{
var parser = new OptionsParser <OptionsWithCollectionWithDefaultValue>();
var options = parser.Parse(new string[0]);
Assert.Equal(new[] { "Default" }, options.Strings);
}
public void ShouldParseStringEnumValue()
{
var parser = new OptionsParser <OptionsWithEnum>();
var options = parser.Parse(new [] { "--enum-value", "One" });
Assert.Equal(DummyEnum.One, options.EnumValue);
}
public void ShouldReturnDefaultValue_WhenOptionNotSpecified()
{
var parser = new OptionsParser <OptionsWithDefaults>();
var options = parser.Parse(new string[0]);
Assert.Equal(DefaultValue, options.Email);
}
public void ShouldReturnDefaultValue_WhenDefaultValueIsOfDerivedType()
{
var parser = new OptionsParser <OptionsWithDerivedDefaultValue>();
var options = parser.Parse(new string[0]);
Assert.Equal(32, options.PropertyA);
}
public void ShouldReturnOptionValue_WhenOptionSpecified()
{
var parser = new OptionsParser <OptionsWithDefaults>();
var options = parser.Parse(new[] { "--email", "some-value" });
Assert.Equal("some-value", options.Email);
}
//TODO: как команде выводить инфу: пусть executor получает или команде передается
public void TryInvoke(params string[] stringParams)
{
if (stringParams.Length == 0)
{
return;
}
var cmdName = stringParams[0];
var args = new string[stringParams.Length - 1];
Array.Copy(stringParams, 1, args, 0, args.Length);
if (commands.ContainsKey(cmdName))
{
var cmd = commands[cmdName];
cmd.SentOut = (str) =>
{
if (_outIO == Console.Out)
{
Console.ForegroundColor = ConsoleColor.Green;
}
_outIO.WriteLine(str);
if (_outIO == Console.Out)
{
Console.ForegroundColor = ConsoleColor.Gray;
}
};
var opts = OptionsParser.Parse(args, cmd.GetPossibleOptions(args));
Task.Run(() => cmd.Invoke(opts));
}
}
public void VerifyOptionsFromResponseFileMultiLine()
{
using (var tempFile = TempFile.CreateRandom())
{
using (var writer = new StreamWriter(tempFile.Path))
{
writer.WriteLine("--char-value=1");
writer.WriteLine("--byte-value=2");
writer.WriteLine("--s-byte-value=3");
writer.WriteLine("--short-value=4");
writer.WriteLine("--u-short-value=5");
writer.WriteLine("--int-value=6");
writer.WriteLine("--u-int-value=7");
writer.WriteLine("--long-value=8");
writer.WriteLine("--u-long-value=9");
writer.WriteLine("--float-value=10.42");
writer.WriteLine("--double-value=11.33");
writer.WriteLine("--bool-value");
writer.WriteLine("--string-value-with-spaces=\"value with spaces\"");
writer.WriteLine("--string-value-no-spaces=valuewithoutspaces");
}
var commandLine = new[]
{
$"@\"{tempFile.Path}\""
};
BasicTypesOptions.SetupDefaults();
var types = new[] { typeof(BasicTypesOptions) };
OptionsParser.Prepare(commandLine, types);
VerifyResponseFileOptions();
}
}
public void ShouldSetValueWhenSpecified()
{
var parser = new OptionsParser <EnumSwitchOptions>();
var options = parser.Parse(new[] { "--set-enum" });
Assert.Equal(DummyEnum.One, options.SwitchValue);
}
public void ShouldHaveDefaultValueWhenSwitchNotSpecified()
{
var parser = new OptionsParser <SwitchOptions>();
var options = parser.Parse(new string[0]);
Assert.False(options.IsSet);
}
public void ReturnOptionsWhenValuesAreValid()
{
var parser = new OptionsParser <ValidatedOptions>();
var options = parser.Parse(new[] { "--email", "some-value" });
Assert.NotNull(options);
}
public void PopulateGeostationary()
{
var options = new GeostationaryOptions
{
HazeAmount = 0.5f,
Longitude = 147,
Tint = "ff0000",
SpatialResolution = Constants.Satellite.SpatialResolution.TwoKm,
InterpolationType = InterpolationOptions.N,
Force = false,
Verbose = false,
Quiet = true
};
var renderOptions = OptionsParser.Populate(options);
Assert.NotNull(renderOptions.GeostationaryRender);
renderOptions.GeostationaryRender.Longitude.Should().Be(147);
renderOptions.GeostationaryRender.HazeAmount.Should().Be(0.5f);
renderOptions.InterpolationType.Should().Be(InterpolationType.NearestNeighbour);
renderOptions.ImageSize.Should().Be(Constants.Satellite.ImageSize.TwoKm);
renderOptions.ImageOffset.Should().Be(Constants.Satellite.Offset.TwoKm);
renderOptions.Force.Should().BeFalse();
renderOptions.Verbose.Should().BeFalse();
renderOptions.Quiet.Should().BeTrue();
}
public void PopulateEquirectangular()
{
var options = new EquirectangularOptions
{
AutoCrop = true,
Tint = "ff0000",
SpatialResolution = Constants.Satellite.SpatialResolution.FourKm,
InterpolationType = InterpolationOptions.B,
IntervalMinutes = 30,
Brightness = 1.2f,
Saturation = 0.5f,
Force = true,
Verbose = true
};
var renderOptions = OptionsParser.Populate(options);
Assert.NotNull(renderOptions.EquirectangularRender);
renderOptions.EquirectangularRender.AutoCrop.Should().BeTrue();
renderOptions.SpatialResolution.Should().Be(Constants.Satellite.SpatialResolution.FourKm);
renderOptions.Tint.Should().Be(Color.FromRgb(255, 0, 0));
renderOptions.InterpolationType.Should().Be(InterpolationType.Bilinear);
renderOptions.ImageSize.Should().Be(Constants.Satellite.ImageSize.FourKm);
renderOptions.ImageOffset.Should().Be(Constants.Satellite.Offset.FourKm);
renderOptions.Interval.Should().Be(TimeSpan.FromMinutes(30));
renderOptions.Brightness.Should().Be(1.2f);
renderOptions.Saturation.Should().Be(0.5f);
renderOptions.Force.Should().BeTrue();
renderOptions.Verbose.Should().BeTrue();
}
public void ShouldThrowWhenBase64ValueInvalid()
{
var parser = new OptionsParser <Base64ByteArrayOptions>();
Assert.Throws <InvalidOptionsException>(
() => parser.Parse(new[] { "--bytes", "something%definitely$not;valid" }));
}
public void ShouldThrowWhenHexValueInvalid()
{
var parser = new OptionsParser <HexByteArrayOptions>();
Assert.Throws <InvalidOptionsException>(
() => parser.Parse(new[] { "--bytes", "486" }));
}
public void CreateOptionsIncorrectParams()
{
var cmdLine = new[] { "-p", TestConfig.TestPodcastName, "-o", TestConfig.TestOutputPath };
var result = OptionsParser.GetOptions(cmdLine);
result.DownloadOptions.Should().BeNull();
}
public void Parse_NullArgs_ThrowsArgumentNullException()
{
object output;
var parser = new OptionsParser(typeof(OptionsObjectWith1RequiredStringOption));
parser.Parse(null, out output, new CommandLineLogger());
}
public void CreateOptionsAndSave()
{
var cmdLine = new[] { DownloadOptions.PodcastVerb, "-p", TestConfig.TestPodcastName, "-o", TestConfig.TestOutputPath, "save" };
var result = OptionsParser.GetOptions(cmdLine);
result.DownloadOptions.Should().NotBeNull();
}
public static int Main(string[] args)
{
var options = new Options();
var parser = new OptionsParser();
if(!parser.Parse(options, args))
{
return 1;
}
if(options.Interactive)
{
return HandleInteractive(options.Directories.ToList());
}
switch(options.Action)
{
case Operation.GenerateAll:
GenerateAllProjects(options.Directories).Save(solutionName);
break;
case Operation.Clean:
Cleaner.Clean(options.MainProject);
break;
case Operation.GenerateSolution:
HandleGenerateSolution(options.MainProject, options.AdditionalProjects, options.Output);
break;
case Operation.Scan:
HandleScan(options.Type, options.Directories);
break;
}
return 0;
}
public void ShouldParseNumericEnumValue()
{
var parser = new OptionsParser <OptionsWithEnum>();
var options = parser.Parse(new[] { "--enum-value", "2" });
Assert.Equal(DummyEnum.Two, options.EnumValue);
}
public void ShouldThrowWhenNumericValueInvalid()
{
var parser = new OptionsParser <OptionsWithEnum>();
Assert.Throws <InvalidOptionsException>(
() => parser.Parse(new[] { "--enum-value", "55" }));
}
public void ShouldSetDefaultValueWhenParameterIsNotFound()
{
var args = new string[0];
var parser = new OptionsParser();
var options = new OptionsWithParameterWithDefaultValue();
parser.Parse(options, args);
Assert.AreEqual(0, parser.ParsedOptions.Count());
Assert.AreEqual(147, options.NumericParameter);
}
public void ShouldDetectLongSwitch()
{
var args = new [] { "--long" };
var parser = new OptionsParser();
parser.WithOption<bool>("long");
parser.Parse(args);
Assert.AreEqual(1, parser.ParsedOptions.Count());
Assert.AreEqual("long", parser.ParsedOptions.First().Flag.LongName);
}
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 ShouldDetectedUnexpectedShortSwitchWithValue()
{
var args = new [] { "-cx", "value with whitespace" };
var parser = new OptionsParser();
parser.WithOption<bool>('c');
parser.Parse(args);
Assert.AreEqual(1, parser.ParsedOptions.Count());
Assert.AreEqual('c', parser.ParsedOptions.First().Flag.ShortName);
Assert.AreEqual(2, parser.UnexpectedArguments.Count());
Assert.AreEqual("x", parser.UnexpectedArguments.ElementAt(0).Value);
Assert.AreEqual("value with whitespace", parser.UnexpectedArguments.ElementAt(1).Value);
}
public void ShouldThrowExceptionWhenRequiredParamterIsNotFound()
{
var args = new string[0];
var parser = new OptionsParser(new ParserConfiguration { ThrowValidationException = true });
var options = new OptionsWithRequiredParameter();
try
{
parser.Parse(options, args);
Assert.Fail("Expected exception");
}
catch (ValidationException)
{
// intentionally left blank
}
}
public void ShouldThrowAnExceptionWhenDefaultValueIsOfAWrongType()
{
var args = new [] { "--arg" };
var parser = new OptionsParser();
var options = new OptionsWithDefault();
try
{
parser.Parse(options, args);
Assert.Fail("Expected exception");
}
catch(ArgumentException e)
{
Assert.IsTrue(e.Message.Contains("is of unexpected type"));
}
}
public void ShouldCallCustomValidator()
{
var args = new [] { "--stringValue=foo", "-n1" };
var parser = new OptionsParser(new ParserConfiguration { ThrowValidationException = true });
var options = new OptionsWithCustomValidator();
try
{
parser.Parse(options, args);
Assert.Fail("Expected exception");
}
catch (ValidationException)
{
Assert.AreEqual(1, options.NumericValue);
Assert.AreEqual("foo", options.StringValue);
}
}
public PythonObject(string[] args)
{
ScriptRuntimeSetup runtimeSetup = ScriptRuntimeSetup.ReadConfiguration();
ConsoleHostOptions options = new ConsoleHostOptions();
_optionsParser = new ConsoleHostOptionsParser(options, runtimeSetup);
string provider = GetLanguageProvider(runtimeSetup);
LanguageSetup languageSetup = null;
foreach (LanguageSetup language in runtimeSetup.LanguageSetups) {
if (language.TypeName == provider) {
languageSetup = language;
}
}
if (languageSetup == null) {
// the language doesn't have a setup -> create a default one:
languageSetup = new LanguageSetup(Provider.AssemblyQualifiedName, Provider.Name);
runtimeSetup.LanguageSetups.Add(languageSetup);
}
// inserts search paths for all languages (/paths option):
InsertSearchPaths(runtimeSetup.Options, Options.SourceUnitSearchPaths);
_languageOptionsParser = new OptionsParser<ConsoleOptions>();
try {
_languageOptionsParser.Parse(Options.IgnoredArgs.ToArray(), runtimeSetup, languageSetup, PlatformAdaptationLayer.Default);
} catch (InvalidOptionException e) {
Console.Error.WriteLine(e.Message);
}
_runtime = new ScriptRuntime(runtimeSetup);
try {
_engine = _runtime.GetEngineByTypeName(provider);
} catch (Exception e) {
Console.Error.WriteLine(e.Message);
}
_runtime.LoadAssembly(System.Reflection.Assembly.GetExecutingAssembly());
_runtime.LoadAssembly(provider.GetType().Assembly);
_runtime.LoadAssembly(PythonStringIO.StringIO().GetType().Assembly);
_scope= _engine.CreateScope();
RunCommandLine(args);
}
public void GenerateSwitches(OptionsParser optionsParser, bool defaultOption = false)
{
// here we assume that all descriptors from `descriptors` array
// have the same basic attributes (name, description, switches, etc.)
// they should differ only in configuration and path
SwitchOption = optionsParser.WithOption<bool>(descriptors[0].ShortSwitch ?? Tokenizer.NullCharacter, descriptors[0].LongSwitch);
SwitchOption.Description = descriptors[0].Description;
if(defaultOption)
{
SwitchOption.Description += " (default)";
}
if(descriptors[0].ProvidesHelp)
{
HelpOption = optionsParser.WithOption<bool>(string.Format("help-{0}", descriptors[0].LongSwitch));
HelpOption.Description = string.Format("Show help for {0}", descriptors[0].Name);
}
}
public static void Main(string[] args)
{
CommandLineLogger logger = new CommandLineLogger();
Dictionary<string, Type> commands = typeof(ICommand).Assembly
.GetTypes()
.Where(x => x.GetInterfaces().Contains(typeof(ICommand)))
.ToDictionary(x => x.Name.Substring(0, x.Name.Length - "Command".Length));
if (args.Length > 0)
{
if (commands.ContainsKey(args[0]))
{
ICommand command = CreateCommandInstance(commands[args[0]]);
OptionsParser optionsParser = new OptionsParser(command.OptionsType);
object options;
var commandArgs = args.Skip(1).Take(args.Length - 1).ToArray();
if (optionsParser.Parse(commandArgs, out options, logger) &&
command.EnsureOptions(options, logger))
{
command.Execute(options, logger);
}
}
else
{
Console.Error.WriteLine("ERROR: Unknown command \"{0}\".", args[0]);
Console.Error.WriteLine();
ListCommands(commands);
}
}
else
{
Console.Error.WriteLine("ERROR: Please prvoide a command to execute.");
Console.Error.WriteLine();
ListCommands(commands);
}
}
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 static void Run(string[] args)
{
var options = new Options();
var optionsParser = new OptionsParser();
if(!optionsParser.Parse(options, args))
{
return;
}
using(var context = ObjectCreator.OpenContext())
{
var monitor = new Emul8.UserInterface.Monitor();
context.RegisterSurrogate(typeof(Emul8.UserInterface.Monitor), monitor);
// we must initialize plugins AFTER registering monitor surrogate
// as some plugins might need it for construction
TypeManager.Instance.PluginManager.Init("CLI");
Logger.AddBackend(ConsoleBackend.Instance, "console");
EmulationManager.Instance.ProgressMonitor.Handler = new CLIProgressMonitor();
var crashHandler = new CrashHandler();
AppDomain.CurrentDomain.UnhandledException += (sender, e) => crashHandler.HandleCrash(e);
var resetEvent = new ManualResetEventSlim();
if(options.StdInOut)
{
Logger.AddBackend(new FileBackend("logger.log"), "file");
var world = new StreamIOSource(Console.OpenStandardInput(), Console.OpenStandardOutput());
var io = new DetachableIO(world);
monitor.Quitted += resetEvent.Set;
var handler = new StdInOutHandler(io, monitor, options.Plain);
handler.Start();
}
else
{
Shell shell = null;
Type preferredUARTAnalyzer = null;
if(options.Port > 0)
{
var io = new DetachableIO(new SocketIOSource(options.Port));
shell = ShellProvider.GenerateShell(io, monitor, true, false);
shell.Quitted += resetEvent.Set;
}
else if(options.ConsoleMode)
{
preferredUARTAnalyzer = typeof(UARTMultiplexedBackendAnalyzer);
var stream = new PtyUnixStream("/proc/self/fd/1");
var world = new StreamIOSource(stream, stream.Name);
Logger.AddBackend(new FileBackend("logger.log"), "file");
var consoleTerm = new ConsoleTerminal(world);
UARTMultiplexedBackendAnalyzer.Multiplexer = consoleTerm;
monitor.Console = consoleTerm;
shell = ShellProvider.GenerateShell(monitor);
consoleTerm.AttachTerminal("shell", shell.Terminal);
shell.Quitted += resetEvent.Set;
}
else
{
preferredUARTAnalyzer = typeof(UARTWindowBackendAnalyzer);
var stream = new PtyUnixStream();
var dio = new DetachableIO(new StreamIOSource(stream, stream.Name));
var terminal = new UARTWindowBackendAnalyzer(dio);
shell = ShellProvider.GenerateShell(dio, monitor);
shell.Quitted += resetEvent.Set;
monitor.Quitted += shell.Stop;
try
{
terminal.Show();
}
catch(InvalidOperationException ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine(ex.Message);
resetEvent.Set();
}
}
if(preferredUARTAnalyzer != null)
{
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), preferredUARTAnalyzer);
EmulationManager.Instance.EmulationChanged += () =>
{
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), preferredUARTAnalyzer);
};
}
monitor.Interaction = shell.Writer;
monitor.UseConsole = options.ConsoleMode;
monitor.MachineChanged += emu => shell.SetPrompt(emu != null ? new Prompt(string.Format("({0}) ", emu), ConsoleColor.DarkYellow) : null);
if(options.Execute != null)
{
shell.Started += s => s.InjectInput(string.Format("{0}\n", options.Execute));
}
else if(!string.IsNullOrEmpty(options.ScriptPath))
{
shell.Started += s => s.InjectInput(string.Format("i $CWD/{0}\n", options.ScriptPath));
}
new Thread(x => shell.Start(true)) { IsBackground = true, Name = "Shell thread" }.Start();
}
resetEvent.Wait();
EmulationManager.Instance.Clear();
TypeManager.Instance.Dispose();
Logger.Dispose();
}
}
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 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 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());
}
/// <summary>
/// Writes the list of valid command line arguments.
/// </summary>
private static void WriteUsage()
{
//
// Define table
//
var options = new OptionsParser<CommandLineOptions>().GetOptions();
//
// Setup layout
//
int[] columnLengths = new int[] { 25, 10, 45 };
//
// Write headings
//
Console.Write("Argument" + new string(' ', columnLengths[0] - "Argument".Length));
Console.Write("Required" + new string(' ', columnLengths[1] - "Required".Length));
Console.Write("Description" + new string(' ', columnLengths[2] - "Description".Length));
Console.Write(new string('=', Console.WindowWidth));
//
// Write table
//
foreach (var option in options.OrderByDescending(o => o.IsRequired).ThenBy(o => o.Name))
{
string[] row = new string[]
{
option.Name,
option.IsRequired ? "Y" : "N",
option.Description
};
for (int i = 0; i < row.Length; i++)
{
//
// Write max width columns
//
while (row[i].Length > columnLengths[i])
{
int x = Console.CursorLeft;
Console.Write(row[i].Substring(0, columnLengths[i]));
row[i] = row[i].Substring(columnLengths[i]);
Console.CursorLeft = x;
}
//
// Write remainder
//
Console.Write(row[i]);
Console.Write(new string(' ', columnLengths[i] - row[i].Length));
}
Console.WriteLine();
}
}
/// <summary>
/// The program's entry point.
/// </summary>
/// <param name="args">The command line arguments.</param>
public static void Main(string[] args)
{
//
// Catch unhandled exceptions and terminate decently
//
AppDomain.CurrentDomain.UnhandledException += delegate(object sender, UnhandledExceptionEventArgs e)
{
Exception ex = e.ExceptionObject as Exception;
Console.WriteLine(ex.Message);
Environment.Exit(-1);
};
//
// Read command line arguments
//
CommandLineOptions arguments = null;
try
{
arguments = new OptionsParser<CommandLineOptions>().Parse(args);
}
catch (FormatException)
{
WriteInformation();
WriteUsage();
Environment.Exit(-1);
}
//
// Print information
//
if (!arguments.Silent)
{
WriteInformation();
}
//
// Get assemblies that containt the migrations
//
var assemblies = LoadAssemblies(arguments.Assemblies);
//
// Prepare the engine
//
var engine = new Engine();
engine.SetConnectionString(arguments.ProviderInvariantName, arguments.ConnectionString);
foreach (var assembly in assemblies)
{
engine.AddAssembly(assembly);
}
if (arguments.WhatIf)
{
engine.SetSqlProcessor(new WhatIfSqlProcessor());
engine.SetMigrationHistoryRepository(new WhatIfMigrationHistoryRepository());
}
//
// Set event handlers for status output
//
engine.BeforeMigration += delegate(object sender, BeforeMigrationEventArgs e)
{
if (!arguments.Silent)
{
Console.WriteLine("{0} {1}...", e.Version, (e.Direction == MigrationDirection.Up ? "UP" : "DOWN"));
}
};
engine.BeforeSql += delegate(object sender, BeforeSqlEventArgs e)
{
Console.WriteLine(e.Sql);
if (arguments.Confirm)
{
Console.Write("Do you want to execute this SQL statement (Y/N) ");
e.Cancel = (char.ToLowerInvariant(Console.ReadKey().KeyChar) == 'n');
Console.WriteLine();
}
};
engine.AfterMigration += delegate(object sender, AfterMigrationEventArgs e)
{
if (!arguments.Silent || !e.Success)
{
Console.WriteLine();
Console.WriteLine("Migration finished succcessful: {0}", e.Success);
Console.WriteLine(new string('=', Console.WindowWidth));
Console.WriteLine();
}
};
//
// Run migrations
//
if (arguments.Version == null)
{
engine.Migrate();
}
else
{
engine.Migrate(arguments.Version.Value);
}
}
public void ShouldThrowAnExceptionForShortOptionRequiringValueWhenThereIsNone()
{
var args = new [] { "-n" };
var parser = new OptionsParser(new ParserConfiguration { ThrowValidationException = true });
parser.WithOption<int>('n');
try
{
parser.Parse(args);
Assert.Fail("Should throw an exception");
}
catch (ValidationException e)
{
Assert.IsTrue(e.Message.Contains("requires parameter of type"));
}
}
public void ShouldSetShortSwitchInClass()
{
var args = new [] { "-s" };
var options = new OptionsWithBool();
var parser = new OptionsParser();
parser.Parse(options, args);
Assert.AreEqual(1, parser.ParsedOptions.Count());
Assert.AreEqual(options.Switch, true);
}
public void ShoulNotParseOnMissingRequiredPositionalValues()
{
var args = new string [0];
var parser = new OptionsParser();
var options = new OptionsWithRequiredPositionalValues();
Assert.AreEqual(false, parser.Parse(options, args));
}
public void ShouldThrowAnExceptionOnUnexpectedMultipleOccurencesOfArgument()
{
var args = new[] { "--value", "5", "--value", "6" };
var parser = new OptionsParser(new ParserConfiguration { ThrowValidationException = true });
var options = new OptionsWithInt();
parser.Parse(options, args);
}
public void ShouldDetectOptionHavingBothShortAndLongName()
{
var argsShort = new [] { "-l" };
var argsLong = new [] { "--long" };
foreach(var args in new [] { argsShort, argsLong })
{
var parser = new OptionsParser();
parser.WithOption<bool>('l', "long");
parser.Parse(args);
Assert.AreEqual(1, parser.ParsedOptions.Count());
var flag = parser.ParsedOptions.First().Flag;
Assert.AreEqual('l', flag.ShortName);
Assert.AreEqual("long", flag.LongName);
}
}
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();
}
protected virtual int RunCommandLine(OptionsParser optionsParser)
{
Contract.RequiresNotNull(optionsParser, "optionsParser");
CommandLine command_line;
ConsoleOptions console_options;
EngineOptions engine_options;
console_options = optionsParser.ConsoleOptions;
engine_options = optionsParser.EngineOptions;
command_line = _options.LanguageProvider.GetCommandLine();
IScriptEngine engine = _options.LanguageProvider.GetEngine(engine_options);
if (console_options.PrintVersionAndExit) {
Console.WriteLine(engine.VersionString);
return 0;
}
if (console_options.PrintUsageAndExit) {
if (optionsParser != null) {
PrintLanguageHelp(_options.LanguageProvider, Console.Out);
}
return 0;
}
engine.SetSourceUnitSearchPaths(_options.SourceUnitSearchPaths);
IConsole console = _options.LanguageProvider.GetConsole(command_line, engine, console_options);
console_options.RemainingArgs = _options.IgnoredArgs.ToArray();
int result;
if (console_options.HandleExceptions) {
try {
result = command_line.Run(engine, console, console_options);
} catch (Exception e) {
UnhandledException(engine, e);
result = 1;
}
ScriptEngine se = engine as ScriptEngine;
if (se != null) {
try {
se.DumpDebugInfo();
} catch {
result = 1;
}
}
return result;
} else {
try {
return command_line.Run(engine, console, console_options);
} finally {
ScriptEngine se = engine as ScriptEngine;
if (se != null) {
se.DumpDebugInfo();
}
}
}
}
private int RunFiles(OptionsParser optionsParser)
{
EngineOptions engine_options = (optionsParser != null) ? optionsParser.EngineOptions : null;
IScriptEngine engine = _options.LanguageProvider.GetEngine(engine_options);
engine.SetSourceUnitSearchPaths(_options.SourceUnitSearchPaths);
int result = 0;
foreach (string filePath in _options.Files) {
SourceUnit sourceUnit = ScriptDomainManager.CurrentManager.Host.TryGetSourceFileUnit(engine, filePath, Encoding.Default);
if (sourceUnit == null) {
throw new FileNotFoundException(string.Format("Source file '{0}' not found.", filePath));
}
result = RunFile(engine, sourceUnit);
}
return result;
}
public static void Run(string[] args)
{
var options = new Options();
var optionsParser = new OptionsParser();
if(!optionsParser.Parse(options, args))
{
return;
}
Plugins.XwtProviderPlugin.XwtProvider.StartXwtThread();
using(var context = ObjectCreator.Instance.OpenContext())
{
var monitor = new Emul8.UserInterface.Monitor();
context.RegisterSurrogate(typeof(Emul8.UserInterface.Monitor), monitor);
// we must initialize plugins AFTER registering monitor surrogate
// as some plugins might need it for construction
TypeManager.Instance.PluginManager.Init("CLI");
Logger.AddBackend(ConsoleBackend.Instance, "console");
EmulationManager.Instance.ProgressMonitor.Handler = new CLIProgressMonitor();
var crashHandler = new CrashHandler();
AppDomain.CurrentDomain.UnhandledException += (sender, e) => crashHandler.HandleCrash(e);
Shell shell = null;
Type preferredUARTAnalyzer = null;
if(options.Port > 0)
{
var io = new IOProvider(new SocketIOSource(options.Port));
shell = ShellProvider.GenerateShell(io, monitor, true, false);
}
else
{
preferredUARTAnalyzer = typeof(UARTWindowBackendAnalyzer);
var terminal = new UARTWindowBackendAnalyzer();
shell = ShellProvider.GenerateShell(terminal.IO, monitor);
monitor.Quitted += shell.Stop;
try
{
terminal.Show();
}
catch(InvalidOperationException ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine(ex.Message);
Emulator.Exit();
}
}
shell.Quitted += Emulator.Exit;
if(preferredUARTAnalyzer != null)
{
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), preferredUARTAnalyzer);
EmulationManager.Instance.EmulationChanged += () =>
{
EmulationManager.Instance.CurrentEmulation.BackendManager.SetPreferredAnalyzer(typeof(UARTBackend), preferredUARTAnalyzer);
};
}
monitor.Interaction = shell.Writer;
monitor.MachineChanged += emu => shell.SetPrompt(emu != null ? new Prompt(string.Format("({0}) ", emu), ConsoleColor.DarkYellow) : null);
if(options.Execute != null)
{
shell.Started += s => s.InjectInput(string.Format("{0}\n", options.Execute));
}
else if(!string.IsNullOrEmpty(options.ScriptPath))
{
shell.Started += s => s.InjectInput(string.Format("i {0}{1}\n", Path.IsPathRooted(options.ScriptPath) ? "@" : "$CWD/", options.ScriptPath));
}
new Thread(x => shell.Start(true))
{
IsBackground = true,
Name = "Shell thread"
}.Start();
Emulator.BeforeExit += () =>
{
Emulator.DisposeAll();
};
Emulator.WaitForExit();
Plugins.XwtProviderPlugin.XwtProvider.StopXwtThread();
}
}
