From da1f555652af42a42bbb54a32a858123dc4543b7 Mon Sep 17 00:00:00 2001 From: Vincent Biret Date: Tue, 29 Dec 2020 15:45:38 -0500 Subject: [PATCH 1/2] - refactors refiners --- src/kiota.core/KiotaBuilder.cs | 40 +------------------- src/kiota.core/Refiners/CSharpRefiner.cs | 21 ++++++++++ src/kiota.core/Refiners/ILanguageRefiner.cs | 24 ++++++++++++ src/kiota.core/Refiners/TypeScriptRefiner.cs | 24 ++++++++++++ 4 files changed, 70 insertions(+), 39 deletions(-) create mode 100644 src/kiota.core/Refiners/CSharpRefiner.cs create mode 100644 src/kiota.core/Refiners/ILanguageRefiner.cs create mode 100644 src/kiota.core/Refiners/TypeScriptRefiner.cs diff --git a/src/kiota.core/KiotaBuilder.cs b/src/kiota.core/KiotaBuilder.cs index 4eb9a29ba2..cb965e315f 100644 --- a/src/kiota.core/KiotaBuilder.cs +++ b/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() - .Select(x =>x.Type.Name) - .Distinct() - .Select(x => new CodeUsing{Name = x}) - .ToArray()); - } - foreach(var childClass in current.GetChildElements().OfType()) - AddRelativeImports(childClass); - } - private void AddInnerClasses(CodeElement current) { - if(current is CodeClass currentClass) { - foreach(var parameter in current.GetChildElements().OfType().SelectMany(x =>x.Parameters).Where(x => x.Type.ActionOf)) - currentClass.AddInnerClass(parameter.Type.TypeDefinition); - } - foreach(var childClass in current.GetChildElements().OfType()) - AddInnerClasses(childClass); - } - /// /// Iterate through Url Space and create request builder classes for each node in the tree /// diff --git a/src/kiota.core/Refiners/CSharpRefiner.cs b/src/kiota.core/Refiners/CSharpRefiner.cs new file mode 100644 index 0000000000..aafb302051 --- /dev/null +++ b/src/kiota.core/Refiners/CSharpRefiner.cs @@ -0,0 +1,21 @@ +using System.Linq; + +namespace kiota.core { + public class CSharpRefiner : ILanguageRefiner + { + public void Refine(CodeNamespace generatedCode) + { + generatedCode.AddUsing(new CodeUsing() { Name = "System" }); + generatedCode.AddUsing(new CodeUsing() { Name = "System.Threading.Tasks" }); + AddInnerClasses(generatedCode); + } + private void AddInnerClasses(CodeElement current) { + if(current is CodeClass currentClass) { + foreach(var parameter in current.GetChildElements().OfType().SelectMany(x =>x.Parameters).Where(x => x.Type.ActionOf)) + currentClass.AddInnerClass(parameter.Type.TypeDefinition); + } + foreach(var childClass in current.GetChildElements().OfType()) + AddInnerClasses(childClass); + } + } +} diff --git a/src/kiota.core/Refiners/ILanguageRefiner.cs b/src/kiota.core/Refiners/ILanguageRefiner.cs new file mode 100644 index 0000000000..d77d43ea2a --- /dev/null +++ b/src/kiota.core/Refiners/ILanguageRefiner.cs @@ -0,0 +1,24 @@ +namespace kiota.core +{ + public interface ILanguageRefiner + { + void Refine(CodeNamespace generatedCode); + public static void Refine(GenerationLanguage language, CodeNamespace generatedCode) { + var csRefiner = new CSharpRefiner(); + switch (language) + { + case GenerationLanguage.CSharp: + csRefiner.Refine(generatedCode); + break; + case GenerationLanguage.TypeScript: + new TypeScriptRefiner().Refine(generatedCode); + break; + case GenerationLanguage.Java: + csRefiner.Refine(generatedCode); + break; + default: + break; //Do nothing + } + } + } +} diff --git a/src/kiota.core/Refiners/TypeScriptRefiner.cs b/src/kiota.core/Refiners/TypeScriptRefiner.cs new file mode 100644 index 0000000000..cd2552279f --- /dev/null +++ b/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() + .Select(x =>x.Type.Name) + .Distinct() + .Select(x => new CodeUsing{Name = x}) + .ToArray()); + } + foreach(var childClass in current.GetChildElements().OfType()) + AddRelativeImports(childClass); + } + } +} From 8ec2d3396586d8c74f6a17316b5f835e840fedc5 Mon Sep 17 00:00:00 2001 From: Vincent Biret Date: Tue, 29 Dec 2020 15:53:59 -0500 Subject: [PATCH 2/2] - fixes an issue where java refiner would introduce undesired usings --- src/kiota.core/Refiners/CSharpRefiner.cs | 12 ++---------- .../Refiners/CommonLanaguageRefiner.cs | 17 +++++++++++++++++ src/kiota.core/Refiners/ILanguageRefiner.cs | 5 ++--- src/kiota.core/Refiners/JavaRefiner.cs | 9 +++++++++ 4 files changed, 30 insertions(+), 13 deletions(-) create mode 100644 src/kiota.core/Refiners/CommonLanaguageRefiner.cs create mode 100644 src/kiota.core/Refiners/JavaRefiner.cs diff --git a/src/kiota.core/Refiners/CSharpRefiner.cs b/src/kiota.core/Refiners/CSharpRefiner.cs index aafb302051..2127983fc7 100644 --- a/src/kiota.core/Refiners/CSharpRefiner.cs +++ b/src/kiota.core/Refiners/CSharpRefiner.cs @@ -1,21 +1,13 @@ using System.Linq; namespace kiota.core { - public class CSharpRefiner : ILanguageRefiner + public class CSharpRefiner : CommonLanguageRefiner, ILanguageRefiner { - public void Refine(CodeNamespace generatedCode) + public override void Refine(CodeNamespace generatedCode) { generatedCode.AddUsing(new CodeUsing() { Name = "System" }); generatedCode.AddUsing(new CodeUsing() { Name = "System.Threading.Tasks" }); AddInnerClasses(generatedCode); } - private void AddInnerClasses(CodeElement current) { - if(current is CodeClass currentClass) { - foreach(var parameter in current.GetChildElements().OfType().SelectMany(x =>x.Parameters).Where(x => x.Type.ActionOf)) - currentClass.AddInnerClass(parameter.Type.TypeDefinition); - } - foreach(var childClass in current.GetChildElements().OfType()) - AddInnerClasses(childClass); - } } } diff --git a/src/kiota.core/Refiners/CommonLanaguageRefiner.cs b/src/kiota.core/Refiners/CommonLanaguageRefiner.cs new file mode 100644 index 0000000000..94d085cfab --- /dev/null +++ b/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().SelectMany(x =>x.Parameters).Where(x => x.Type.ActionOf)) + currentClass.AddInnerClass(parameter.Type.TypeDefinition); + } + foreach(var childClass in current.GetChildElements().OfType()) + AddInnerClasses(childClass); + } + } +} diff --git a/src/kiota.core/Refiners/ILanguageRefiner.cs b/src/kiota.core/Refiners/ILanguageRefiner.cs index d77d43ea2a..636094afbd 100644 --- a/src/kiota.core/Refiners/ILanguageRefiner.cs +++ b/src/kiota.core/Refiners/ILanguageRefiner.cs @@ -4,17 +4,16 @@ public interface ILanguageRefiner { void Refine(CodeNamespace generatedCode); public static void Refine(GenerationLanguage language, CodeNamespace generatedCode) { - var csRefiner = new CSharpRefiner(); switch (language) { case GenerationLanguage.CSharp: - csRefiner.Refine(generatedCode); + new CSharpRefiner().Refine(generatedCode); break; case GenerationLanguage.TypeScript: new TypeScriptRefiner().Refine(generatedCode); break; case GenerationLanguage.Java: - csRefiner.Refine(generatedCode); + new JavaRefiner().Refine(generatedCode); break; default: break; //Do nothing diff --git a/src/kiota.core/Refiners/JavaRefiner.cs b/src/kiota.core/Refiners/JavaRefiner.cs new file mode 100644 index 0000000000..021264a4d6 --- /dev/null +++ b/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); + } + } +}