Fix functions as object names in go snippets

CodeSnippetsReflection.OpenAPI.Test/GoGeneratorTests.cs

@@ -433,6 +433,20 @@ public async Task WritesEmptyPrimitiveArrays() {
             Assert.Contains("SetIncludeUserActions", result);
         }
         [Fact]
+        public async Task WriteCorrectFunctionNameWithParametersAsModelName()
+        {
+            const string messageObject = "{\r\n\"displayName\": \"Display name\"\r\n}";
+            using var requestPayload = new HttpRequestMessage(HttpMethod.Patch, $"{ServiceRootUrl}/applications(uniqueName='app-65278')")
+            {
+                Content = new StringContent(messageObject, Encoding.UTF8, "application/json")
+            };
+            requestPayload.Headers.Add("Prefer", "create-if-missing");
+            var snippetModel = new SnippetModel(requestPayload, ServiceRootUrl, await GetBetaSnippetMetadata());
+            var result = _generator.GenerateCodeSnippet(snippetModel);
+            Assert.Contains("graphapplicationswithuniquename \"github.com/microsoftgraph/msgraph-sdk-go/applicationswithuniquename\"", result);
+            Assert.Contains("graphapplicationswithuniquename.ApplicationsWithUniqueNameRequestBuilderPatchRequestConfiguration", result);
+        }
+        [Fact]
         public async Task WriteCorrectTypesForFilterParameters()
         {
             using var requestPayload = new HttpRequestMessage(HttpMethod.Get,

CodeSnippetsReflection.OpenAPI/LanguageGenerators/GoGenerator.cs

@@ -1,21 +1,19 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
 using System.Collections.Immutable;
+using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using CodeSnippetsReflection.OpenAPI.ModelGraph;
 using CodeSnippetsReflection.StringExtensions;
 using Microsoft.OpenApi.Services;
-using System.Text.RegularExpressions;
-using System.Collections;
 
 namespace CodeSnippetsReflection.OpenAPI.LanguageGenerators
 {
     public class GoGenerator : ILanguageGenerator<SnippetModel, OpenApiUrlTreeNode>
     {
         private const string clientVarName = "graphClient";
-        private const string clientVarType = "GraphServiceClientWithCredentials";
-        private const string clientFactoryVariables = "cred, scopes";
         private const string requestBodyVarName = "requestBody";
         private const string requestHeadersVarName = "headers";
         private const string optionsParameterVarName = "options";
@@ -29,6 +27,10 @@
 
         private static readonly Regex PropertyNameRegex = new Regex(@"@(.*)", RegexOptions.Compiled, TimeSpan.FromMilliseconds(200));
 
+        private static readonly Regex FunctionRegex = new Regex(@"(\w+)\(([^)]*)\)", RegexOptions.Compiled, TimeSpan.FromMilliseconds(200));
+
+        private static readonly Regex ParamRegex = new Regex(@"(\w+)\s*=\s*'[^']*'", RegexOptions.Compiled, TimeSpan.FromMilliseconds(200));
+
         static IImmutableSet<string> GetNativeTypes()
         {
             return ImmutableHashSet.Create("string", "int", "float");
@@ -142,9 +144,24 @@
 
         private static String ProcessNameSpaceName(String nameSpace)
         {
-            return (nameSpace != null ? nameSpace.Split(".", StringSplitOptions.RemoveEmptyEntries)
+            if (String.IsNullOrEmpty(nameSpace))
+                return "";
+
+            // process function names and parameters
+            var functionNameMatch = FunctionRegex.Match(nameSpace);
+            if (functionNameMatch.Success)
+            {
+                var paramMatches = ParamRegex.Matches(functionNameMatch.Groups[2].Value);
+                var paramNames = paramMatches.Cast<Match>().Select(static m => m.Groups[1].Value).ToList();
+
+                return functionNameMatch.Groups[1].Value + "With" + string.Join("With", paramNames);
+            }
+
+            var processedName = (nameSpace.Split(".", StringSplitOptions.RemoveEmptyEntries)
                 .Select(x => x.Equals("Me", StringComparison.OrdinalIgnoreCase) ? "Users" : x)
-                .Aggregate((current, next) => current + "." + next) : "models").Replace(".microsoft.graph", "");
+                .Aggregate(static (current, next) => current + "." + next)).Replace(".microsoft.graph", "");
+
+            return processedName;
         }
 
         private static String ProcessFinalNameSpaceName(String nameSpace)
@@ -182,7 +199,7 @@
         {
             if (property.Children != null && property.Children.Count != 0)
             {
                 var existingChild = property.Children.FirstOrDefault(x => x.PropertyType == propertyType);
                 return propertyType == existingChild.PropertyType;
             }
             return property.PropertyType == propertyType;
@@ -299,14 +316,14 @@
             var isCollection = nodes.First().Segment.IsCollectionIndex();
             var isSingleElement = nodes.Count() == 1;
 
             var filteredNodes = (isCollection && !isSingleElement) ? nodes.Skip(2) : isCollection ? nodes.Skip(1) : nodes; // skip first element if its not only element
             if (!(filteredNodes?.Any() ?? false)) return string.Empty;
             return filteredNodes.Select(static x =>
             {
                 if (x.Segment.IsCollectionIndex())
                     return "Item";
                 else
-                    return x.Segment.ToFirstCharacterUpperCase();
+                    return EscapeFunctionNames(x.Segment.ToFirstCharacterUpperCase());
             })
                         .Aggregate(static (x, y) =>
                         {
@@ -316,6 +333,22 @@
                         });
         }
 
+        private static string EscapeFunctionNames(String objectName)
+        {
+            if (String.IsNullOrEmpty(objectName))
+                return objectName;
+
+            var match = FunctionRegex.Match(objectName);
+            if (match.Success)
+            {
+                var paramMatches = ParamRegex.Matches(match.Groups[2].Value);
+                var paramNames = paramMatches.Cast<Match>().Select(static m => m.Groups[1].Value.ToFirstCharacterUpperCase()).ToList();
+
+                return match.Groups[1].Value + "With" + string.Join("With", paramNames);
+            }
+            return objectName;
+        }
+
         private static string evaluateParameter(CodeProperty param)
         {
             if (param.PropertyType == PropertyType.Array)
@@ -358,7 +391,7 @@
 
         private static string GetResultVarName(SnippetCodeGraph codeGraph)
         {
             var path = codeGraph.Nodes.LastOrDefault(x => !x.IsParameter)?.Path?.Split("\\").Last(static x => !string.IsNullOrWhiteSpace(x)).Split("(").First()
                 .Split(".")
                 .Select(static s => s.ToFirstCharacterUpperCase())
                 .Aggregate(static (a, b) => $"{a}{b}")
@@ -423,7 +456,7 @@
                 builder.AppendLine(objectBuilder.ToString());
             }
 
             var typeDefinition = codeProperty.TypeDefinition?.ToLowerInvariant()?.Trim();
 
             String typeName;
             if (NativeTypes.Contains(typeDefinition))
@@ -447,7 +480,7 @@
 
         }
 
         private static void WriteCodeProperty(string propertyAssignment, StringBuilder builder, CodeProperty codeProperty, CodeProperty child, IndentManager indentManager, int childPosition = 0, bool declarationOnly = false)
         {
             var isArray = codeProperty.PropertyType == PropertyType.Array;
             var isMap = codeProperty.PropertyType == PropertyType.Map;
@@ -606,7 +639,7 @@
                         .Aggregate(new List<String>(), (current, next) =>
                         {
                             var element = next.Contains("ByTypeId", StringComparison.OrdinalIgnoreCase) ?
                             next.Replace("ByTypeId", $"By{current.Last().Replace("s().", string.Empty, StringComparison.OrdinalIgnoreCase)}Id") :
                             $"{next.Replace("$", string.Empty, StringComparison.OrdinalIgnoreCase).ToFirstCharacterUpperCase()}";
 
                             current.Add(element);