First running version of OpenApi tool

Author: darrelmiller

src/Microsoft.OpenApi.Tool/Microsoft.OpenApi.Tool.csproj

@@ -6,6 +6,7 @@
     <PackAsTool>true</PackAsTool>
     <ToolCommandName>openapi</ToolCommandName>
     <PackageOutputPath>./../../artifacts</PackageOutputPath>
+    <Version>0.5.0</Version>
   </PropertyGroup>
 
   <ItemGroup>

src/Microsoft.OpenApi.Tool/OpenApiService.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Text;
 using Microsoft.OpenApi.Extensions;
+using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Readers;
 using Microsoft.OpenApi.Validations;
 using Microsoft.OpenApi.Writers;
@@ -13,21 +14,22 @@ namespace Microsoft.OpenApi.Tool
     static class OpenApiService
     {
         public static void ProcessOpenApiDocument(
-            FileInfo fileOption,
-            string outputPath,
+            FileInfo input,
+            FileInfo output,
             OpenApiSpecVersion version,
             OpenApiFormat format,
-            bool inline = false)
+            bool inline)
         {
-                Stream stream = fileOption.OpenRead();
+            OpenApiDocument document;
+            using (Stream stream = input.OpenRead())
+            {
 
-                var document = new OpenApiStreamReader(new OpenApiReaderSettings
+                document = new OpenApiStreamReader(new OpenApiReaderSettings
                 {
                     ReferenceResolution = ReferenceResolutionSetting.ResolveLocalReferences,
                     RuleSet = ValidationRuleSet.GetDefaultRuleSet()
                 }
                 ).Read(stream, out var context);
-
                 if (context.Errors.Count != 0)
                 {
                     var errorReport = new StringBuilder();
@@ -38,21 +40,41 @@ public static void ProcessOpenApiDocument(
                     }
 
                     throw new ArgumentException(String.Join(Environment.NewLine, context.Errors.Select(e => e.Message).ToArray()));
+                }
             }
 
-            using (var outputStream = new FileStream(outputPath, FileMode.Create))
+            using (var outputStream = output?.Create())
             {
-                document.Serialize(
-                   outputStream,
-                   version,
-                   format,
-                   new OpenApiWriterSettings()
-                   {
-                       ReferenceInline = inline == true ? ReferenceInlineSetting.InlineLocalReferences : ReferenceInlineSetting.DoNotInlineReferences
-                   });
+                TextWriter textWriter;
+
+                if (outputStream!=null)
+                {
+                    textWriter = new StreamWriter(outputStream);
+                } else
+                {
+                    textWriter = Console.Out;
+                }
+                
+                var settings = new OpenApiWriterSettings()
+                {
+                    ReferenceInline = inline == true ? ReferenceInlineSetting.InlineLocalReferences : ReferenceInlineSetting.DoNotInlineReferences
+                };
+                IOpenApiWriter writer;
+                switch (format)
+                {
+                    case OpenApiFormat.Json:
+                        writer = new OpenApiJsonWriter(textWriter, settings);
+                        break;
+                    case OpenApiFormat.Yaml:
+                        writer = new OpenApiYamlWriter(textWriter, settings);
+                        break;
+                    default:
+                        throw new ArgumentException("Unknown format");
+                }
+                
+                document.Serialize(writer,version );
 
-                outputStream.Position = 0;
-                outputStream.Flush();
+                textWriter.Flush();
             }
         }
 }

src/Microsoft.OpenApi.Tool/Program.cs

@@ -2,49 +2,29 @@
 using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.IO;
+using System.Threading.Tasks;
 using Microsoft.OpenApi;
 
 namespace Microsoft.OpenApi.Tool
 {
     class Program
     {
-        static int Main(string[] args)
+        static async Task<int> Main(string[] args)
         {
-            var rootCommand = new RootCommand
+            var command = new RootCommand
             {
-                new Option(
-                    "--input",
-                    "Input OpenAPI description")
-                {
-                    Argument = new Argument<FileInfo>()
-                },
-                new Option(
-                    "--output",
-                    "Output path for OpenAPI Description")
-                {
-                    Argument = new Argument<string>()
-                },
-                new Option(
-                    "--output-version",
-                    "OpenAPI Version")
-                {
-                    Argument = new Argument<OpenApiSpecVersion>(() => OpenApiSpecVersion.OpenApi3_0)
-                },
-                new Option(
-                    "--output-format",
-                    "OpenAPI format [Json | Yaml")
-                {
-                    Argument = new Argument<OpenApiFormat>(() => OpenApiFormat.Yaml )
-                }
+               new Option("--input") { Argument = new Argument<FileInfo>() },
+                new Option("--output") { Argument = new Argument<FileInfo>() },
+                new Option("--version") { Argument = new Argument<OpenApiSpecVersion>() },
+                new Option("--format") { Argument = new Argument<OpenApiFormat>() },
+                new Option("--inline") { Argument = new Argument<bool>() }
             };
 
-            rootCommand.Description = "OpenAPI";
-
-            rootCommand.Handler = CommandHandler.Create<FileInfo,string,OpenApiSpecVersion,OpenApiFormat, bool>(
-               OpenApiService.ProcessOpenApiDocument);
+            command.Handler = CommandHandler.Create<FileInfo,FileInfo,OpenApiSpecVersion,OpenApiFormat,bool>(
+                OpenApiService.ProcessOpenApiDocument);
 
             // Parse the incoming args and invoke the handler
-            return rootCommand.InvokeAsync(args).Result;
+            return await command.InvokeAsync(args);
         }
     }
 }