trackler 2.2.1.41 → 2.2.1.42

data/tracks/cfml/config/maintainers.json

@@ -1,13 +1,13 @@
 {
+  "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md",
   "maintainers": [
-	{
-	  "github_username": "bdw429s",
-	  "show_on_website": true,
-	  "name": "Brad Wood",
-	  "bio": "ColdBox/CommandBox Developer Advocate. Lucee Member. System Architect. CFML dev. DBA. Dad. Handyman. Ready for a revolution.",
-	  "link_text": "Tech Blog",
-	  "link_url": "http://www.codersrevolution.com/"
-	}
-  ],
-  "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md"
-}
+    {
+      "bio": "ColdBox/CommandBox Developer Advocate. Lucee Member. System Architect. CFML dev. DBA. Dad. Handyman. Ready for a revolution.",
+      "github_username": "bdw429s",
+      "link_text": "Tech Blog",
+      "link_url": "http://www.codersrevolution.com/",
+      "name": "Brad Wood",
+      "show_on_website": true
+    }
+  ]
+}

data/tracks/csharp/exercises/etl/Etl.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)
     {

data/tracks/csharp/exercises/etl/EtlTest.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));
+    }
+}

data/tracks/csharp/exercises/etl/Example.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)
     {

data/tracks/csharp/exercises/pascals-triangle/Example.cs

@@ -1,15 +1,24 @@
 using System.Collections.Generic;
+using System;
 
 public static class PascalsTriangle
 {
     public static IEnumerable<IEnumerable<int>> Calculate(int rows)
+    {
+        if (rows < 0)
+            throw new ArgumentOutOfRangeException();
+
+        return IterateRows(rows);
+    }
+    
+    private static IEnumerable<IEnumerable<int>> IterateRows(int rows)
     {
         for (var i = 1; i <= rows; i++)
         {
             yield return Row(i);
         }
     }
-    
+
     private static IEnumerable<int> Row(int row)
     {
         yield return 1;

data/tracks/csharp/exercises/pascals-triangle/PascalsTriangle.cs

@@ -7,4 +7,5 @@ public static IEnumerable<IEnumerable<int>> Calculate(int rows)
     {
         throw new NotImplementedException();
     }
+
 }

data/tracks/csharp/exercises/pascals-triangle/PascalsTriangleTest.cs

@@ -1,80 +1,47 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
+using System;
 
 public class PascalsTriangleTest
 {
     [Fact]
-    public void One_row()
+    public void Zero_rows()
+    {
+        Assert.Empty(PascalsTriangle.Calculate(0));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Single_row()
     {
-        var actual = PascalsTriangle.Calculate(1);
         var expected = new[] { new[] { 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
+        Assert.Equal(expected, PascalsTriangle.Calculate(1));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Two_rows()
     {
-        var actual = PascalsTriangle.Calculate(2).ToArray();
         var expected = new[] { new[] { 1 }, new[] { 1, 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
+        Assert.Equal(expected, PascalsTriangle.Calculate(2));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Three_rows()
     {
-        var actual = PascalsTriangle.Calculate(3);
         var expected = new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
+        Assert.Equal(expected, PascalsTriangle.Calculate(3));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Four_rows()
     {
-        var actual = PascalsTriangle.Calculate(4);
         var expected = new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 }, new[] { 1, 3, 3, 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Five_rows()
-    {
-        var actual = PascalsTriangle.Calculate(5);
-        var expected = new[] { new[] { 1 }, new[] { 1, 1 }, new[] { 1, 2, 1 }, new[] { 1, 3, 3, 1 }, new[] { 1, 4, 6, 4, 1 } };
-        Assert.Equal(expected, actual, NestedEnumerableEqualityComparer<int>.Instance);
+        Assert.Equal(expected, PascalsTriangle.Calculate(4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Twenty_rows()
+    public void Negative_rows()
     {
-        var actual = PascalsTriangle.Calculate(20).Last();
-        var expected = new[] { 1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1 };
-        Assert.Equal(expected, actual);
-    }
-
-    private class EnumerableEqualityComparer<T> : IEqualityComparer<IEnumerable<T>>
-    {
-        public static readonly EnumerableEqualityComparer<T> Instance = new EnumerableEqualityComparer<T>();
-
-        public bool Equals(IEnumerable<T> x, IEnumerable<T> y) => x.SequenceEqual(y);
-
-        public int GetHashCode(IEnumerable<T> obj)
-        {
-            throw new NotImplementedException();
-        }
-    }
-
-    private class NestedEnumerableEqualityComparer<T> : IEqualityComparer<IEnumerable<IEnumerable<T>>>
-    {
-        public static readonly NestedEnumerableEqualityComparer<T> Instance = new NestedEnumerableEqualityComparer<T>();
-
-        public bool Equals(IEnumerable<IEnumerable<T>> x, IEnumerable<IEnumerable<T>> y)
-            => x.SequenceEqual(y, EnumerableEqualityComparer<T>.Instance);
-
-        public int GetHashCode(IEnumerable<IEnumerable<T>> obj)
-        {
-            throw new NotImplementedException();
-        }
+        Assert.Throws<ArgumentOutOfRangeException>(() => PascalsTriangle.Calculate(-1));
     }
 }

data/tracks/csharp/exercises/saddle-points/SaddlePointsTest.cs

@@ -0,0 +1,75 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
+using System;
+
+public class SaddlePointsTest
+{
+    [Fact]
+    public void Can_identify_single_saddle_point()
+    {
+        var input = new[,]
+        {
+            { 9, 8, 7 },
+            { 5, 3, 2 },
+            { 6, 6, 7 }
+        };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        var expected = new[] { Tuple.Create(1, 0) };
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_identify_that_empty_matrix_has_no_saddle_points()
+    {
+        var input = new int[,] { };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        Assert.Empty(actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_identify_lack_of_saddle_points_when_there_are_none()
+    {
+        var input = new[,]
+        {
+            { 1, 2, 3 },
+            { 3, 1, 2 },
+            { 2, 3, 1 }
+        };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        Assert.Empty(actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_identify_multiple_saddle_points()
+    {
+        var input = new[,]
+        {
+            { 4, 5, 4 },
+            { 3, 5, 5 },
+            { 1, 5, 4 }
+        };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        var expected = new[] { Tuple.Create(0, 1), Tuple.Create(1, 1), Tuple.Create(2, 1) };
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Can_identify_saddle_point_in_bottom_right_corner()
+    {
+        var input = new[,]
+        {
+            { 8, 7, 9 },
+            { 6, 7, 6 },
+            { 3, 2, 5 }
+        };
+        var sut = new SaddlePoints(input);
+        var actual = sut.Calculate();
+        var expected = new[] { Tuple.Create(2, 2) };
+        Assert.Equal(expected, actual);
+    }
+}

data/tracks/csharp/generators/Exercises/Etl.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 };
+    }
+}

data/tracks/csharp/generators/Exercises/PascalsTriangle.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Linq;
+using Generators.Input;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class PascalsTriangle : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            //remove null case until canonical data is updated
+            var cases = canonicalData.Cases.ToList();
+            cases.RemoveAll(x => x.Properties["count"] == null);
+            canonicalData.Cases = cases.ToArray();
+
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseVariableForExpected = true;
+                canonicalDataCase.Property = "calculate";
+                if (!(canonicalDataCase.Expected is JArray))
+                    canonicalDataCase.ExceptionThrown = typeof(ArgumentOutOfRangeException);
+                if (canonicalDataCase.Properties["count"] == null)
+                    canonicalDataCase.Properties["count"] = -1;
+            }
+        }
+    }
+}