public override async Task RunAsync(CommandLineProcessor processor, IConsoleHost host) { var schema = JsonSchema4.FromJson(InputJson); var generator = new TypeScriptGenerator(schema); var code = generator.GenerateFile(); WriteOutput(host, code); }
public PrivateData( CommandLineProcessor.Delegate commandLineDelegate, VisualStudioProcessor.Delegate visualStudioDelegate) { this.CommandLineDelegate = commandLineDelegate; this.VisualStudioProjectDelegate = visualStudioDelegate; }
public override async Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var document = await RunAsync(); if (TryWriteFileOutput(host, () => document.ToJson()) == false) return document; return null; }
static void Main(string[] args) { var host = new ConsoleHost(); host.WriteMessage("NSwag command line: v" + typeof(SwaggerInfo).Assembly.GetName().Version + "\n"); host.WriteMessage("Visit http://NSwag.org for more information.\n"); host.WriteMessage("Execute the 'help' command to show a list of all the available commands.\n"); try { var processor = new CommandLineProcessor(host); processor.RegisterCommand<WebApiToSwaggerCommand>("webapi2swagger"); processor.RegisterCommand<JsonSchemaToCSharpCommand>("jsonschema2csharp"); processor.RegisterCommand<JsonSchemaToTypeScriptCommand>("jsonschema2typescript"); processor.RegisterCommand<SwaggerToCSharpCommand>("swagger2csharp"); processor.RegisterCommand<SwaggerToTypeScriptCommand>("swagger2typescript"); processor.Process(args); } catch (Exception exception) { var savedForegroundColor = Console.ForegroundColor; Console.ForegroundColor = ConsoleColor.Red; host.WriteMessage(exception.ToString()); Console.ForegroundColor = savedForegroundColor; } if (Debugger.IsAttached) { Console.WriteLine("Press <any> key to exit..."); Console.ReadKey(); } }
static void Main(string[] args) { var host = new ConsoleHost(); host.WriteMessage("NSwag command line: v" + typeof(SwaggerInfo).Assembly.GetName().Version + "\n"); host.WriteMessage("Visit http://NSwag.org for more information."); host.WriteMessage("\n"); try { var processor = new CommandLineProcessor(host); processor.RegisterCommand<CSharpCommand>("csharp"); processor.RegisterCommand<TypeScriptCommand>("typescript"); processor.Process(args); } catch (Exception exception) { var savedForegroundColor = System.Console.ForegroundColor; System.Console.ForegroundColor = ConsoleColor.Red; host.WriteMessage(exception.ToString()); System.Console.ForegroundColor = savedForegroundColor; } if (Debugger.IsAttached) System.Console.ReadKey(); }
static void Main(string[] args) { var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand<CloneCommand>("clone"); processor.Process(args); Console.ReadKey(); }
public override async Task RunAsync(CommandLineProcessor processor, IConsoleHost host) { var clientGenerator = new SwaggerToTypeScriptGenerator(InputSwaggerService); clientGenerator.Class = Class; var output = clientGenerator.GenerateFile(); WriteOutput(host, output); }
public override async Task RunAsync(CommandLineProcessor processor, IConsoleHost host) { var clientGenerator = new SwaggerToCSharpGenerator(InputSwaggerService); clientGenerator.Class = Class; clientGenerator.Namespace = Namespace; clientGenerator.OperationGenerationMode = OperationGenerationMode; var output = clientGenerator.GenerateFile(); WriteOutput(host, output); }
public void ProcessArgs_NullOptionsAsParameter_ExceptionThrown() { // arrange clp = new CommandLineProcessor(); // act - not required clp.Options = null; // assert - not required }
public void When_adding_command_with_same_name_then_exception_is_thrown() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost(), new MyDependencyResolver()); processor.RegisterCommand<MyCommand>("Test"); //// Act processor.RegisterCommand<MyCommand>("test"); // exception //// Assert }
public void When_adding_a_command_then_the_command_is_in_the_commands_list() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost(), new MyDependencyResolver()); //// Act processor.RegisterCommand<MyCommand>("test"); //// Assert Assert.IsTrue(processor.Commands.ContainsKey("test")); }
public async Task When_dependency_resolver_is_missing_and_command_without_default_constructor_then_exception_is_thrown() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand<MyCommand>("test"); //// Act await processor.ProcessAsync(new string[] { "test" }); // exception //// Assert }
public async Task WhenArgumentIsEnumThenItShouldBeLoadedCorrectly() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand<MyEnumCommand>("test"); //// Act var command = (MyEnumCommand)await processor.ProcessAsync(new string[] { "test", "/myenum:def" }); //// Assert Assert.AreEqual(MyEnum.Def, command.MyEnum); }
public async Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { if (!DynamicApis.FileExists("nswag.json")) { await CreateDocumentAsync("nswag.json"); host.WriteMessage("nswag.json file created."); } else host.WriteMessage("nswag.json already exists."); return null; }
public override bool Execute() { if (Debug) Debugger.Launch(); _success = true; var commandProcessor = new CommandLineProcessor(new CommandRepository(ReadCommands(Services.Services.GetService<IEnvironment>()))); foreach (var cmd in commandProcessor.Execute(new[] { Noun, Verb }.Concat(GetArguments()).ToList())) ProcessOutput(cmd); return _success; }
public void When_adding_command_with_upper_case_then_it_is_converted_to_lower_case() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost(), new MyDependencyResolver()); //// Act processor.RegisterCommand<MyCommand>("Test"); //// Assert Assert.IsFalse(processor.Commands.ContainsKey("Test")); Assert.IsTrue(processor.Commands.ContainsKey("test")); }
public async Task When_running_command_with_int64_parameter_then_they_are_correctly_set() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand<MyArgumentCommand>("test"); //// Act var command = (MyArgumentCommand)await processor.ProcessAsync(new string[] { "test", "/int64:123" }); //// Assert Assert.IsTrue(123 == command.Int64); }
public async Task When_array_has_empty_default_then_property_is_correctly_initialized() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand<MyDefaultArrayCommand>("test"); //// Act var result = await processor.ProcessAsync(new string[] { "test" }); var command = (MyDefaultArrayCommand)result.Last().Command; //// Assert Assert.AreEqual(0, command.MyStrings.Length); }
public void When_first_argument_is_existing_command_name_then_command_is_executed() { //// Arrange var resolver = new MyDependencyResolver(); var processor = new CommandLineProcessor(new ConsoleHost(), resolver); processor.RegisterCommand<MyCommand>("test"); //// Act var command = (MyCommand)processor.Process(new string[] { "test" }); //// Assert Assert.IsNotNull(command); }
/// <summary>Runs the command.</summary> /// <param name="processor">The processor.</param> /// <param name="host">The host.</param> /// <returns>The input object for the next command.</returns> public Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { foreach (var pair in processor.Commands) { if (pair.Key != "help") { PrintCommand(host, pair); host.ReadValue("Press <enter> key for next command..."); } } return Task.FromResult<object>(null); }
public void TestAutoLayoutCommand() { var args = new string[] { "-input", Path.Combine(TestFilesPath, "MicroSecSemicolonSeperated.txt"), "-format", "Generic", "-TimeFormat", "yyyy-MM-dd-hh.mm.ss.ffffff", "-Precision", "Microseconds", "-splitter", ";", "-tags", "Server=abcd", "-ignoreerrors", "/export", "/autolayout" }; Assert.IsFalse(CommandLineProcessor.ProcessArguments(args), "Processing AutoLayout Command failed"); }
public override Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { using (var collection = new ProjectCollection()) { foreach (var projectPath in GetProjectPaths()) { try { var project = collection.LoadProject(projectPath); var result = false; switch (Action) { case "warnaserror": result = EnableBooleanProperty(project, "WarningsAsErrors"); break; case "xmldocs": result = EnableXmlDocs(project); break; default: throw new ArgumentException("The feature " + Action + " is not available."); } if (result) { host.WriteMessage("[x] Enabled feature " + Action + " in project " + System.IO.Path.GetFileName(projectPath) + "\n"); if (!Simulate) { project.Save(); } } else { host.WriteMessage("[ ] Feature " + Action + " already enabled in project " + System.IO.Path.GetFileName(projectPath) + "\n"); } collection.UnloadProject(project); } catch (Exception e) { host.WriteError(e + "\n"); } } } return(Task.FromResult <object>(null)); }
public override Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var schema = JsonSchema4.FromJson(InputJson); var generator = new TypeScriptGenerator(schema); var code = generator.GenerateFile(Name); if (TryWriteFileOutput(host, () => code) == false) { return(Task.FromResult <object>(code)); } return(Task.FromResult <object>(null)); }
public void CommandLineProcessor_IsThereASiteWhenCommandLineIsSet_SiteLoadedintoProperty() { // Arrange string[] args = new string[] { "-s testsite" }; // Act CommandLineProcessor p = new CommandLineProcessor(args, logger); var results = p.Options.SiteName; // Assert Assert.AreEqual(results.Length > 0, true); Assert.AreEqual(results, "testsite"); }
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var inputJson = await GetInputJsonAsync().ConfigureAwait(false); var schema = await JsonSchema4.FromJsonAsync(inputJson).ConfigureAwait(false); var generator = new CSharpGenerator(schema, Settings); var code = generator.GenerateFile(Name); await TryWriteFileOutputAsync(host, () => code).ConfigureAwait(false); return(code); }
public void When_no_dependency_resolver_is_present_static_ctor_is_not_used() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <CommandWithStaticCtor>("test"); //// Act var result = processor.Process(new[] { "test" }); var command = result.Last().Command as CommandWithStaticCtor; //// Assert Assert.NotNull(command); }
public void Option_NoArg_1(params string[] args) { CommandLineProcessor cmdline = new CommandLineProcessor(); cmdline.RegisterOptionMatchHandler("a", (sender, e) => { }); cmdline.ProcessCommandLineArgs(args); Assert.That(cmdline.ArgCount, Is.EqualTo(1)); IEnumerable <string> emptylist = new List <string>(0); Assert.That(cmdline.InvalidArgs, Is.EquivalentTo(emptylist)); }
/// <summary>Processes the command line arguments.</summary> /// <param name="args">The arguments.</param> /// <returns>The result.</returns> public int Process(string[] args) { var architecture = IntPtr.Size == 4 ? " (x86)" : " (x64)"; _host.WriteMessage("toolchain v" + SwaggerDocument.ToolchainVersion + " (NJsonSchema v" + JsonSchema4.ToolchainVersion + ")" + architecture + "\n"); _host.WriteMessage("Visit http://NSwag.org for more information.\n"); WriteBinDirectory(); if (args.Length == 0) { _host.WriteMessage("Execute the 'help' command to show a list of all the available commands.\n"); } try { var processor = new CommandLineProcessor(_host); processor.RegisterCommandsFromAssembly(_assemblyLoaderAssembly); processor.RegisterCommandsFromAssembly(typeof(SwaggerToCSharpControllerCommand).GetTypeInfo().Assembly); var stopwatch = new Stopwatch(); stopwatch.Start(); var results = processor.Process(args); stopwatch.Stop(); var output = results.Last()?.Output; var document = output as SwaggerDocument; if (document != null) { _host.WriteMessage(document.ToJson()); } else if (output != null) { _host.WriteMessage(output.ToString()); } _host.WriteMessage("\nDuration: " + stopwatch.Elapsed + "\n"); } catch (Exception exception) { _host.WriteError(exception.ToString()); return(-1); } WaitWhenDebuggerAttached(); return(0); }
public async Task When_running_command_with_quoted_string_parameter_then_they_are_correctly_set() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <MyArgumentCommand>("test"); //// Act var result = await processor.ProcessAsync(new string[] { "test", "/string:abc def" }); var command = (MyArgumentCommand)result.Last().Command; //// Assert Assert.AreEqual("abc def", command.String); }
public async Task When_running_command_with_int64_parameter_then_they_are_correctly_set() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <MyArgumentCommand>("test"); //// Act var result = await processor.ProcessAsync(new string[] { "test", "/int64:123" }); var command = (MyArgumentCommand)result.Last().Command; //// Assert Assert.IsTrue(123 == command.Int64); }
public async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { if (await DynamicApis.FileExistsAsync("nswag.json").ConfigureAwait(false) == false) { await CreateDocumentAsync("nswag.json"); host.WriteMessage("nswag.json file created."); } else { host.WriteMessage("nswag.json already exists."); } return(null); }
public async Task When_running_command_with_boolean_parameter_then_they_are_correctly_set() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <MyArgumentCommand>("test"); //// Act var result = await processor.ProcessAsync(new[] { "test", "/boolean:true" }); var command = (MyArgumentCommand)result.Last().Command; //// Assert Assert.True(command.Boolean); }
static void Main(string[] args) { Out.Echo(ANSI.RIS); Out.ClearScreen(); var commandLineProcessor = new CommandLineProcessor( args, new OrbitalShellCommandLineProcessorSettings()); var commandLineReader = new CommandLineReader( commandLineProcessor); commandLineProcessor.Initialize(); var returnCode = commandLineReader.ReadCommandLine(); Environment.Exit(returnCode); }
public void When_first_argument_is_existing_command_name_then_command_is_executed() { //// Arrange var resolver = new MyDependencyResolver(); var processor = new CommandLineProcessor(new ConsoleHost(), resolver); processor.RegisterCommand <MyCommand>("test"); //// Act var result = processor.Process(new[] { "test" }); var command = result.Last().Command as MyCommand; //// Assert Assert.NotNull(command); }
public async Task When_array_has_empty_default_then_property_is_correctly_initialized() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <MyDefaultArrayCommand>("test"); //// Act var result = await processor.ProcessAsync(new string[] { "test" }); var command = (MyDefaultArrayCommand)result.Last().Command; //// Assert Assert.AreEqual(0, command.MyStrings.Length); }
public async Task When_command_is_chained_and_output_is_ignored_then_first_command_does_not_influence_second_command() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand<SumCommand>("sum"); processor.RegisterCommand<SubtractCommand>("subtract"); var args = new string[] { "sum", "/a:6", "/b:10", "=", "subtract", "/a: 20", "/b:7" }; //// Act var result = await processor.ProcessAsync(args); //// Assert Assert.AreEqual(13, result.Last().Output); }
public async Task When_argument_is_string_array_then_it_can_be_defined_as_comma_separated_string() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand<MyArrayCommand>("test"); //// Act var command = (MyArrayCommand)await processor.ProcessAsync(new string[] { "test", "/mystrings:a,b,c" }); //// Assert Assert.AreEqual(3, command.MyStrings.Length); Assert.AreEqual("a", command.MyStrings[0]); Assert.AreEqual("b", command.MyStrings[1]); Assert.AreEqual("c", command.MyStrings[2]); }
public override async Task RunAsync(CommandLineProcessor processor, IConsoleHost host) { var settings = new CSharpGeneratorSettings { Namespace = Namespace, RequiredPropertiesMustBeDefined = RequiredPropertiesMustBeDefined, DateTimeType = DateTimeType }; var schema = JsonSchema4.FromJson(InputJson); var generator = new CSharpGenerator(schema, settings); var code = generator.GenerateFile(); WriteOutput(host, code); }
public async Task When_positional_argument_starts_with_slash_then_it_is_correctly_read() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <MyCommand>("test"); //// Act var result = await processor.ProcessAsync(new[] { "test", "/foo/bar/test.cs" }); var command = (MyCommand)result.Last().Command; //// Assert Assert.Equal("/foo/bar/test.cs", command.First); }
static void Main(string[] args) { if (args.ToList().Contains(WindowsServiceUtilities.RUN_AS_SERVICE_TOKEN)) { #if DEBUG Debugger.Launch(); #endif WindowsServiceUtilities.RunService(); } else { var commandLineProcessor = new CommandLineProcessor(); commandLineProcessor.EntryPoint(args); } }
public async Task WhenArgumentIsEnumThenItShouldBeLoadedCorrectly() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <MyEnumCommand>("test"); //// Act var result = await processor.ProcessAsync(new[] { "test", "/myenum:def" }); var command = (MyEnumCommand)result.Last().Command; //// Assert Assert.Equal(MyEnum.Def, command.MyEnum); }
public async Task When_command_is_chained_and_output_is_ignored_then_first_command_does_not_influence_second_command() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <SumCommand>("sum"); processor.RegisterCommand <SubtractCommand>("subtract"); var args = new string[] { "sum", "/a:6", "/b:10", "=", "subtract", "/a: 20", "/b:7" }; //// Act var result = await processor.ProcessAsync(args); //// Assert Assert.AreEqual(13, result.Last().Output); }
private void BasicWellFormedCheck(string option) { var originalValue = _options[option]; Assert.DoesNotThrow(() => CommandLineProcessor.ValidateCommandLineArgs(_options), "legal value should not throw"); _options[option] = string.Empty; Assert.Throws <CommandLineException>(() => CommandLineProcessor.ValidateCommandLineArgs(_options), "empty string should have thrown"); _options[option] = null; Assert.Throws <CommandLineException>(() => CommandLineProcessor.ValidateCommandLineArgs(_options), "null string should have thrown"); // Restore original value. _options[option] = originalValue; }
public static int Main(string[] args) { _logger = new ConsoleLogger( ConsoleLoggerOptions.DisplayBanner | ConsoleLoggerOptions.UseLabels | ConsoleLoggerOptions.ShowTime); using (var processor = new CommandLineProcessor(args)) { processor.WithErrorAction(ShowErrors) .WithHelpAction(ShowHelp); return(processor.Parse <ProgramOptions>() .Execute(MainCore)); } }
public async Task When_command_is_chained_then_output_is_passed_as_input_to_second_command() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <SumCommand>("sum"); processor.RegisterCommand <SubtractCommand>("subtract"); var args = new [] { "sum", "/a:6", "/b:10", "=", "subtract", "/b:7" }; //// Act var result = await processor.ProcessAsync(args); //// Assert Assert.Equal(9, result.Last().Output); }
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var packages = new List <PackageReferenceInfo>(); LoadProjects(host, packages); await LoadAllDependenciesAsync(packages, host); await LoadLicensesAsync(packages, host); host.WriteMessage($"{"Package",-85} {"Version",-22} {"Type",-5} {"#",-3} {"License",-15} {"License URL"}\n"); foreach (var entry in packages.OrderBy(p => p.Name).ThenBy(p => p.Version)) { host.WriteMessage($"{entry.Name,-85} {entry.Version,-22} {entry.Type,-5} {entry.Count,-3} {entry.License,-15} {entry.LicenseUri,-10}\n"); } return(Task.FromResult <object>(null)); }
public static void Main(string[] args) { bool listener_flag = false; // Listen to network requests bool reader_flag = false; // Read the dictionary file string readerHandle = null; CommandLineProcessor argsProcessor = new CommandLineProcessor(); argsProcessor.RegisterOptionMatchHandler("L", requiresArgument: false, (sender, o) => { listener_flag = true; }); argsProcessor.RegisterOptionMatchHandler("R", requiresArgument: false, (sender, o) => { reader_flag = true; }); argsProcessor.RegisterOptionMatchHandler("H", requiresArgument: true, (sender, o) => { readerHandle = o.Argument; }); argsProcessor.RegisterOptionMatchHandler(CommandLineProcessor.InvalidOptionIdentifier, (sender, o) => { //Usage(); Environment.Exit(1); }); argsProcessor.ProcessCommandLineArgs(args); if (listener_flag && reader_flag) { // Error! Environment.Exit(1); } if (listener_flag) { // run as the network Listener Listener(); } if (reader_flag) { // run as the dictionary reader Reader(readerHandle); } // This is what the main app does ForkListener(); ForkReader(); }
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var configuration = ReferenceSwitcherConfiguration.Load(Configuration, host); if (configuration == null) { return(null); } await AddProjectsToSolutionAsync(configuration, host); SwitchToProjects(configuration, host); configuration.Save(); return(null); }
public static void Main(string[] args) { logger.Info("IIS Log Muncher (" + Assembly.GetExecutingAssembly().GetName().Version.ToString() + ")" + " starting."); var clp = new CommandLineProcessor("achis:t:"); var clo = clp.ProcessArgs(args); if (clo.IsOptionSet('h')) { ShowHelpText(); } var fhe = new FileHelperEngine(clo); fhe.ProcessFileList(); logger.Info("IIS Log Muncher finished."); }
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var configuration = ReferenceSwitcherConfiguration.Load(Configuration, host); if (configuration == null) { return(null); } SwitchToPackages(host, configuration); await RemoveProjectsFromSolutionAsync(configuration, host); configuration.Restore = null; // restore information no longer needed configuration.Save(); return(null); }
public async Task When_running_command_with_datetime_parameter_then_they_are_correctly_set() { //// Arrange var processor = new CommandLineProcessor(new ConsoleHost()); processor.RegisterCommand <MyArgumentCommand>("test"); //// Act var result = await processor.ProcessAsync(new string[] { "test", "/datetime:2014-5-3" }); var command = (MyArgumentCommand)result.Last().Command; //// Assert Assert.AreEqual(3, command.DateTime.Day); Assert.AreEqual(5, command.DateTime.Month); Assert.AreEqual(2014, command.DateTime.Year); }
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { return(await Task.Run(async() => { var generator = await CreateGeneratorAsync(); var classNames = generator.GetExportedClassNames(); host.WriteMessage("\r\n"); foreach (var className in classNames) { host.WriteMessage(className + "\r\n"); } host.WriteMessage("\r\n"); return classNames; })); }
public void ValidatesFilesRelativeToAppContext() { var exists = Path.Combine(AppContext.BaseDirectory, "exists.txt"); if (!File.Exists(exists)) { File.WriteAllText(exists, ""); } var appInBaseDir = new CommandLineApplication( new TestConsole(_output), AppContext.BaseDirectory, false); var notFoundDir = Path.Combine(AppContext.BaseDirectory, "notfound"); var appNotInBaseDir = new CommandLineApplication( new TestConsole(_output), notFoundDir, false); appInBaseDir.Argument("Files", "Files") .Accepts(v => v.ExistingFileOrDirectory()); appNotInBaseDir.Argument("Files", "Files") .Accepts(v => v.ExistingFileOrDirectory()); var success = new CommandLineProcessor(appInBaseDir, new[] { "exists.txt" }) .Process() .GetValidationResult(); var fails = new CommandLineProcessor(appNotInBaseDir, new[] { "exists.txt" }) .Process() .GetValidationResult(); Assert.Equal(ValidationResult.Success, success); Assert.NotEqual(ValidationResult.Success, fails); Assert.Equal("The file path 'exists.txt' does not exist.", fails.ErrorMessage); var console = new TestConsole(_output); var context = new DefaultCommandLineContext(console, appNotInBaseDir.WorkingDirectory, new[] { "exists.txt" }); Assert.NotEqual(0, CommandLineApplication.Execute <App>(context)); context = new DefaultCommandLineContext(console, appInBaseDir.WorkingDirectory, new[] { "exists.txt" }); Assert.Equal(0, CommandLineApplication.Execute <App>(context)); }
/// <summary>Processes the command line arguments.</summary> /// <param name="args">The arguments.</param> /// <returns>The result.</returns> public int Process(string[] args) { var architecture = IntPtr.Size == 4 ? " (x86)" : " (x64)"; _host.WriteMessage("toolchain v" + SwaggerDocument.ToolchainVersion + " (NJsonSchema v" + JsonSchema4.ToolchainVersion + ")" + architecture + "\n"); _host.WriteMessage("Visit http://NSwag.org for more information.\n"); var binDirectory = DynamicApis.PathGetDirectoryName(((dynamic)typeof(NSwagCommandProcessor).GetTypeInfo().Assembly).CodeBase.Replace("file:///", string.Empty)); _host.WriteMessage("NSwag bin directory: " + binDirectory + "\n"); if (args.Length == 0) _host.WriteMessage("Execute the 'help' command to show a list of all the available commands.\n"); try { var processor = new CommandLineProcessor(_host); processor.RegisterCommandsFromAssembly(_assemblyLoaderAssembly); processor.RegisterCommandsFromAssembly(typeof(SwaggerToCSharpControllerCommand).GetTypeInfo().Assembly); var stopwatch = new Stopwatch(); stopwatch.Start(); var results = processor.Process(args); stopwatch.Stop(); var output = results.Last()?.Output; var document = output as SwaggerDocument; if (document != null) _host.WriteMessage(document.ToJson()); else if (output != null) _host.WriteMessage(output.ToString()); _host.WriteMessage("\nDuration: " + stopwatch.Elapsed); } catch (Exception exception) { _host.WriteError(exception.ToString()); return -1; } WaitWhenDebuggerAttached(); return 0; }
public async Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { if (!string.IsNullOrEmpty(Input)) await ExecuteDocumentAsync(host, Input); else { if (DynamicApis.FileExists("nswag.json")) await ExecuteDocumentAsync(host, "nswag.json"); var files = DynamicApis.DirectoryGetFiles(DynamicApis.DirectoryGetCurrentDirectory(), "*.nswag"); if (files.Any()) { foreach (var file in files) await ExecuteDocumentAsync(host, file); } else host.WriteMessage("Current directory does not contain any .nswag files."); } return null; }
/// <summary>Runs the command.</summary> /// <param name="processor">The processor.</param> /// <param name="host">The host.</param> /// <returns>The output.</returns> public Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { host.WriteMessage("\nNSwag version: " + SwaggerDocument.ToolchainVersion + "\n"); host.WriteMessage("NJsonSchema version: " + JsonSchema4.ToolchainVersion + "\n"); return Task.FromResult<object>(null); }
public PrivateData( CommandLineProcessor.Delegate commandLineDelegate) { this.CommandLineDelegate = commandLineDelegate; }
public async Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { host.WriteMessage(string.Format("Clone {{ Repository={0}, Quiet={1} }}", Repository, Quiet)); return null; }
public override Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var schema = JsonSchema4.FromJson(InputJson); var generator = new CSharpGenerator(schema, Settings); var code = generator.GenerateFile(Name); if (TryWriteFileOutput(host, () => code) == false) return Task.FromResult<object>(code); return Task.FromResult<object>(null); }