Add Etl generator (#462)

Author: hymccord

exercises/etl/ETLTest.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 
-public static class ETL
+public static class Etl
 {
     public static IDictionary<string, int> Transform(IDictionary<int, IList<string>> old)
     {

exercises/etl/Etl.cs

@@ -0,0 +1,102 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
+using System.Collections.Generic;
+
+public class EtlTest
+{
+    [Fact]
+    public void A_single_letter()
+    {
+        var input = new Dictionary<int, IList<string>>
+        {
+            [1] = new[] { "A" }
+        };
+        var expected = new Dictionary<string, int>
+        {
+            ["a"] = 1
+        };
+        Assert.Equal(expected, Etl.Transform(input));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Single_score_with_multiple_letters()
+    {
+        var input = new Dictionary<int, IList<string>>
+        {
+            [1] = new[] { "A", "E", "I", "O", "U" }
+        };
+        var expected = new Dictionary<string, int>
+        {
+            ["a"] = 1,
+            ["e"] = 1,
+            ["i"] = 1,
+            ["o"] = 1,
+            ["u"] = 1
+        };
+        Assert.Equal(expected, Etl.Transform(input));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiple_scores_with_multiple_letters()
+    {
+        var input = new Dictionary<int, IList<string>>
+        {
+            [1] = new[] { "A", "E" },
+            [2] = new[] { "D", "G" }
+        };
+        var expected = new Dictionary<string, int>
+        {
+            ["a"] = 1,
+            ["d"] = 2,
+            ["e"] = 1,
+            ["g"] = 2
+        };
+        Assert.Equal(expected, Etl.Transform(input));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiple_scores_with_differing_numbers_of_letters()
+    {
+        var input = new Dictionary<int, IList<string>>
+        {
+            [1] = new[] { "A", "E", "I", "O", "U", "L", "N", "R", "S", "T" },
+            [2] = new[] { "D", "G" },
+            [3] = new[] { "B", "C", "M", "P" },
+            [4] = new[] { "F", "H", "V", "W", "Y" },
+            [5] = new[] { "K" },
+            [8] = new[] { "J", "X" },
+            [10] = new[] { "Q", "Z" }
+        };
+        var expected = new Dictionary<string, int>
+        {
+            ["a"] = 1,
+            ["b"] = 3,
+            ["c"] = 3,
+            ["d"] = 2,
+            ["e"] = 1,
+            ["f"] = 4,
+            ["g"] = 2,
+            ["h"] = 4,
+            ["i"] = 1,
+            ["j"] = 8,
+            ["k"] = 5,
+            ["l"] = 1,
+            ["m"] = 3,
+            ["n"] = 1,
+            ["o"] = 1,
+            ["p"] = 3,
+            ["q"] = 10,
+            ["r"] = 1,
+            ["s"] = 1,
+            ["t"] = 1,
+            ["u"] = 1,
+            ["v"] = 4,
+            ["w"] = 4,
+            ["x"] = 8,
+            ["y"] = 4,
+            ["z"] = 10
+        };
+        Assert.Equal(expected, Etl.Transform(input));
+    }
+}

exercises/etl/EtlTest.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 
-public static class ETL
+public static class Etl
 {
     public static IDictionary<string, int> Transform(IDictionary<int, IList<string>> old)
     {

exercises/etl/Example.cs

@@ -0,0 +1,61 @@
+using Generators.Input;
+using Generators.Output;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Generators.Exercises
+{
+    public class Etl : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.UseVariableForExpected = true;
+                // Make sure to convert keys to ints as stated in canonical data
+                canonicalDataCase.Properties["input"] = ConvertInput(canonicalDataCase.Properties["input"]);
+                canonicalDataCase.Expected = ConvertExpected(canonicalDataCase.Expected);
+            }
+        }
+
+        protected override string RenderTestMethodBodyArrange(TestMethodBody testMethodBody)
+        {
+            // The ValueFormatter doesn't handle Dictionary<int, IList<string>>. Need to format manually.
+            Dictionary<int, string[]> inputDictionary = testMethodBody.CanonicalDataCase.Properties["input"];
+            var newInput = FormatMultiLineEnumerable(
+                inputDictionary.Keys.Select((key, i) => $"[{ValueFormatter.Format(key)}] = {ValueFormatter.Format(inputDictionary[key])}" + (i < inputDictionary.Keys.Count - 1 ? "," : "")), 
+                "input", "new Dictionary<int, IList<string>>");
+            newInput = AddTrailingSemicolon(newInput);
+
+            var arrangeVariables = testMethodBody.Data.Variables.ToList();
+            arrangeVariables.RemoveAt(0);
+            arrangeVariables.InsertRange(0, newInput);
+            testMethodBody.ArrangeTemplateParameters = new { Variables = arrangeVariables };
+
+            return base.RenderTestMethodBodyArrange(testMethodBody);
+        }
+
+        private static dynamic ConvertExpected(dynamic expected)
+            => ((Dictionary<string, object>)expected).ToDictionary(kv => kv.Key, kv => int.Parse($"{kv.Value}"));
+
+        private static dynamic ConvertInput(dynamic input)
+            => ((Dictionary<string, object>)input).ToDictionary(kv => int.Parse(kv.Key), kv => (string[])kv.Value);
+
+        private static string[] FormatMultiLineEnumerable(IEnumerable<string> enumerable, string name, string constructor = null)
+            => FormatMultiLineVariable(enumerable.Prepend("{").Append("}"), name, constructor);
+
+        private static string[] FormatMultiLineVariable(IEnumerable<string> enumerable, string name, string constructor = null)
+            => enumerable.Select(line => line == "{" || line == "}" ? line : line.Indent())
+                .Prepend($"var {name} = {constructor}")
+                .ToArray();
+
+        private static string[] AddTrailingSemicolon(string[] array)
+        {
+            array[array.Length - 1] += ";";
+            return array;
+        }
+
+        protected override HashSet<string> AddAdditionalNamespaces() => new HashSet<string> { typeof(Dictionary<string, int>).Namespace };
+    }
+}