Refactoring

Author: ErikSchierboom

generators.new/CanonicalData.cs

@@ -17,28 +17,29 @@ internal record TestCase(
     dynamic Error,
     string[] Path);
 
-internal static class CanonicalData
+internal record CanonicalData(Exercise Exercise, TestCase[] TestCases);
+
+internal static class CanonicalDataParser
 {
-    static CanonicalData() => ProbSpecs.Sync();
+    static CanonicalDataParser() => ProbSpecs.Sync();
+    
+    internal static CanonicalData Parse(Exercise exercise) => new(exercise, ParseTestCases(exercise));
 
-    internal static TestCase[] Parse(Exercise exercise)
+    private static TestCase[] ParseTestCases(Exercise exercise)
     {
-        var json = File.ReadAllText(Paths.CanonicalDataFile(exercise));
-        var jsonObject = JObject.Parse(json);
-        return Parse(jsonObject, ImmutableQueue<string>.Empty)
-            .ToArray();
+        var jsonObject = JObject.Parse(File.ReadAllText(Paths.CanonicalDataFile(exercise)));
+        return ParseTestCases(jsonObject, ImmutableQueue<string>.Empty).ToArray();
     }
 
-    private static IEnumerable<TestCase> Parse(JObject jsonObject, ImmutableQueue<string> path)
+    private static IEnumerable<TestCase> ParseTestCases(JObject jsonObject, ImmutableQueue<string> path)
     {
         var updatedPath = jsonObject.TryGetValue("description", out var description)
             ? path.Enqueue(description.Value<string>()!)
             : path;
 
-        if (jsonObject.TryGetValue("cases", out var cases))
-            return ((JArray)cases).Cast<JObject>().SelectMany(child => Parse(child, updatedPath));
-        
-        return [ToTestCase(jsonObject, updatedPath)];
+        return jsonObject.TryGetValue("cases", out var cases)
+            ? ((JArray)cases).Cast<JObject>().SelectMany(child => ParseTestCases(child, updatedPath))
+            : [ToTestCase(jsonObject, updatedPath)];
     }
 
     private static TestCase ToTestCase(JObject testCaseJson, IEnumerable<string> path)

generators.new/Exercises.cs

@@ -6,17 +6,14 @@ internal record Exercise(string Slug, string Name);
 
 internal static class Exercises
 {
-    internal static Exercise[] TemplatedExercises(string? slug) =>
-        slug is null ? TemplatedExercises() : [TemplatedExercise(slug)];
-
-    private static Exercise[] TemplatedExercises() =>
+    internal static Exercise[] TemplatedExercises() =>
         Directory.EnumerateFiles(Paths.PracticeExercisesDir, "Generator.tpl", SearchOption.AllDirectories)
             .Select(templateFile => Directory.GetParent(templateFile)!.Parent!.Name)
             .Select(ToExercise)
             .OrderBy(exercise => exercise.Slug)
             .ToArray();
 
-    private static Exercise TemplatedExercise(string slug)
+    internal static Exercise TemplatedExercise(string slug)
     {
         var exercise = ToExercise(slug);
 

generators.new/Program.cs

@@ -14,7 +14,12 @@ static void Main(string[] args) =>
         Parser.Default.ParseArguments<Options>(args)
             .WithParsed(options =>
             {
-                foreach (var exercise in Exercises.TemplatedExercises(options.Exercise))
-                    TestGenerator.GenerateTests(exercise);
+                foreach (var exercise in Exercises(options))
+                    TestsGenerator.Generate(exercise);
             });
+
+    private static Exercise[] Exercises(Options options) =>
+        options.Exercise is null
+            ? Generators.Exercises.TemplatedExercises()
+            : [Generators.Exercises.TemplatedExercise(options.Exercise)];
 }

generators.new/Templates.cs

@@ -42,18 +42,18 @@ static Templates()
         });
     }
 
-    public static string RenderTests(Exercise exercise, TestCase[] testCases) =>
-        CompileTemplate(exercise)(ToTemplateData(exercise, testCases));
+    public static string RenderTestsCode(CanonicalData canonicalData) =>
+        CompileTemplate(canonicalData.Exercise)(ToTemplateData(canonicalData));
 
     private static HandlebarsTemplate<object, object> CompileTemplate(Exercise exercise) =>
         HandlebarsContext.Compile(File.ReadAllText(Paths.TemplateFile(exercise)));
 
-    private static Dictionary<string, object> ToTemplateData(Exercise exercise, TestCase[] testCases) =>
+    private static Dictionary<string, object> ToTemplateData(CanonicalData canonicalData) =>
         new()
         {
-            { "exercise", exercise },
-            { "test_cases", testCases },
-            { "test_cases_by_property", GroupTestCasesByProperty(testCases)}
+            { "exercise", canonicalData.Exercise },
+            { "test_cases", canonicalData.TestCases },
+            { "test_cases_by_property", GroupTestCasesByProperty(canonicalData.TestCases)}
         };
 
     private static Dictionary<string, TestCase[]> GroupTestCasesByProperty(TestCase[] testCases) =>

generators.new/TestCaseConfiguration.cs

@@ -0,0 +1,28 @@
+using Tomlyn;
+using Tomlyn.Model;
+
+namespace Generators;
+
+internal static class TestCasesConfiguration
+{
+    internal static CanonicalData RemoveExcludedTestCases(CanonicalData canonicalData)
+    {
+        var excludedTestCaseIds = ExcludedTestCaseIds(canonicalData.Exercise);
+        var includedTestCases = canonicalData.TestCases
+            .Where(testCase => !excludedTestCaseIds.Contains(testCase.Uuid))
+            .ToArray();
+        
+        return canonicalData with { TestCases = includedTestCases };
+    }
+
+    private static HashSet<string> ExcludedTestCaseIds(Exercise exercise) =>
+        Toml.ToModel(File.ReadAllText(Paths.TestsTomlFile(exercise)))
+            .Where(IsExcluded)
+            .Select(table => table.Key)
+            .ToHashSet();
+
+    private static bool IsExcluded(KeyValuePair<string, object> idTablePair) =>
+        idTablePair.Value is TomlTable table &&
+        table.TryGetValue("include", out var includeValue) &&
+        includeValue is false;
+}

generators.new/TestCasesConfiguration.cs

@@ -0,0 +1,16 @@
+namespace Generators;
+
+internal static class TestsGenerator
+{
+    internal static void Generate(Exercise exercise)
+    {
+        Console.WriteLine($"{exercise.Slug}: generating tests...");
+        
+        var canonicalData = CanonicalDataParser.Parse(exercise);
+        var filteredCanonicalData = TestCasesConfiguration.RemoveExcludedTestCases(canonicalData);
+
+        var testCode = Templates.RenderTestsCode(filteredCanonicalData);
+        var formattedTestCode = Formatting.FormatCode(testCode);
+        File.WriteAllText(Paths.TestsFile(exercise), formattedTestCode);
+    }
+}