private static void ArgumentParsingComplete(ParsedArguments arguments) { if (arguments.Contains("i")) { interactive = true; } }
private ParsedArguments GetSwitchDictionary( string[] args) { var result = new ParsedArguments(); int indexOfSwitch = 0; while (indexOfSwitch < args.Length) { var switchArg = args[indexOfSwitch]; var switchType = CommandlineSwitchType.GetTypeForCommandLineSwitch(switchArg); var indexOfSwitchValue = indexOfSwitch + 1; if (WeHaveMatchingCommandLineSwitch(switchType) && ArgsIsLargeEnoughtToSupportSwitchValue(args, indexOfSwitchValue)) { var switchValue = args[indexOfSwitchValue]; result.SetValue(switchType, switchValue); } indexOfSwitch += 2; } return result; }
public void TestNoUpdateKeys() { ParsedArguments args = ArgumentParser.Parse(new string[] { "Stardew Valley", "TestMod", "-u", "" }); Assert.AreEqual(1, args.ModUpdateKeys.Count()); Assert.AreEqual("", args.ModUpdateKeys.ElementAt(0)); }
/// <summary> /// Returns this <see cref="ParsedArguments"/> in a human readable format. /// </summary> /// <param name="detailed">True if the output should be detailed.</param> /// <returns>A <see cref="string"/>.</returns> public string ToString(bool detailed) { StringBuilder returnValue = new StringBuilder(); ArgumentDictionary invalidArguments = ParsedArguments.GetInvalidArguments(); ArgumentDictionary validArguments = ParsedArguments.GetValidArguments(); if (validArguments.Count > 0) { returnValue.AppendLine("Valid Arguments:"); returnValue.AppendLine(); foreach (Argument validArgument in validArguments.Values) { returnValue.AppendLine(" " + validArgument.ToString(detailed)); } } if (invalidArguments.Count > 0) { returnValue.AppendLine(); returnValue.AppendLine("Invalid Arguments:"); returnValue.AppendLine(); foreach (Argument invalidArgument in invalidArguments.Values) { returnValue.AppendLine(" " + invalidArgument.ToString(detailed)); } } return(returnValue.ToString()); }
private ParsedArguments GetSwitchDictionary( string[] args) { var result = new ParsedArguments(); int indexOfSwitch = 0; while (indexOfSwitch < args.Length) { var switchArg = args[indexOfSwitch]; var switchType = CommandlineSwitchType.GetTypeForCommandLineSwitch(switchArg); var indexOfSwitchValue = indexOfSwitch + 1; if (WeHaveMatchingCommandLineSwitch(switchType) && ArgsIsLargeEnoughtToSupportSwitchValue(args, indexOfSwitchValue)) { var switchValue = args[indexOfSwitchValue]; result.SetValue(switchType, switchValue); } indexOfSwitch += 2; } return(result); }
public static void Main(string[] args) { try { var parsedArguments = new ParsedArguments(args); var stopwatch = new System.Diagnostics.Stopwatch(); stopwatch.Start(); string transcodedFilePath = Path.ChangeExtension(parsedArguments.inputFilePath, ".Transcoded.fit"); string finalOriginalPath = Path.ChangeExtension(parsedArguments.inputFilePath, ".Original.fit"); TranscodeFile(parsedArguments.inputFilePath, transcodedFilePath, parsedArguments.resultantSport); stopwatch.Stop(); Console.WriteLine(""); Console.WriteLine("Time elapsed: {0:0.#}s", stopwatch.Elapsed.TotalSeconds); Console.WriteLine("Transcode successful. Moving files.."); File.Move(parsedArguments.inputFilePath, finalOriginalPath); Console.WriteLine("Moved original to {0}.", finalOriginalPath); File.Move(transcodedFilePath, parsedArguments.inputFilePath); Console.WriteLine("Moved transcoded to {0}.", parsedArguments.inputFilePath); Console.WriteLine("Done."); } catch (Exception caught) { Console.WriteLine("Execution failed with exception:\n{0}", caught.ToString()); } Console.Write("Press any key to continue . . . "); Console.ReadKey(true); }
public MainWindow() { var parsedArguments = new ParsedArguments(new string[] { }); var server = new Server(parsedArguments); _server = server; server.TempAddSink(new GraphDataSink(this)); server.Run(); InitializeComponent(); var plt = TheGraph.plt; Random rand = new Random(0); int pointCount = (int)1e6; int lineCount = 5; plt.Title("Signal Plot Quickstart (5 million points)"); plt.YLabel("Vertical Units"); plt.XLabel("Horizontal Units"); plt.Resize(); TheGraph.Render(); }
public void TestMultipleUpdateKeys() { ParsedArguments args = ArgumentParser.Parse(new string[] { "Stardew Valley", "TestMod", "-u", "Nexus:1234,Nexus:4321" }); Assert.AreEqual(2, args.ModUpdateKeys.Count()); Assert.AreEqual("Nexus:1234", args.ModUpdateKeys.ElementAt(0)); Assert.AreEqual("Nexus:4321", args.ModUpdateKeys.ElementAt(1)); }
public void HasUndoScriptFileShouldReturnTrueWhenUndoScriptFilePopulated() { var parsedArguments = new ParsedArguments(); parsedArguments.SetValue(CommandlineSwitchType.UndoFile, "sdf"); Assert.That(parsedArguments.HasValue(CommandlineSwitchType.UndoFile), Is.True); }
public void GetScriptsFilesFolderShouldReturnDefaultWhenScriptFilesFolderIsNotSet() { var parsedArguments = new ParsedArguments(); var r = parsedArguments.GetScriptFilesFolderOrDefaultFolder(); Assert.That(r, Is.EqualTo(ParsedArguments.ScriptFilesFolderDefault)); }
private IViolationReporter CreateViolationReporter(ParsedArguments arguments) { if (arguments.ReportOutputFile != null) { return(_violationReporterFactory.CreateFileReporter(arguments.ReportFormat, arguments.ReportOutputFile)); } return(_violationReporterFactory.CreateConsoleReporter(arguments.ReportFormat)); }
private ParsedArguments GetResultsForArgs( string[] args) { var parser = new CommandLineArgumentsParser(); ParsedArguments result = parser.ParseArgs(args); return(result); }
/// <summary> /// Execute any ArgZero arguments specified on the command line. Has no effect if no relevant arguments /// are detected. /// </summary> public static void ExecuteArgZero(string[] arguments, Action onArgZeroExecuted = null) { if (arguments.Length == 0) { return; } if (Environment.GetCommandLineArgs().Any(a => a.Equals("/pause"))) { Pause("Press enter to continue"); } onArgZeroExecuted ??= (() => { }); if (Targets.ContainsKey(arguments[0])) { List <string> targetArguments = new List <string>(); List <ArgumentInfo> argumentInfos = new List <ArgumentInfo>(); arguments.Rest(2, (val) => { targetArguments.Add(val); if (val.StartsWith("/")) { string argName = val.TruncateFront(1).ReadUntil(':', out string argVal); argumentInfos.Add(new ArgumentInfo(argName, true)); } }); Arguments = new ParsedArguments(targetArguments.ToArray(), argumentInfos.ToArray()); MethodInfo method = Targets[arguments[0]]; if (method.HasCustomAttributeOfType <ArgZeroAttribute>(out ArgZeroAttribute argZeroAttribute)) { if (argZeroAttribute.BaseType != null) { RegisterArgZeroProviderTypes(argZeroAttribute.BaseType, arguments, argZeroAttribute.BaseType.Assembly); } } object instance = null; if (!method.IsStatic) { instance = method.DeclaringType.Construct(); } try { ArgZeroDelegator.CommandLineArguments = arguments; method.Invoke(instance, null); } catch (Exception ex) { Message.PrintLine("Exception executing ArgZero: {0}", ConsoleColor.Magenta, ex.Message); } onArgZeroExecuted(); } }
public void TestOptionsDontAffectEachOther() { ParsedArguments args = ArgumentParser.Parse(new string[] { "Stardew Valley", "TestMod", "-a", "John Doe" }); Assert.AreEqual("John Doe", args.AuthorName); Assert.AreEqual("", args.ModName); Assert.AreEqual("1.0.0", args.ModVersion); Assert.AreEqual("", args.ModDescription); Assert.AreEqual("", args.ModUpdateKeys); }
public void GetScriptsFilesFolderShouldReturnScriptFolderWhenScriptFolderPopulated() { var parsedArguments = new ParsedArguments(); parsedArguments.SetValue(CommandlineSwitchType.ScriptFiles, "c:\\foo"); var r = parsedArguments.GetScriptFilesFolderOrDefaultFolder(); Assert.That(r, Is.EqualTo("c:\\foo")); }
public TextWriter GetDoPrintStream( ParsedArguments p) { if (p.HasValue(CommandlineSwitchType.DoFile)) { return(new StreamWriter(p.GetValue(CommandlineSwitchType.DoFile))); } return(Console.Out); }
public void GetAll_Named_Empty() { var target = new ParsedArguments(new[] { new ParsedNamedArgument("a", "1"), new ParsedNamedArgument("a", "2") }); var result = target.GetAll("XXX").ToList(); result.Count.Should().Be(0); }
public void GetDoPrintStreamShouldReturnConsoleWhenNotGivenFinalScriptFile() { var printScreenFactory = new PrintScreenFactory(); var parsedArguments = new ParsedArguments(); TextWriter results = printScreenFactory.GetDoPrintStream(parsedArguments); Assert.That(results, Is.EqualTo(System.Console.Out)); printScreenFactory.ClosePrintStream(results); }
public void VerifyAllAreConsumed_NotConsumed() { var target = new ParsedArguments(new IParsedArgument[] { new ParsedPositionalArgument("test1"), new ParsedNamedArgument("b", "test2"), new ParsedFlagArgument("c") }); Action act = () => target.VerifyAllAreConsumed(); act.Should().Throw <CommandArgumentException>(); }
private IEnumerable <string> ArgsToForwardToRestore() { var restoreArguments = ParsedArguments.Where(a => !a.StartsWith("/p:TargetFramework")); if (!restoreArguments.Any(a => a.StartsWith("/verbosity:"))) { restoreArguments = restoreArguments.Concat(new string[] { "/verbosity:q" }); } return(restoreArguments.Concat(TrailingArguments)); }
public void Shift_Test() { var target = new ParsedArguments(new[] { new ParsedPositionalArgument("a"), new ParsedPositionalArgument("b") }); target.Shift().Value.Should().Be("a"); target.Shift().Value.Should().Be("b"); target.Shift().Should().BeOfType <MissingArgument>(); }
internal string Pluralize(string locale, ParsedArguments arguments, double n, double offset) { Pluralizer pluralizer; if (this.Pluralizers.TryGetValue(locale, out pluralizer) == false) { pluralizer = this.Pluralizers["en"]; } var pluralForm = pluralizer(n - offset); KeyedBlock other = null; foreach (var keyedBlock in arguments.KeyedBlocks) { if (keyedBlock.Key == OtherKey) { other = keyedBlock; } if (keyedBlock.Key.StartsWith("=")) { var numberLiteral = Convert.ToDouble(keyedBlock.Key.Substring(1)); // ReSharper disable once CompareOfFloatsByEqualityOperator if (numberLiteral == n) { return(keyedBlock.BlockText); } } if (keyedBlock.Key.StartsWith("%")) { var numberLiteral = Convert.ToInt32(keyedBlock.Key.Substring(1)); if (n % numberLiteral == 0) { return(keyedBlock.BlockText); } } if (keyedBlock.Key == pluralForm) { return(keyedBlock.BlockText); } } if (other == null) { throw new MessageFormatterException("'other' option not found in pattern."); } return(other.BlockText); }
public void GetAll_Named_Test() { var target = new ParsedArguments(new[] { new ParsedNamedArgument("a", "1"), new ParsedNamedArgument("a", "2") }); var result = target.GetAll("a").Cast <INamedArgument>().ToList(); result.Count.Should().Be(2); result[0].Value.Should().Be("1"); result[1].Value.Should().Be("2"); }
public void ParseArgsShouldSetScriptFilesPathWhenGivenArgs() { var args = new[] { CommandlineSwitchType.ScriptFiles.GetSwitch() , SourcePath }; ParsedArguments result = GetResultsForArgs( args); Assert.That(result.GetValue(CommandlineSwitchType.ScriptFiles), Is.EqualTo(SourcePath)); }
public void GetUndoPrintStreamShouldReturnFileWriterWhenGivenFinalScriptFile() { var printScreenFactory = new PrintScreenFactory(); var parsedArguments = new ParsedArguments(); parsedArguments.SetValue(CommandlineSwitchType.UndoFile, "c:\\temp\\foo2.sql"); TextWriter results = printScreenFactory.GetUndoPrintStream(parsedArguments); Assert.That(results, Is.TypeOf <StreamWriter>()); printScreenFactory.ClosePrintStream(results); }
static int Main(string[] args) { ParsedArguments parsedArgs = null; try { parsedArgs = ArgumentParser.Parse(args); } catch (Exception e) { Console.Error.WriteLine("An error occured when trying to parse command line arguments: "); Console.Error.WriteLine(e.ToString()); return(-1); } if (Path.GetFileName(parsedArgs.SDVContentRootDirectory) != "Content") { Console.Error.WriteLine($"\"{parsedArgs.SDVContentRootDirectory}\" doesn't look like a valid SDV Content Directory: "); Console.Error.WriteLine($"It doesn't point to a Content folder."); return(-1); } MappedDirectory mapping = DirectoryMapper.TryMapDirectories(parsedArgs.SDVContentRootDirectory, parsedArgs.ModRootDirectory, out IDictionary <string, string> errors); if (mapping == null) { Console.Error.WriteLine($"An error occured when trying to map the mod to the game's Content folder: "); foreach (KeyValuePair <string, string> errorinfo in errors) { Console.Error.WriteLine($"{errorinfo.Key} is invalid because: ${errorinfo.Value}"); } return(-1); } ContentPack p = new ContentPack(Path.Combine(Directory.GetCurrentDirectory(), "CP")); if (Directory.Exists(p.RootDirectory)) { Directory.Delete(p.RootDirectory, true); } Directory.CreateDirectory(p.RootDirectory); Console.WriteLine(p.RootDirectory); p.GenerateManifest(parsedArgs); ContentGenerator.GenerateContent(p.RootDirectory, mapping); return(0); }
/// <summary> /// Validates the <paramref name="arguments" /> against model. /// </summary> /// <param name="arguments">The arguments.</param> /// <exception cref="ConsoleExtensions.Commandline.Exceptions.UnknownOptionException"> /// Thrown when a requested options is unknown. /// </exception> /// <exception cref="ConsoleExtensions.Commandline.Exceptions.UnknownCommandException"> /// Thrown when a requested command is unknown. /// </exception> private void ValidateArgumentsAgainstModel(ParsedArguments arguments) { foreach (var argument in arguments.Properties) { if (!this.ModelMap.Options.TryGetValue(argument.Key, out _)) { throw new UnknownOptionException(argument.Key, this.ModelMap.Options.Values); } } if (!this.ModelMap.Commands.TryGetValue(arguments.Command, out _)) { throw new UnknownCommandException(arguments.Command, this.ModelMap.Commands.Values); } }
public void ParseArgsShouldUndoScriptFileWhenGivenArgs() { ParsedArguments result = GetResultsForArgs( new[] { CommandlineSwitchType.ScriptFiles.GetSwitch() , SourcePath , CommandlineSwitchType.DoFile.GetSwitch() , DoScriptFile , CommandlineSwitchType.UndoFile.GetSwitch() , UndoScriptFile }); Assert.That(result.GetValue(CommandlineSwitchType.UndoFile), Is.EqualTo(UndoScriptFile)); }
public void MapTo_Test() { var target = new ParsedArguments(new IParsedArgument[] { new ParsedPositionalArgument("test1"), new ParsedNamedArgument("b", "test2"), new ParsedFlagArgument("c") }); var result = target.MapTo <TestArgs1>(); result.A.Should().Be("test1"); result.B.Should().Be("test2"); result.C.Should().BeTrue(); result.D.Should().BeFalse(); }
public void VerifyAllAreConsumed_Consumed() { var target = new ParsedArguments(new IParsedArgument[] { new ParsedPositionalArgument("test1"), new ParsedNamedArgument("b", "test2"), new ParsedFlagArgument("c") }); target.Consume(0); target.Consume("b"); target.ConsumeFlag("c"); Action act = () => target.VerifyAllAreConsumed(); act.Should().NotThrow(); }
/// <summary> /// Parse the array of command line arguments. /// </summary> /// <param name="args">The array of command line arguments.</param> public void Parse(string[] args) { _ParsedArguments.Clear(); List <string> arguments = args.ToList(); Argument lastArgumentWithPrefix = null; for (int i = 0; i < arguments.Count; i++) { string currentValue = arguments[i]; string parameter; if (GetArgumentNameWithoutPrefix(ref currentValue, out parameter)) { if (!string.IsNullOrEmpty(parameter)) { arguments.Insert(i + 1, parameter); } lastArgumentWithPrefix = BuildArgument(currentValue, true); ParsedArguments.Add(lastArgumentWithPrefix); } else { bool addArgument = !string.IsNullOrEmpty(currentValue); if (lastArgumentWithPrefix != null) { if (lastArgumentWithPrefix.ArgumentValue != ArgumentValue.None) { addArgument = false; lastArgumentWithPrefix.Value = currentValue; SetArgumentIsValid(lastArgumentWithPrefix); } lastArgumentWithPrefix = null; } if (addArgument) { ParsedArguments.Add(BuildArgument(currentValue, false)); } } } }
static void Main(string[] arguments) { var args = new ParsedArguments(arguments); if (args.Params.Count > 0) { string inputFile = args.Params.FirstOrDefault(); var util = new XmlDocumentSweeper(inputFile); string outputFile = args.GetNamedParam("output"); if (string.IsNullOrWhiteSpace(outputFile) && args.HasSwitch("replace")) outputFile = inputFile; if (!string.IsNullOrWhiteSpace(outputFile)) util.Transform(outputFile); else Console.WriteLine(util.Transform()); } else usage(); }
private static void ArgumentParsingComplete(ParsedArguments arguments) { if (arguments.Contains("i")) interactive = true; }
public ParsedArguments ParseArgumentsAndMerge(IEnumerable<string> arg, ParsedArguments parsedArguments) { var parsedMethod = Parse(arg); // Inferred ordinal arguments should not be recognized twice parsedArguments.RecognizedArguments = parsedArguments.RecognizedArguments .Where(argopts => !parsedMethod.RecognizedArguments.Any(pargopt => pargopt.Index == argopts.Index && argopts.InferredOrdinal)); var merged = parsedArguments.Merge(parsedMethod); if (!_controller.IgnoreGlobalUnMatchedParameters) merged.AssertFailOnUnMatched(); return merged; }
internal string Pluralize(string locale, ParsedArguments arguments, double n, double offset) { Pluralizer pluralizer; if (this.Pluralizers.TryGetValue(locale, out pluralizer) == false) { pluralizer = this.Pluralizers["en"]; } var pluralForm = pluralizer(n - offset); KeyedBlock other = null; foreach (var keyedBlock in arguments.KeyedBlocks) { if (keyedBlock.Key == OtherKey) { other = keyedBlock; } if (keyedBlock.Key.StartsWith("=")) { var numberLiteral = Convert.ToDouble(keyedBlock.Key.Substring(1)); if (Math.Abs(numberLiteral - n) < double.Epsilon) { return keyedBlock.BlockText; } } if (keyedBlock.Key == pluralForm) { return keyedBlock.BlockText; } } if (other == null) { throw new MessageFormatterException("'other' option not found in pattern."); } return other.BlockText; }
public ParsedMethod Parse(Method methodInfo, ParsedArguments parsedArguments) { var unMatchedRequiredArguments = parsedArguments.UnMatchedRequiredArguments(); if (unMatchedRequiredArguments.Any()) { throw new MissingArgumentException("Missing arguments") { Arguments = unMatchedRequiredArguments .Select(unmatched => unmatched.Name).ToArray() }; } var convertArgument = new ConvertArgumentsToParameterValue(_configuration.CultureInfo, _configuration.TypeConverter); var recognizedActionParameters = convertArgument.GetParametersForMethod(methodInfo, parsedArguments.RecognizedArgumentsAsKeyValuePairs()); return new ParsedMethod( parsedArguments, _typeContainer, _configuration) { RecognizedAction = methodInfo, RecognizedActionParameters = recognizedActionParameters, RecognizedClass = _controller.Type }; }
public ParsedArguments ParseArgumentsAndMerge(string actionName, Dictionary<string, string> arg, ParsedArguments parsedArguments) { var methodInfo = _controller.GetMethod(actionName); var argumentRecognizers = methodInfo.GetArguments() .ToList(); var parser = new ArgumentParser(argumentRecognizers, _allowInferParameter, Culture); var parsedMethodArguments = parser.Parse(arg); var parsedMethod = Parse(methodInfo, parsedMethodArguments); var merged = parsedArguments.Merge(parsedMethod); if (!_controller.IgnoreGlobalUnMatchedParameters) merged.AssertFailOnUnMatched(); return merged; }