majorly cleaned up language handling

jsinglet · jsinglet · commit 786d3b092af6 · 2023-09-06T13:27:39.000-04:00
diff --git a/src/CodeQLToolkit.Features.Query/Scaffolding/QueryScaffoldFeature.cs b/src/CodeQLToolkit.Features.Query/Scaffolding/QueryScaffoldFeature.cs
@@ -1,6 +1,7 @@
 ﻿using CodeQLToolkit.Features.Query.Scaffolding.Targets;
 using CodeQLToolkit.Shared.Feature;
 using CodeQLToolkit.Shared.Options;
+using CodeQLToolkit.Shared.Utils;
 using System.CommandLine;
 
 namespace CodeQLToolkit.Features.Query.Scaffolding
@@ -10,7 +11,7 @@ public class QueryScaffoldFeature : FeatureBase, IToolkitScaffoldingFeature
         public QueryScaffoldFeature() {
             FeatureName = "Query";
         }
-        public override string[] SupportedLangauges { get => new string[] { "c", "cpp", "javascript" }; }
+        public override LanguageType[] SupportedLangauges { get => new LanguageType[] { LanguageType.C, LanguageType.CPP, LanguageType.JAVASCRIPT}; }
 
         public void Register(Command parentCommand)
         {
@@ -27,7 +28,8 @@ public void Register(Command parentCommand)
 
             var createTestsOption = new Option<bool>("--create-tests", ()=> true, "Create a new unit test for this query if it doesn't already exist.");
             var queryNameOption = new Option<string>("--query-name", "Name of the query. Note: Do not specify the `.ql` extension in naming your query.") { IsRequired = true };
-            var queryLanguageOption = new Option<string>("--language", $"The language to generate a query for.") { IsRequired = true}.FromAmong(SupportedLangauges);
+            var queryLanguageOption = new Option<string>("--language", $"The language to generate a query for.") { IsRequired = true}
+            .FromAmong(SupportedLangauges.Select(x => x.ToOptionString()).ToArray());
             var queryPackOption = new Option<string>("--pack", "The name of the query pack to place this query in.") { IsRequired = true };
             var queryPackScopeOption = new Option<string>("--scope", "The scope to use") { IsRequired = true };
 
@@ -53,7 +55,7 @@ public void Register(Command parentCommand)
                     new NewQueryScaffoldTarget()
                     {
                         Name = queryName,
-                        Language = queryLangauge,
+                        Language = LanguageTypeHelper.LanguageTypeFromOptionString(queryLangauge),
                         Base = basePath,
                         QueryPack = queryPack,
                         QueryPackScope = queryPackScope,
diff --git a/src/CodeQLToolkit.Features.Test/Commands/TestCommandFeature.cs b/src/CodeQLToolkit.Features.Test/Commands/TestCommandFeature.cs
@@ -1,6 +1,7 @@
 ﻿using CodeQLToolkit.Features.Test.Commands.Targets;
 using CodeQLToolkit.Features.Test.Lifecycle;
 using CodeQLToolkit.Shared.Types;
+using CodeQLToolkit.Shared.Utils;
 using Microsoft.VisualBasic;
 using System;
 using System.Collections.Generic;
@@ -13,7 +14,16 @@ namespace CodeQLToolkit.Features.Test.Commands
 {
     public class TestCommandFeature : FeatureBase, IToolkitLifecycleFeature
     {
-        public override string[] SupportedLangauges { get => new string[] { "c", "cpp", "javascript", "go", "python", "ql", "java", "ruby" }; }
+        public override LanguageType[] SupportedLangauges { get => new LanguageType[] { 
+            LanguageType.C,
+            LanguageType.CPP,
+            LanguageType.CSHARP,
+            LanguageType.JAVA,
+            LanguageType.JAVASCRIPT,
+            LanguageType.GO,
+            LanguageType.RUBY,
+            LanguageType.PYTHON            
+        }; }
 
         public TestCommandFeature()
         {
@@ -39,7 +49,7 @@ public void Register(Command parentCommand)
             
             var numThreadsOption = new Option<int>("--num-threads", () => 4, "The number of threads to use for runner. For best performance, do not exceed the number of physical cores on your system.") { IsRequired = true };
             var workDirectoryOption = new Option<string>("--work-dir", () => Path.GetTempPath(), "Where to place intermediate execution output files.") { IsRequired = true };
-            var languageOption = new Option<string>("--language", $"The language to run tests for.") { IsRequired = true }.FromAmong(SupportedLangauges);
+            var languageOption = new Option<string>("--language", $"The language to run tests for.") { IsRequired = true }.FromAmong(SupportedLangauges.Select(x => x.ToOptionString()).ToArray());
             var runnerOSOption = new Option<string>("--runner-os", $"Label for the operating system running these tests.") { IsRequired = true };
             var cliVersionOption = new Option<string>("--cli-version", $"The version of the cli running the tests.") { IsRequired = true };
             var stdLibIdentOption = new Option<string>("--stdlib-ident", $"A string identifying the standard library used.") { IsRequired = true };
diff --git a/src/CodeQLToolkit.Features.Test/Lifecycle/TestLifecycleFeature.cs b/src/CodeQLToolkit.Features.Test/Lifecycle/TestLifecycleFeature.cs
@@ -1,5 +1,6 @@
 ﻿using CodeQLToolkit.Features.Test.Lifecycle.Targets;
 using CodeQLToolkit.Features.Test.Lifecycle.Targets.Actions;
+using CodeQLToolkit.Shared.Utils;
 using System.CommandLine;
 using System.Reflection;
 
@@ -12,7 +13,19 @@ public TestLifecycleFeature()
             FeatureName = "Test";
         }
 
-        public override string[] SupportedLangauges { get => new string[] { "c", "cpp", "javascript", "go", "python", "ql", "java", "ruby" }; }
+        public override LanguageType[] SupportedLangauges
+        {
+            get => new LanguageType[] {
+            LanguageType.C,
+            LanguageType.CPP,
+            LanguageType.CSHARP,
+            LanguageType.JAVA,
+            LanguageType.JAVASCRIPT,
+            LanguageType.GO,
+            LanguageType.RUBY,
+            LanguageType.PYTHON
+        };
+        }
 
         public void Register(Command parentCommand)
         {
@@ -23,7 +36,7 @@ public void Register(Command parentCommand)
             var overwriteExistingOption = new Option<bool>("--overwrite-existing", () => false, "Overwrite exiting files (if they exist).");
             var numThreadsOption = new Option<int>("--num-threads", () => 4, "Number of threads to use during test execution.");
             var useRunnerOption = new Option<string>("--use-runner", () => "ubuntu-latest", "The runner(s) to use. Should be a comma-seperated list of actions runners.");
-            var languageOption = new Option<string>("--language", $"The language to generate automation for.") { IsRequired = true }.FromAmong(SupportedLangauges);
+            var languageOption = new Option<string>("--language", $"The language to generate automation for.") { IsRequired = true }.FromAmong(SupportedLangauges.Select(x => x.ToOptionString()).ToArray());
 
             initCommand.AddOption(overwriteExistingOption);
             initCommand.AddOption(numThreadsOption);
diff --git a/src/CodeQLToolkit.Shared/Feature/FeatureBase.cs b/src/CodeQLToolkit.Shared/Feature/FeatureBase.cs
@@ -12,8 +12,14 @@ abstract public class FeatureBase
     {
         public string FeatureName { get; set; }
 
-        public virtual string[] SupportedLangauges { get; } = { };
+        public virtual LanguageType[] SupportedLangauges { get; } = { };
         public bool IsSupportedLangauge(string language)
+        {
+            var strLangauges = SupportedLangauges.Select(x => x.ToOptionString()).ToArray();
+            return strLangauges.Contains(language);
+        }
+
+        public bool IsSupportedLangauge(LanguageType language)
         {
             return SupportedLangauges.Contains(language);
         }
diff --git a/src/CodeQLToolkit.Shared/Target/ScaffoldTarget.cs b/src/CodeQLToolkit.Shared/Target/ScaffoldTarget.cs
@@ -1,5 +1,6 @@
 ﻿using CodeQLToolkit.Shared.Logging;
 using CodeQLToolkit.Shared.Template;
+using CodeQLToolkit.Shared.Utils;
 using Microsoft.Extensions.Logging;
 
 namespace CodeQLToolkit.Shared.Target
@@ -8,7 +9,7 @@ public abstract class ScaffoldTarget : ITarget
     {
        
         public string Name { get; set; }
-        public string Language { get; set; }
+        public LanguageType Language { get; set; }
         public bool OverwriteExisting { get; set; }
         public string FeatureName { get; set; }
 
@@ -18,12 +19,7 @@ public string GetTemplatePathForLanguage(string templateName)
         {
             var languagePath = Language;
 
-            if(languagePath == "c")
-            {
-                languagePath = "cpp";
-
-            }
-            return Path.Combine("Templates", FeatureName, languagePath, templateName + ".liquid");
+            return Path.Combine("Templates", FeatureName, Language.ToDirectory(), templateName + ".liquid");
         }
 
         
diff --git a/src/CodeQLToolkit.Shared/Utils/Language.cs b/src/CodeQLToolkit.Shared/Utils/Language.cs
@@ -0,0 +1,239 @@
+﻿using CodeQLToolkit.Shared.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CodeQLToolkit.Shared.Utils
+{
+    public enum LanguageType
+    {
+        C,
+        CPP,
+        JAVASCRIPT,
+        GO,
+        RUBY,
+        PYTHON,
+        JAVA,
+        CSHARP
+    }
+
+    public static class LanguageTypeMethods
+    {
+        public static LanguageType FromOptionString(this LanguageType LanguageType, string value)
+        {
+            if (value.ToLower().Equals("c"))
+            {
+                return LanguageType.C;
+            }
+
+            if (value.ToLower().Equals("cpp"))
+            {
+                return LanguageType.CPP;
+            }
+
+            if (value.ToLower().Equals("javascript"))
+            {
+                return LanguageType.JAVASCRIPT;
+            }
+
+            if (value.ToLower().Equals("go"))
+            {
+                return LanguageType.GO;
+            }
+
+            if (value.ToLower().Equals("ruby"))
+            {
+                return LanguageType.RUBY;
+            }
+
+            if (value.ToLower().Equals("java"))
+            {
+                return LanguageType.JAVA;
+            }
+
+            if (value.ToLower().Equals("csharp"))
+            {
+                return LanguageType.CSHARP;
+            }
+
+            throw new NotImplementedException();
+        }
+
+
+        public static string ToOptionString(this LanguageType LanguageType)
+        {
+            if (LanguageType == LanguageType.C)
+            {
+                return "c";
+            }
+
+            if (LanguageType == LanguageType.CPP)
+            {
+                return "cpp";
+            }
+
+            if (LanguageType == LanguageType.JAVASCRIPT)
+            {
+                return "javascript";
+            }
+            if (LanguageType == LanguageType.GO)
+            {
+                return "go";
+            }
+            if (LanguageType == LanguageType.RUBY)
+            {
+                return "ruby";
+            }
+            if (LanguageType == LanguageType.PYTHON)
+            {
+                return "python";
+            }
+            if (LanguageType == LanguageType.JAVA)
+            {
+                return "java";
+            }
+            if (LanguageType == LanguageType.CSHARP)
+            {
+                return "csharp";
+            }
+
+            throw new NotImplementedException();
+        }
+
+
+        public static string ToDirectory(this LanguageType LanguageType)
+        {
+            if (LanguageType == LanguageType.C)
+            {
+                return "cpp";
+            }
+
+            if (LanguageType == LanguageType.CPP)
+            {
+                return "cpp";
+            }
+
+            if (LanguageType == LanguageType.JAVASCRIPT)
+            {
+                return "javascript";
+            }
+            if (LanguageType == LanguageType.GO)
+            {
+                return "go";
+            }
+            if (LanguageType == LanguageType.RUBY)
+            {
+                return "ruby";
+            }
+            if (LanguageType == LanguageType.PYTHON)
+            {
+                return "python";
+            }
+            if (LanguageType == LanguageType.JAVA)
+            {
+                return "java";
+            }
+            if (LanguageType == LanguageType.CSHARP)
+            {
+                return "csharp";
+            }
+
+            throw new NotImplementedException();
+        }
+
+        public static string ToImport(this LanguageType LanguageType)
+        {
+            if (LanguageType == LanguageType.C)
+            {
+                return "cpp";
+            }
+
+            if (LanguageType == LanguageType.CPP)
+            {
+                return "cpp";
+            }
+
+            if (LanguageType == LanguageType.JAVASCRIPT)
+            {
+                return "javascript";
+            }
+            if (LanguageType == LanguageType.GO)
+            {
+                return "go";
+            }
+            if (LanguageType == LanguageType.RUBY)
+            {
+                return "ruby";
+            }
+            if (LanguageType == LanguageType.PYTHON)
+            {
+                return "python";
+            }
+            if (LanguageType == LanguageType.JAVA)
+            {
+                return "java";
+            }
+            if (LanguageType == LanguageType.CSHARP)
+            {
+                return "csharp";
+            }
+
+            throw new NotImplementedException();
+        }
+
+
+        public static string ToExtension(this LanguageType LanguageType)
+        {
+            if (LanguageType == LanguageType.C)
+            {
+                return "c";
+            }
+
+            if(LanguageType == LanguageType.CPP)
+            {
+                return "cpp";
+            }
+
+            if(LanguageType == LanguageType.JAVASCRIPT)
+            {
+                return "js";
+            }
+            if(LanguageType == LanguageType.GO)
+            {
+                return "go";
+            }
+            if(LanguageType == LanguageType.RUBY)
+            {
+                return "rb";
+            }
+            if(LanguageType == LanguageType.PYTHON)
+            {
+                return "py";
+            }
+            if(LanguageType == LanguageType.JAVA) 
+            {
+                return "java";            
+            }
+            if (LanguageType == LanguageType.CSHARP)
+            {
+                return "cs";
+            }
+
+
+            throw new NotImplementedException();
+        }
+
+    }
+
+
+    public class LanguageTypeHelper
+    {
+        public static LanguageType LanguageTypeFromOptionString(string LanguageType)
+        {
+            return new LanguageType().FromOptionString(LanguageType);
+        }
+    }
+
+}
diff --git a/src/CodeQLToolkit.Shared/Utils/Query.cs b/src/CodeQLToolkit.Shared/Utils/Query.cs

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,14 @@ abstract public class FeatureBase`
`12`	`12`	`{`
`13`	`13`	`public string FeatureName { get; set; }`
`14`	`14`
`15`		`- public virtual string[] SupportedLangauges { get; } = { };`
	`15`	`+ public virtual LanguageType[] SupportedLangauges { get; } = { };`
`16`	`16`	`public bool IsSupportedLangauge(string language)`
	`17`	`+ {`
	`18`	`+ var strLangauges = SupportedLangauges.Select(x => x.ToOptionString()).ToArray();`
	`19`	`+ return strLangauges.Contains(language);`
	`20`	`+ }`
	`21`	`+`
	`22`	`+ public bool IsSupportedLangauge(LanguageType language)`
`17`	`23`	`{`
`18`	`24`	`return SupportedLangauges.Contains(language);`
`19`	`25`	`}`