Move languageFormat to settings file

Author: peombwa

src/Microsoft.OpenApi.Hidi/Extensions/OpenApiExtensibleExtensions.cs

@@ -0,0 +1,25 @@
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Interfaces;
+using System.Collections.Generic;
+
+namespace Microsoft.OpenApi.Hidi.Extensions
+{
+    internal static class OpenApiExtensibleExtensions
+    {
+        /// <summary>
+        /// Gets an extension value from the extensions dictionary.
+        /// </summary>
+        /// <param name="extensions">A dictionary of <see cref="IOpenApiExtension"/>.</param>
+        /// <param name="extensionKey">The key corresponding to the <see cref="IOpenApiExtension"/>.</param>
+        /// <returns>A <see cref="string"/> value matching the provided extensionKey. Return null when extensionKey is not found. </returns>
+        public static string GetExtension(this IDictionary<string, IOpenApiExtension> extensions, string extensionKey)
+        {
+            string extensionValue = null;
+            if (extensions.TryGetValue(extensionKey, out var value) && value != null)
+            {
+                extensionValue = (value as OpenApiString)?.Value;
+            }
+            return extensionValue;
+        }
+    }
+}

src/Microsoft.OpenApi.Hidi/Extensions/StringExtensions.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.OpenApi.Hidi.Extensions
+{
+    /// <summary>
+    /// Extension class for <see cref="string"/>.
+    /// </summary>
+    internal static class StringExtensions
+    {
+        /// <summary>
+        /// Checks if the specified searchValue is equal to the target string based on the specified <see cref="StringComparison"/>.
+        /// </summary>
+        /// <param name="target">The target string to commpare to.</param>
+        /// <param name="searchValue">The search string to seek.</param>
+        /// <param name="comparison">The <see cref="StringComparison"/> to use. This defaults to <see cref="StringComparison.OrdinalIgnoreCase"/>.</param>
+        /// <returns>true if the searchValue parameter occurs within this string; otherwise, false.</returns>
+        public static bool IsEquals(this string target, string searchValue, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
+        {
+            if (string.IsNullOrWhiteSpace(target) || string.IsNullOrWhiteSpace(searchValue))
+            {
+                return false;
+            }
+            return target.Equals(searchValue, comparison);
+        }
+
+        /// <summary>
+        /// Splits the target string in substrings based on the specified char separator.
+        /// </summary>
+        /// <param name="target">The target string to split by char. </param>
+        /// <param name="separator">The char separator.</param>
+        /// <returns>An <see cref="IList{String}"/> containing substrings.</returns>
+        public static IList<string> SplitByChar(this string target, char separator)
+        {
+            if (string.IsNullOrWhiteSpace(target))
+            {
+                return new List<string>();
+            }
+            return target.Split(new char[] { separator }, StringSplitOptions.RemoveEmptyEntries).ToList();
+        }
+    }
+}

src/Microsoft.OpenApi.Hidi/Formatters/PowerShellFormatter.cs

@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using System.Text.RegularExpressions;
 using Humanizer;
 using Humanizer.Inflections;
+using Microsoft.OpenApi.Hidi.Extensions;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Services;
 
@@ -29,7 +31,7 @@ static PowerShellFormatter()
             Vocabularies.Default.AddSingular("(statistics)$", "$1");
         }
 
-        //TODO: FHL for PS
+        //TODO: FHL taks for PS
         // Fixes (Order matters):
         // 1. Singularize operationId operationIdSegments.
         // 2. Add '_' to verb in an operationId.
@@ -50,9 +52,9 @@ public override void Visit(OpenApiSchema schema)
 
         public override void Visit(OpenApiPathItem pathItem)
         {
-            if (pathItem.Operations.ContainsKey(OperationType.Put))
+            if (pathItem.Operations.TryGetValue(OperationType.Put, out var value))
             {
-                var operationId = pathItem.Operations[OperationType.Put].OperationId;
+                var operationId = value.OperationId;
                 pathItem.Operations[OperationType.Put].OperationId = ResolvePutOperationId(operationId);
             }
 
@@ -61,55 +63,38 @@ public override void Visit(OpenApiPathItem pathItem)
 
         public override void Visit(OpenApiOperation operation)
         {
-            if (operation.OperationId == null)
+            if (string.IsNullOrWhiteSpace(operation.OperationId))
                 throw new ArgumentNullException(nameof(operation.OperationId), $"OperationId is required {PathString}");
 
             var operationId = operation.OperationId;
+            var operationTypeExtension = operation.Extensions.GetExtension("x-ms-docs-operation-type");
+            if (operationTypeExtension.IsEquals("function"))
+                operation.Parameters = ResolveFunctionParameters(operation.Parameters);
 
+            // Order matters. Resolve operationId.
             operationId = RemoveHashSuffix(operationId);
+            if (operationTypeExtension.IsEquals("action") || operationTypeExtension.IsEquals("function"))
+                operationId = RemoveKeyTypeSegment(operationId, operation.Parameters);
+            operationId = SingularizeAndDeduplicateOperationId(operationId.SplitByChar('.'));
             operationId = ResolveODataCastOperationId(operationId);
             operationId = ResolveByRefOperationId(operationId);
-
-
-            var operationIdSegments = operationId.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries).ToList();
-            operationId = SingularizeAndDeduplicateOperationId(operationIdSegments);
+            // Verb segment resolution should always be last. user.get -> user_Get
+            operationId = ResolveVerbSegmentInOpertationId(operationId);
 
             operation.OperationId = operationId;
             base.Visit(operation);
         }
 
-        private void AddAddtionalPropertiesToSchema(OpenApiSchema schema)
+        private static string ResolveVerbSegmentInOpertationId(string operationId)
         {
-            if (schema != null && !_schemaLoop.Contains(schema) && "object".Equals(schema?.Type, StringComparison.OrdinalIgnoreCase))
-            {
-                schema.AdditionalProperties = new OpenApiSchema() { Type = "object" };
-
-                /* Because 'additionalProperties' are now being walked,
-                 * we need a way to keep track of visited schemas to avoid
-                 * endlessly creating and walking them in an infinite recursion.
-                 */
-                _schemaLoop.Push(schema.AdditionalProperties);
-            }
-        }
-
-        private static void ResolveOneOfSchema(OpenApiSchema schema)
-        {
-            if (schema.OneOf?.Any() ?? false)
-            {
-                var newSchema = schema.OneOf.FirstOrDefault();
-                schema.OneOf = null;
-                FlattenSchema(schema, newSchema);
-            }
-        }
-
-        private static void ResolveAnyOfSchema(OpenApiSchema schema)
-        {
-            if (schema.AnyOf?.Any() ?? false)
-            {
-                var newSchema = schema.AnyOf.FirstOrDefault();
-                schema.AnyOf = null;
-                FlattenSchema(schema, newSchema);
-            }
+            var charPos = operationId.LastIndexOf('.', operationId.Length - 1);
+            if (operationId.Contains('_') || charPos < 0)
+                return operationId;
+            // TODO: Optimize this call.
+            var newOperationId = new StringBuilder(operationId);
+            newOperationId[charPos] = '_';
+            operationId = newOperationId.ToString();
+            return operationId;
         }
 
         private static string ResolvePutOperationId(string operationId)
@@ -158,6 +143,79 @@ private static string RemoveHashSuffix(string operationId)
             return s_hashSuffixRegex.Match(operationId).Value;
         }
 
+        private static string RemoveKeyTypeSegment(string operationId, IList<OpenApiParameter> parameters)
+        {
+            var segments = operationId.SplitByChar('.');
+            foreach (var parameter in parameters)
+            {
+                var keyTypeExtension = parameter.Extensions.GetExtension("x-ms-docs-key-type");
+                if (keyTypeExtension != null)
+                {
+                    if (operationId.Contains(keyTypeExtension))
+                    {
+                        segments.Remove(keyTypeExtension);
+                    }
+                }
+            }
+            return string.Join(".", segments);
+        }
+
+        private static IList<OpenApiParameter> ResolveFunctionParameters(IList<OpenApiParameter> parameters)
+        {
+            foreach (var parameter in parameters)
+            {
+                if (parameter.Content?.Any() ?? false)
+                {
+                    // Replace content with a schema object of type array
+                    // for structured or collection-valued function parameters
+                    parameter.Content = null;
+                    parameter.Schema = new OpenApiSchema
+                    {
+                        Type = "array",
+                        Items = new OpenApiSchema
+                        {
+                            Type = "string"
+                        }
+                    };
+                }
+            }
+            return parameters;
+        }
+
+        private void AddAddtionalPropertiesToSchema(OpenApiSchema schema)
+        {
+            if (schema != null && !_schemaLoop.Contains(schema) && "object".Equals(schema?.Type, StringComparison.OrdinalIgnoreCase))
+            {
+                schema.AdditionalProperties = new OpenApiSchema() { Type = "object" };
+
+                /* Because 'additionalProperties' are now being walked,
+                 * we need a way to keep track of visited schemas to avoid
+                 * endlessly creating and walking them in an infinite recursion.
+                 */
+                _schemaLoop.Push(schema.AdditionalProperties);
+            }
+        }
+
+        private static void ResolveOneOfSchema(OpenApiSchema schema)
+        {
+            if (schema.OneOf?.Any() ?? false)
+            {
+                var newSchema = schema.OneOf.FirstOrDefault();
+                schema.OneOf = null;
+                FlattenSchema(schema, newSchema);
+            }
+        }
+
+        private static void ResolveAnyOfSchema(OpenApiSchema schema)
+        {
+            if (schema.AnyOf?.Any() ?? false)
+            {
+                var newSchema = schema.AnyOf.FirstOrDefault();
+                schema.AnyOf = null;
+                FlattenSchema(schema, newSchema);
+            }
+        }
+
         private static void FlattenSchema(OpenApiSchema schema, OpenApiSchema newSchema)
         {
             if (newSchema != null)

src/Microsoft.OpenApi.Hidi/Handlers/TransformCommandHandler.cs

@@ -29,7 +29,6 @@ internal class TransformCommandHandler : ICommandHandler
         public Option<string> FilterByCollectionOption { get; set; }
         public Option<bool> InlineLocalOption { get; set; }
         public Option<bool> InlineExternalOption { get; set; }
-        public Option<string?> LanguageFormatOption { get; set; }
 
         public int Invoke(InvocationContext context)
         {
@@ -50,7 +49,6 @@ public async Task<int> InvokeAsync(InvocationContext context)
             LogLevel logLevel = context.ParseResult.GetValueForOption(LogLevelOption);
             bool inlineLocal = context.ParseResult.GetValueForOption(InlineLocalOption);
             bool inlineExternal = context.ParseResult.GetValueForOption(InlineExternalOption);
-            string? languageFormatOption = context.ParseResult.GetValueForOption(LanguageFormatOption);
             string filterbyoperationids = context.ParseResult.GetValueForOption(FilterByOperationIdsOption);
             string filterbytags = context.ParseResult.GetValueForOption(FilterByTagsOption);
             string filterbycollection = context.ParseResult.GetValueForOption(FilterByCollectionOption);
@@ -61,7 +59,7 @@ public async Task<int> InvokeAsync(InvocationContext context)
             var logger = loggerFactory.CreateLogger<OpenApiService>();
             try
             {
-                await OpenApiService.TransformOpenApiDocument(openapi, csdl, csdlFilter, output, cleanOutput, version, metadataVersion, format, terseOutput, settingsFile, inlineLocal, inlineExternal, languageFormatOption, filterbyoperationids, filterbytags, filterbycollection, logger, cancellationToken);
+                await OpenApiService.TransformOpenApiDocument(openapi, csdl, csdlFilter, output, cleanOutput, version, metadataVersion, format, terseOutput, settingsFile, inlineLocal, inlineExternal, filterbyoperationids, filterbytags, filterbycollection, logger, cancellationToken);
 
                 return 0;
             }

src/Microsoft.OpenApi.Hidi/OpenApiService.cs

@@ -48,7 +48,6 @@ public static async Task TransformOpenApiDocument(
             string settingsFile,
             bool inlineLocal,
             bool inlineExternal,
-            string? languageFormatOption,
             string filterbyoperationids,
             string filterbytags,
             string filterbycollection,
@@ -84,7 +83,9 @@ CancellationToken cancellationToken
 
                 OpenApiDocument document = await GetOpenApi(openapi, csdl, csdlFilter, settingsFile, inlineExternal, logger, cancellationToken, metadataVersion);
                 document = await FilterOpenApiDocument(filterbyoperationids, filterbytags, filterbycollection, document, logger, cancellationToken);
-                if (!string.IsNullOrWhiteSpace(languageFormatOption) && languageFormatOption.Equals("PowerShell", StringComparison.InvariantCultureIgnoreCase))
+
+                var languageFormat = GetConfiguration(settingsFile).GetSection("LanguageFormat").Value;
+                if (Extensions.StringExtensions.IsEquals(languageFormat, "PowerShell"))
                 {
                     // PowerShell Walker.
                     var powerShellFormatter = new PowerShellFormatter();

src/Microsoft.OpenApi.Hidi/Program.cs

@@ -73,9 +73,6 @@ internal static RootCommand CreateRootCommand()
             var inlineExternalOption = new Option<bool>("--inline-external", "Inline external $ref instances");
             inlineExternalOption.AddAlias("--ie");
 
-            // TODO: Move to settings file (--settings-path).
-            var languageFormatOption = new Option<string>("--language-style", "Language to format the OpenAPI document. e.g. powershell");
-
             var validateCommand = new Command("validate")
             {
                 descriptionOption,
@@ -105,8 +102,7 @@ internal static RootCommand CreateRootCommand()
                 filterByTagsOption,
                 filterByCollectionOption,
                 inlineLocalOption,
-                inlineExternalOption,
-                languageFormatOption
+                inlineExternalOption
             };
 
             transformCommand.Handler = new TransformCommandHandler
@@ -126,8 +122,7 @@ internal static RootCommand CreateRootCommand()
                 FilterByTagsOption = filterByTagsOption,
                 FilterByCollectionOption = filterByCollectionOption,
                 InlineLocalOption = inlineLocalOption,
-                InlineExternalOption = inlineExternalOption,
-                LanguageFormatOption = languageFormatOption
+                InlineExternalOption = inlineExternalOption
             };
 
             var showCommand = new Command("show")

src/Microsoft.OpenApi/Services/CopyReferences.cs

@@ -52,6 +52,16 @@ public override void Visit(IOpenApiReferenceable referenceable)
                     }
                     break;
 
+                case OpenApiRequestBody requestBody:
+                    EnsureComponentsExists();
+                    EnsureResponsesExists();
+                    EnsurRequestBodiesExists();
+                    if (!Components.RequestBodies.ContainsKey(requestBody.Reference.Id))
+                    {
+                        Components.RequestBodies.Add(requestBody.Reference.Id, requestBody);
+                    }
+                    break;
+
                 default:
                     break;
             }
@@ -108,5 +118,13 @@ private void EnsureResponsesExists()
                 _target.Components.Responses = new Dictionary<string, OpenApiResponse>();
             }
         }
+
+        private void EnsurRequestBodiesExists()
+        {
+            if (_target.Components.RequestBodies == null)
+            {
+                _target.Components.RequestBodies = new Dictionary<string, OpenApiRequestBody>();
+            }
+        }
     }
 }