Kindergarten-garden generator (#446)

* Fix null-reference exception when key is missing

* Don't discard JToken hierarchy

* Add kindergarten-garden generator

Author: ErikSchierboom

exercises/kindergarten-garden/Example.cs

@@ -10,7 +10,7 @@ public enum Plant
     Grass
 }
 
-public class Garden
+public class KindergartenGarden
 {
     private const int PlantsPerChildPerRow = 2;
     private const char RowSeparator = '\n';
@@ -32,22 +32,21 @@ public class Garden
 
     private readonly IDictionary<string, IEnumerable<Plant>> plantsByChild;
 
-    public Garden(IEnumerable<string> children, string windowSills)
+    public KindergartenGarden(string diagram) : this(diagram, DefaultChildren)
     {
-        var plantsPerChild = PlantsPerChild(windowSills);
-        plantsByChild = children.OrderBy(c => c)
-                                .Zip(plantsPerChild, Tuple.Create)
-                                .ToDictionary(kv => kv.Item1, kv => kv.Item2);
     }
 
-    public IEnumerable<Plant> GetPlants(string child)
+    public KindergartenGarden(string diagram, IEnumerable<string> students)
     {
-        return plantsByChild.ContainsKey(child) ? plantsByChild[child] : Enumerable.Empty<Plant>();
+        var plantsPerChild = PlantsPerChild(diagram);
+        plantsByChild = students.OrderBy(c => c)
+                                .Zip(plantsPerChild, Tuple.Create)
+                                .ToDictionary(kv => kv.Item1, kv => kv.Item2);
     }
 
-    public static Garden DefaultGarden(string windowSills)
+    public IEnumerable<Plant> Plants(string child)
     {
-        return new Garden(DefaultChildren, windowSills);
+        return plantsByChild.ContainsKey(child) ? plantsByChild[child] : Enumerable.Empty<Plant>();
     }
 
     private static Plant PlantFromCode(char code)

exercises/kindergarten-garden/KinderGartenGardenTest.cs

@@ -9,18 +9,17 @@ public enum Plant
     Grass
 }
 
-public class Garden
-{
-    public Garden(IEnumerable<string> children, string windowSills)
+public class KindergartenGarden
+{    
+    public KindergartenGarden(string diagram)
     {
     }
 
-    public IEnumerable<Plant> GetPlants(string child)
+    public KindergartenGarden(string diagram, IEnumerable<string> students)
     {
-        throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static Garden DefaultGarden(string windowSills)
+    public IEnumerable<Plant> Plants(string student)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

exercises/kindergarten-garden/KindergartenGarden.cs

@@ -0,0 +1,97 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
+
+public class KindergartenGardenTest
+{
+    [Fact]
+    public void Partial_garden_garden_with_single_student()
+    {
+        var sut = new KindergartenGarden("RC\nGG");
+        Assert.Equal(new[] { Plant.Radishes, Plant.Clover, Plant.Grass, Plant.Grass }, sut.Plants("Alice"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Partial_garden_different_garden_with_single_student()
+    {
+        var sut = new KindergartenGarden("VC\nRC");
+        Assert.Equal(new[] { Plant.Violets, Plant.Clover, Plant.Radishes, Plant.Clover }, sut.Plants("Alice"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Partial_garden_garden_with_two_students()
+    {
+        var sut = new KindergartenGarden("VVCG\nVVRC");
+        Assert.Equal(new[] { Plant.Clover, Plant.Grass, Plant.Radishes, Plant.Clover }, sut.Plants("Bob"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Partial_garden_multiple_students_for_the_same_garden_with_three_students_second_students_garden()
+    {
+        var sut = new KindergartenGarden("VVCCGG\nVVCCGG");
+        Assert.Equal(new[] { Plant.Clover, Plant.Clover, Plant.Clover, Plant.Clover }, sut.Plants("Bob"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Partial_garden_multiple_students_for_the_same_garden_with_three_students_third_students_garden()
+    {
+        var sut = new KindergartenGarden("VVCCGG\nVVCCGG");
+        Assert.Equal(new[] { Plant.Grass, Plant.Grass, Plant.Grass, Plant.Grass }, sut.Plants("Charlie"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Full_garden_first_students_garden()
+    {
+        var sut = new KindergartenGarden("VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV");
+        Assert.Equal(new[] { Plant.Violets, Plant.Radishes, Plant.Violets, Plant.Radishes }, sut.Plants("Alice"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Full_garden_second_students_garden()
+    {
+        var sut = new KindergartenGarden("VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV");
+        Assert.Equal(new[] { Plant.Clover, Plant.Grass, Plant.Clover, Plant.Clover }, sut.Plants("Bob"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Full_garden_second_to_last_students_garden()
+    {
+        var sut = new KindergartenGarden("VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV");
+        Assert.Equal(new[] { Plant.Grass, Plant.Clover, Plant.Clover, Plant.Grass }, sut.Plants("Kincaid"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Full_garden_last_students_garden()
+    {
+        var sut = new KindergartenGarden("VRCGVVRVCGGCCGVRGCVCGCGV\nVRCCCGCRRGVCGCRVVCVGCGCV");
+        Assert.Equal(new[] { Plant.Grass, Plant.Violets, Plant.Clover, Plant.Violets }, sut.Plants("Larry"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Non_alphabetical_student_list_first_students_garden()
+    {
+        var sut = new KindergartenGarden("VCRRGVRG\nRVGCCGCV", new[] { "Samantha", "Patricia", "Xander", "Roger" });
+        Assert.Equal(new[] { Plant.Violets, Plant.Clover, Plant.Radishes, Plant.Violets }, sut.Plants("Patricia"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Non_alphabetical_student_list_second_students_garden()
+    {
+        var sut = new KindergartenGarden("VCRRGVRG\nRVGCCGCV", new[] { "Samantha", "Patricia", "Xander", "Roger" });
+        Assert.Equal(new[] { Plant.Radishes, Plant.Radishes, Plant.Grass, Plant.Clover }, sut.Plants("Roger"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Non_alphabetical_student_list_third_students_garden()
+    {
+        var sut = new KindergartenGarden("VCRRGVRG\nRVGCCGCV", new[] { "Samantha", "Patricia", "Xander", "Roger" });
+        Assert.Equal(new[] { Plant.Grass, Plant.Violets, Plant.Clover, Plant.Grass }, sut.Plants("Samantha"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Non_alphabetical_student_list_fourth_last_students_garden()
+    {
+        var sut = new KindergartenGarden("VCRRGVRG\nRVGCCGCV", new[] { "Samantha", "Patricia", "Xander", "Roger" });
+        Assert.Equal(new[] { Plant.Radishes, Plant.Grass, Plant.Clover, Plant.Violets }, sut.Plants("Xander"));
+    }
+}

exercises/kindergarten-garden/KindergartenGardenTest.cs

@@ -67,10 +67,15 @@ private HashSet<string> GetUsingNamespaces()
         private TestMethod CreateTestMethod(CanonicalDataCase canonicalDataCase, int index) => new TestMethod
         {
             Skip = index > 0,
-            Name = canonicalDataCase.Description.ToTestMethodName(),
+            Name = ToTestMethodName(canonicalDataCase),
             Body = RenderTestMethodBody(canonicalDataCase)
         };
 
+        private static string ToTestMethodName(CanonicalDataCase canonicalDataCase) 
+            => canonicalDataCase.UseFullDescriptionPath 
+                ? string.Join(" - ", canonicalDataCase.DescriptionPath).ToTestMethodName()
+                : canonicalDataCase.Description.ToTestMethodName();
+
         private string RenderTestMethodBody(CanonicalDataCase canonicalDataCase)
         {
             var testMethodBody = CreateTestMethodBody(canonicalDataCase);

generators/Exercise.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using Generators.Input;
+using Generators.Output;
+using Humanizer;
+
+namespace Generators.Exercises
+{
+    public class KindergartenGarden : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.TestedMethodType = TestedMethodType.Instance;
+                canonicalDataCase.UseFullDescriptionPath = true;
+
+                if (canonicalDataCase.Properties.ContainsKey("students"))
+                    canonicalDataCase.SetConstructorInputParameters("diagram", "students");
+                else
+                    canonicalDataCase.SetConstructorInputParameters("diagram");
+
+                var plants = (IEnumerable<string>)canonicalDataCase.Properties["expected"];
+                canonicalDataCase.Properties["expected"] = plants
+                    .Select(x => new UnescapedValue($"Plant.{x.Humanize()}"))
+                    .ToArray();
+            }
+        }
+    }
+}

generators/Exercises/KindergartenGarden.cs

@@ -13,10 +13,13 @@ public class CanonicalDataCase
         private readonly HashSet<string> _constructorInputParameters = new HashSet<string>();
 
         [Required]
-        public string Description { get; set; }
+        public string Property { get; set; }
 
         [Required]
-        public string Property { get; set; }
+        public string Description { get; set; }
+
+        [JsonIgnore]
+        public string[] DescriptionPath { get; set; }
 
         [JsonIgnore]
         public IReadOnlyDictionary<string, dynamic> Input
@@ -48,6 +51,9 @@ public dynamic Expected
         [JsonIgnore]
         public bool UseVariableForTested { get; set; }
 
+        [JsonIgnore]
+        public bool UseFullDescriptionPath { get; set; }
+
         [JsonIgnore]
         public TestedMethodType TestedMethodType { get; set; }
 

generators/Input/CanonicalDataCase.cs

@@ -14,19 +14,36 @@ public class CanonicalDataCaseJsonConverter : JsonConverter
 
         public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
         {
-            var jToken = JToken.ReadFrom(reader);
+            var jTokenReader = (JTokenReader) reader;
 
             var canonicalDataCase = new CanonicalDataCase();
-            serializer.Populate(new JTokenReader(jToken), canonicalDataCase);
+            serializer.Populate(jTokenReader, canonicalDataCase);
 
-            canonicalDataCase.Properties = CanonicalDataCaseJson.ToDictionary(jToken);
+            canonicalDataCase.Properties = CanonicalDataCaseJson.ToDictionary(jTokenReader.CurrentToken);
             canonicalDataCase.SetInputParameters(GetInputProperties(canonicalDataCase.Properties));
-            
+            canonicalDataCase.DescriptionPath = GetDescriptionPath(jTokenReader.CurrentToken);
+
             return canonicalDataCase;
         }
 
         private static string[] GetInputProperties(IDictionary<string, dynamic> properties) => properties.Keys.Except(NonInputProperties).ToArray();
 
+        private static string[] GetDescriptionPath(JToken canonicalDataCaseToken)
+        {
+            var descriptionPath = new Stack<string>();
+            var currentToken = canonicalDataCaseToken;
+
+            while (currentToken != null)
+            {
+                if (currentToken.Type == JTokenType.Object)
+                    descriptionPath.Push(currentToken.SelectToken("description").ToObject<string>());
+
+                currentToken = currentToken.Parent;
+            }
+            
+            return descriptionPath.Where(x => !string.IsNullOrEmpty(x)).ToArray();
+        }
+
         public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) => throw new NotImplementedException();
     }
 }

generators/Input/CanonicalDataCaseJsonConverter.cs

@@ -11,8 +11,8 @@ public static class CanonicalDataCasesJson
 
         public static CanonicalDataCase[] ToArray(JToken casesToken)
         {
-            var caseTokens = new JArray(casesToken.SelectTokens(TokensPath));
-            var canonicalDataCases = new JArray(caseTokens).ToObject<CanonicalDataCase[]>();
+            var caseTokens = casesToken.SelectTokens(TokensPath);
+            var canonicalDataCases = caseTokens.Select(x => x.ToObject<CanonicalDataCase>()).ToArray();
 
             ConvertEmptyJArrayToArray(canonicalDataCases);
 
@@ -49,10 +49,10 @@ private static Type GetArrayType(IGrouping<string, KeyValuePair<string, dynamic>
             return null;
         }
 
-        private static IEnumerable<CanonicalDataCase> GetEmptyJArrays(IGrouping<string, CanonicalDataCase> groupedCanonicalDataCases, IGrouping<string, KeyValuePair<string, dynamic>> groupedProperties) 
-            => groupedCanonicalDataCases.Where(canonicalDataCase => IsEmptyJArray(canonicalDataCase, groupedProperties));
+        private static IEnumerable<CanonicalDataCase> GetEmptyJArrays(IGrouping<string, CanonicalDataCase> groupedCanonicalDataCases, IGrouping<string, KeyValuePair<string, dynamic>> groupedProperties)
+            => groupedCanonicalDataCases.Where(canonicalDataCase => canonicalDataCase.Properties.ContainsKey(groupedProperties.Key) && IsEmptyJArray(canonicalDataCase, groupedProperties));
 
-        private static bool IsEmptyJArray(CanonicalDataCase x, IGrouping<string, KeyValuePair<string, dynamic>> groupedProperties) 
+        private static bool IsEmptyJArray(CanonicalDataCase x, IGrouping<string, KeyValuePair<string, dynamic>> groupedProperties)
             => x.Properties[groupedProperties.Key] is JArray jArray && jArray.Count == 0;
     }
 }

generators/Input/CanonicalDataCasesJson.cs

@@ -28,6 +28,8 @@ public static object Format(object val)
                     return ints.Any() ? $"new[] {{ {string.Join(", ", ints)} }}" : "new int[0]";
                 case IEnumerable<string> strings:
                     return strings.Any() ? $"new[] {{ {string.Join(", ", strings.Select(Format) )} }}" : "new string[0]";
+                case IEnumerable<UnescapedValue> unescapedValues when unescapedValues.Any():
+                    return $"new[] {{ {string.Join(", ", unescapedValues.Select(Format) )} }}";
                 case double dbl:
                     return dbl.ToString(CultureInfo.InvariantCulture);
                 case float flt: