- refactors refiners

src/kiota.core/KiotaBuilder.cs

@@ -132,50 +132,12 @@ public void ApplyLanguageRefinement(GenerationLanguage language, CodeNamespace g
             var stopwatch = new Stopwatch();
             stopwatch.Start();
 
-            // TODO: Refactor into something more scaleable
-            switch (language)
-            {
-                case GenerationLanguage.CSharp:
-                    generatedCode.AddUsing(new CodeUsing() { Name = "System" });
-                    generatedCode.AddUsing(new CodeUsing() { Name = "System.Threading.Tasks" });
-                    AddInnerClasses(generatedCode);
-                    break;
-                case GenerationLanguage.TypeScript:
-                    AddRelativeImports(generatedCode);
-                    break;
-                case GenerationLanguage.Java:
-                    AddInnerClasses(generatedCode);
-                    break;
-                default:
-                    break; //Do nothing
-            }
+            ILanguageRefiner.Refine(language, generatedCode);
 
             stopwatch.Stop();
             logger.LogInformation("{timestamp}ms: Language refinement applied", stopwatch.ElapsedMilliseconds);
         }
 
-        private void AddRelativeImports(CodeElement current) {
-            if(current is CodeClass currentClass) {
-                currentClass.AddUsing(current
-                                    .GetChildElements()
-                                    .OfType<CodeProperty>()
-                                    .Select(x =>x.Type.Name)
-                                    .Distinct()
-                                    .Select(x => new CodeUsing{Name = x})
-                                    .ToArray());
-            }
-            foreach(var childClass in current.GetChildElements().OfType<CodeClass>())
-                AddRelativeImports(childClass);
-        }
-        private void AddInnerClasses(CodeElement current) {
-            if(current is CodeClass currentClass) {
-                foreach(var parameter in current.GetChildElements().OfType<CodeMethod>().SelectMany(x =>x.Parameters).Where(x => x.Type.ActionOf))
-                    currentClass.AddInnerClass(parameter.Type.TypeDefinition);
-            }
-            foreach(var childClass in current.GetChildElements().OfType<CodeClass>())
-                AddInnerClasses(childClass);
-        }
-
         /// <summary>
         /// Iterate through Url Space and create request builder classes for each node in the tree
         /// </summary>

src/kiota.core/Refiners/CSharpRefiner.cs

@@ -0,0 +1,13 @@
+using System.Linq;
+
+namespace kiota.core {
+    public class CSharpRefiner : CommonLanguageRefiner, ILanguageRefiner
+    {
+        public override void Refine(CodeNamespace generatedCode)
+        {
+            generatedCode.AddUsing(new CodeUsing() { Name = "System" });
+            generatedCode.AddUsing(new CodeUsing() { Name = "System.Threading.Tasks" });
+            AddInnerClasses(generatedCode);
+        }
+    }
+}

src/kiota.core/Refiners/CommonLanaguageRefiner.cs

@@ -0,0 +1,17 @@
+using System.Linq;
+
+namespace kiota.core {
+    public abstract class CommonLanguageRefiner : ILanguageRefiner
+    {
+        public abstract void Refine(CodeNamespace generatedCode);
+
+        internal void AddInnerClasses(CodeElement current) {
+            if(current is CodeClass currentClass) {
+                foreach(var parameter in current.GetChildElements().OfType<CodeMethod>().SelectMany(x =>x.Parameters).Where(x => x.Type.ActionOf))
+                    currentClass.AddInnerClass(parameter.Type.TypeDefinition);
+            }
+            foreach(var childClass in current.GetChildElements().OfType<CodeClass>())
+                AddInnerClasses(childClass);
+        }
+    }
+}

src/kiota.core/Refiners/ILanguageRefiner.cs

@@ -0,0 +1,23 @@
+namespace kiota.core
+{
+    public interface ILanguageRefiner
+    {
+        void Refine(CodeNamespace generatedCode);
+        public static void Refine(GenerationLanguage language, CodeNamespace generatedCode) {
+            switch (language)
+            {
+                case GenerationLanguage.CSharp:
+                    new CSharpRefiner().Refine(generatedCode);
+                    break;
+                case GenerationLanguage.TypeScript:
+                    new TypeScriptRefiner().Refine(generatedCode);
+                    break;
+                case GenerationLanguage.Java:
+                    new JavaRefiner().Refine(generatedCode);
+                    break;
+                default:
+                    break; //Do nothing
+            }
+        }
+    }
+}

src/kiota.core/Refiners/JavaRefiner.cs

@@ -0,0 +1,9 @@
+namespace kiota.core {
+    public class JavaRefiner : CommonLanguageRefiner, ILanguageRefiner
+    {
+        public override void Refine(CodeNamespace generatedCode)
+        {
+            AddInnerClasses(generatedCode);
+        }
+    }
+}

src/kiota.core/Refiners/TypeScriptRefiner.cs

@@ -0,0 +1,24 @@
+using System.Linq;
+
+namespace kiota.core {
+    public class TypeScriptRefiner : ILanguageRefiner
+    {
+        public void Refine(CodeNamespace generatedCode)
+        {
+            AddRelativeImports(generatedCode);
+        }
+        private void AddRelativeImports(CodeElement current) {
+            if(current is CodeClass currentClass) {
+                currentClass.AddUsing(current
+                                    .GetChildElements()
+                                    .OfType<CodeProperty>()
+                                    .Select(x =>x.Type.Name)
+                                    .Distinct()
+                                    .Select(x => new CodeUsing{Name = x})
+                                    .ToArray());
+            }
+            foreach(var childClass in current.GetChildElements().OfType<CodeClass>())
+                AddRelativeImports(childClass);
+        }
+    }
+}