microsoft · darrelmiller · Nov 23, 2021 · Jun 7, 2021 · Jun 14, 2021 · Oct 12, 2021
diff --git a/src/Microsoft.OpenApi.Tool/OpenApiService.cs b/src/Microsoft.OpenApi.Tool/OpenApiService.cs
@@ -1,5 +1,7 @@
-using System;
-using System.Collections.Generic;
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using System;
 using System.IO;
 using System.Linq;
 using System.Net;
@@ -21,29 +23,44 @@ public static void ProcessOpenApiDocument(
             FileInfo output,
             OpenApiSpecVersion version,
             OpenApiFormat format,
+            string filterByOperationIds,
             bool inline,
             bool resolveExternal)
         {
-            if (input == null)
+            if (string.IsNullOrEmpty(input))
             {
-                throw new ArgumentNullException("input");
+                throw new ArgumentNullException(nameof(input));
+            }
+            if(output == null)
+            {
+                throw new ArgumentException(nameof(output));
+            }
+            if (output.Exists)
+            {
+                throw new IOException("The file you're writing to already exists. Please input a new output path.");
             }
 
             var stream = GetStream(input);
-
-            OpenApiDocument document;
-
             var result = new OpenApiStreamReader(new OpenApiReaderSettings
             {
-                ReferenceResolution = resolveExternal == true ? ReferenceResolutionSetting.ResolveAllReferences : ReferenceResolutionSetting.ResolveLocalReferences,
+                ReferenceResolution = resolveExternal ? ReferenceResolutionSetting.ResolveAllReferences : ReferenceResolutionSetting.ResolveLocalReferences,
                 RuleSet = ValidationRuleSet.GetDefaultRuleSet()
             }
             ).ReadAsync(stream).GetAwaiter().GetResult();
 
+            OpenApiDocument document;
             document = result.OpenApiDocument;
+
+            // Check if filter options are provided, then execute
+            if (!string.IsNullOrEmpty(filterByOperationIds))
+            {
+                var predicate = OpenApiFilterService.CreatePredicate(filterByOperationIds);
+                document = OpenApiFilterService.CreateFilteredDocument(document, predicate);
+            }
+
             var context = result.OpenApiDiagnostic;
 
-            if (context.Errors.Count != 0)
+            if (context.Errors.Count > 0)
             {
                 var errorReport = new StringBuilder();
 
@@ -52,43 +69,26 @@ public static void ProcessOpenApiDocument(
                     errorReport.AppendLine(error.ToString());
                 }
 
-                throw new ArgumentException(String.Join(Environment.NewLine, context.Errors.Select(e => e.Message).ToArray()));
+                throw new ArgumentException(string.Join(Environment.NewLine, context.Errors.Select(e => e.Message).ToArray()));
             }
 
-            using (var outputStream = output?.Create())
-            {
-                TextWriter textWriter;
-
-                if (outputStream != null)
-                {
-                    textWriter = new StreamWriter(outputStream);
-                }
-                else
-                {
-                    textWriter = Console.Out;
-                }
+            using var outputStream = output?.Create();
 
-                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");
-                }
+            var textWriter = outputStream != null ? new StreamWriter(outputStream) : Console.Out;
 
-                document.Serialize(writer, version);
+            var settings = new OpenApiWriterSettings()
+            {
+                ReferenceInline = inline ? ReferenceInlineSetting.InlineLocalReferences : ReferenceInlineSetting.DoNotInlineReferences
+            };
+            IOpenApiWriter writer = format switch
+            {
+                OpenApiFormat.Json => new OpenApiJsonWriter(textWriter, settings),
+                OpenApiFormat.Yaml => new OpenApiYamlWriter(textWriter, settings),
+                _ => throw new ArgumentException("Unknown format"),
+            };
+            document.Serialize(writer, version);
 
-                textWriter.Flush();
-            }
+            textWriter.Flush();
         }
 
         private static Stream GetStream(string input)
@@ -127,7 +127,6 @@ internal static void ValidateOpenApiDocument(string input)
 
             document = new OpenApiStreamReader(new OpenApiReaderSettings
             {
-                //ReferenceResolution = resolveExternal == true ? ReferenceResolutionSetting.ResolveAllReferences : ReferenceResolutionSetting.ResolveLocalReferences,
                 RuleSet = ValidationRuleSet.GetDefaultRuleSet()
             }
             ).Read(stream, out var context);

diff --git a/src/Microsoft.OpenApi.Tool/Program.cs b/src/Microsoft.OpenApi.Tool/Program.cs
@@ -1,34 +1,15 @@
-using System;
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
 using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.IO;
 using System.Threading.Tasks;
-using Microsoft.OpenApi;
 
 namespace Microsoft.OpenApi.Tool
 {
-    class Program
+    static class Program
     {
-        static async Task<int> OldMain(string[] args)
-        {
-
-            var command = new RootCommand
-            {
-               new Option("--input", "Input OpenAPI description file path or URL", typeof(string) ),
-                new Option("--output","Output OpenAPI description file", typeof(FileInfo), arity: ArgumentArity.ZeroOrOne),
-                new Option("--version", "OpenAPI specification version", typeof(OpenApiSpecVersion)),
-                new Option("--format", "File format",typeof(OpenApiFormat) ),
-                new Option("--inline", "Inline $ref instances", typeof(bool) ),
-                new Option("--resolveExternal","Resolve external $refs", typeof(bool)) 
-            };
-
-            command.Handler = CommandHandler.Create<string,FileInfo,OpenApiSpecVersion,OpenApiFormat,bool, bool>(
-                OpenApiService.ProcessOpenApiDocument);
-
-            // Parse the incoming args and invoke the handler
-            return await command.InvokeAsync(args);
-        }
-
         static async Task<int> Main(string[] args)
         {
             var rootCommand = new RootCommand() {
@@ -47,9 +28,10 @@ static async Task<int> Main(string[] args)
                 new Option("--version", "OpenAPI specification version", typeof(OpenApiSpecVersion)),
                 new Option("--format", "File format",typeof(OpenApiFormat) ),
                 new Option("--inline", "Inline $ref instances", typeof(bool) ),
-                new Option("--resolveExternal","Resolve external $refs", typeof(bool))
+                new Option("--resolveExternal","Resolve external $refs", typeof(bool)),
+                new Option("--filterByOperationIds", "Filters by OperationId provided", typeof(string))
             };
-            transformCommand.Handler = CommandHandler.Create<string, FileInfo, OpenApiSpecVersion, OpenApiFormat, bool, bool>(
+            transformCommand.Handler = CommandHandler.Create<string, FileInfo, OpenApiSpecVersion, OpenApiFormat, string, bool, bool>(
                 OpenApiService.ProcessOpenApiDocument);
 
             rootCommand.Add(transformCommand);

diff --git a/src/Microsoft.OpenApi/Microsoft.OpenApi.csproj b/src/Microsoft.OpenApi/Microsoft.OpenApi.csproj
@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <TargetFrameworks>netstandard2.0</TargetFrameworks>
+        <LangVersion>9.0</LangVersion>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
         <PackageIconUrl>http://go.microsoft.com/fwlink/?LinkID=288890</PackageIconUrl>
         <PackageProjectUrl>https://github.com/Microsoft/OpenAPI.NET</PackageProjectUrl>
@@ -36,7 +37,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All"/>
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
     </ItemGroup>
 
     <ItemGroup>

diff --git a/src/Microsoft.OpenApi/Services/CopyReferences.cs b/src/Microsoft.OpenApi/Services/CopyReferences.cs
@@ -0,0 +1,112 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using System.Collections.Generic;
+using Microsoft.OpenApi.Interfaces;
+using Microsoft.OpenApi.Models;
+
+namespace Microsoft.OpenApi.Services
+{
+    internal class CopyReferences : OpenApiVisitorBase
+    {
+        private readonly OpenApiDocument _target;
+        public OpenApiComponents Components = new();
+
+        public CopyReferences(OpenApiDocument target)
+        {
+            _target = target;
+        }
+
+        /// <summary>
+        /// Visits IOpenApiReferenceable instances that are references and not in components.
+        /// </summary>
+        /// <param name="referenceable"> An IOpenApiReferenceable object.</param>
+        public override void Visit(IOpenApiReferenceable referenceable)
+        {
+            switch (referenceable)
+            {
+                case OpenApiSchema schema:
+                    EnsureComponentsExists();
+                    EnsureSchemasExists();
+                    if (!Components.Schemas.ContainsKey(schema.Reference.Id))
+                    {
+                        Components.Schemas.Add(schema.Reference.Id, schema);
+                    }
+                    break;
+
+                case OpenApiParameter parameter:
+                    EnsureComponentsExists();
+                    EnsureParametersExists();
+                    if (!Components.Parameters.ContainsKey(parameter.Reference.Id))
+                    {
+                        Components.Parameters.Add(parameter.Reference.Id, parameter);
+                    }
+                    break;
+
+                case OpenApiResponse response:
+                    EnsureComponentsExists();
+                    EnsureResponsesExists();
+                    if (!Components.Responses.ContainsKey(response.Reference.Id))
+                    {
+                        Components.Responses.Add(response.Reference.Id, response);
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+            base.Visit(referenceable);
+        }
+
+        /// <summary>
+        /// Visits <see cref="OpenApiSchema"/>
+        /// </summary>
+        /// <param name="schema">The OpenApiSchema to be visited.</param>
+        public override void Visit(OpenApiSchema schema)
+        {
+            // This is needed to handle schemas used in Responses in components
+            if (schema.Reference != null)
+            {
+                EnsureComponentsExists();
+                EnsureSchemasExists();
+                if (!Components.Schemas.ContainsKey(schema.Reference.Id))
+                {
+                    Components.Schemas.Add(schema.Reference.Id, schema);
+                }
+            }
+            base.Visit(schema);
+        }
+
+        private void EnsureComponentsExists()
+        {
+            if (_target.Components == null)
+            {
+                _target.Components = new OpenApiComponents();
+            }
+        }
+
+        private void EnsureSchemasExists()
+        {
+            if (_target.Components.Schemas == null)
+            {
+                _target.Components.Schemas = new Dictionary<string, OpenApiSchema>();
+            }
+        }
+
+        private void EnsureParametersExists()
+        {
+            if (_target.Components.Parameters == null)
+            {
+                _target.Components.Parameters = new Dictionary<string, OpenApiParameter>();
+            }
+        }
+
+        private void EnsureResponsesExists()
+        {
+            if (_target.Components.Responses == null)
+            {
+                _target.Components.Responses = new Dictionary<string, OpenApiResponse>();
+            }
+        }
+    }
+}