trackler 2.2.1.12 → 2.2.1.13

data/tracks/csharp/generators/Output/Templates/_TestMethod.liquid

@@ -0,0 +1,5 @@
+[Fact{% if Skip %}(Skip = "Remove to run test"){% endif %}]
+public void {{ Name }}()
+{
+{{ Body | indent }}
+}

data/tracks/csharp/generators/Output/Templates/_TestMethodBody.liquid

@@ -0,0 +1,3 @@
+{{ Arrange }}
+{{ Act }}
+{{ Assert }}

data/tracks/csharp/generators/Output/TestClass.cs

@@ -6,7 +6,10 @@ public class TestClass
     {
         public string ClassName { get; set; }
         public string CanonicalDataVersion { get; set; }
-        public TestMethod[] TestMethods { get; set; }
-        public ISet<string> UsingNamespaces { get; } = new HashSet<string> { "Xunit" };
+        public IList<string> Methods { get; set; }
+        public ISet<string> UsingNamespaces { get; set; } = new HashSet<string> { "Xunit" };
+        public string TemplateName { get; set; } = "TestClass";
+        
+        public string Render() => TemplateRenderer.RenderPartial(TemplateName, new { ClassName, CanonicalDataVersion, Methods, UsingNamespaces });
     }    
 }

data/tracks/csharp/generators/Output/TestMethod.cs

@@ -1,12 +1,12 @@
-using System.Collections.Generic;
-using Generators.Input;
-
 namespace Generators.Output
 {
     public class TestMethod
     {
-        public string MethodName { get; set; }
-        public IEnumerable<string> Body { get; set; }
-        public CanonicalDataCase GeneratedFrom { get; set; }
+        public bool Skip { get; set; }
+        public string Name { get; set; }
+        public string Body { get; set; }
+        public string TemplateName { get; set; } = "TestMethod";
+
+        public string Render() => TemplateRenderer.RenderPartial(TemplateName, new { Name, Body, Skip });
     }
 }

data/tracks/csharp/generators/Output/TestMethodBody.cs

@@ -0,0 +1,49 @@
+using Generators.Input;
+
+namespace Generators.Output
+{
+    public abstract class TestMethodBody
+    {
+        protected TestMethodBody(CanonicalDataCase canonicalDataCase, CanonicalData canonicalData)
+        {
+            CanonicalDataCase = canonicalDataCase;
+            CanonicalData = canonicalData;
+
+            Data = new TestMethodBodyData(this);
+            InitializeTemplateParameters();
+        }
+
+        public string TemplateName { get; set; } = "TestMethodBody";
+
+        public CanonicalDataCase CanonicalDataCase { get; }
+        public CanonicalData CanonicalData { get; }
+        public TestMethodBodyData Data { get; }
+
+        public virtual bool UseVariablesForInput => CanonicalDataCase.UseVariablesForInput;
+        public virtual bool UseVariablesForConstructorParameters => CanonicalDataCase.UseVariablesForConstructorParameters;
+        public virtual bool UseVariableForExpected => CanonicalDataCase.UseVariableForExpected;
+        public virtual bool UseVariableForTested => CanonicalDataCase.UseVariableForTested;
+        
+        public string ArrangeTemplateName { get; set; } = "Arrange";
+        public object ArrangeTemplateParameters { get; set; }
+        
+        public string ActTemplateName { get; set; } = "Act";
+        public object ActTemplateParameters { get; set; }
+        
+        public string AssertTemplateName { get; set; } = "AssertEqual";
+        public object AssertTemplateParameters { get; set; }
+
+        public string Act { get; set; }
+        public string Arrange { get; set; }
+        public string Assert { get; set; }
+        
+        public virtual string Render() => TemplateRenderer.RenderPartial(TemplateName, new { Arrange, Act, Assert });
+
+        private void InitializeTemplateParameters()
+        {
+            ArrangeTemplateParameters = new { Data.Variables };
+            ActTemplateParameters = new { };
+            AssertTemplateParameters = new { Data.ExpectedParameter, Data.TestedValue };
+        }
+    }
+}

data/tracks/csharp/generators/Output/TestMethodBodyData.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Generators.Input;
+
+namespace Generators.Output
+{
+    public class TestMethodBodyData
+    {
+        private const string SutVariableName = "sut";
+        private const string TestedVariableName = "actual";
+        private const string ExpectedVariableName = "expected";
+
+        private readonly TestMethodBody _testMethodBody;
+
+        public TestMethodBodyData(TestMethodBody testMethodBody)
+        {
+            _testMethodBody = testMethodBody;
+        }
+
+        public object TestedValue => _testMethodBody.UseVariableForTested ? TestedVariableName : TestedMethodInvocation;
+        public object InputParameters => _testMethodBody.UseVariablesForInput ? string.Join(", ", CanonicalDataCase.Input.Keys.Select(key => NameExtensions.ToVariableName(key))) : Input;
+        public object ExpectedParameter => _testMethodBody.UseVariableForExpected ? ExpectedVariableName : Expected;
+        public object ConstructorParameters => _testMethodBody.UseVariablesForConstructorParameters ? string.Join(", ", CanonicalDataCase.ConstructorInput.Keys.Select(key => key.ToVariableName())) : ConstructorInput;
+
+        private CanonicalDataCase CanonicalDataCase => _testMethodBody.CanonicalDataCase;
+        private CanonicalData CanonicalData => _testMethodBody.CanonicalData;
+
+        private string TestedClassName => CanonicalData.Exercise.ToTestedClassName();
+        private string TestedMethodName => CanonicalDataCase.Property.ToTestedMethodName();
+
+        private object Input => ValueFormatter.Format(CanonicalDataCase.Input);
+        private object Expected => ValueFormatter.Format(CanonicalDataCase.Expected);
+        private object ConstructorInput => ValueFormatter.Format(CanonicalDataCase.ConstructorInput);
+
+        private IEnumerable<string> InputVariablesDeclaration => ValueFormatter.FormatVariables(CanonicalDataCase.Input);
+        private IEnumerable<string> ExpectedVariableDeclaration => ValueFormatter.FormatVariable(CanonicalDataCase.Expected, ExpectedVariableName);
+        private IEnumerable<string> ConstructorVariablesDeclaration => ValueFormatter.FormatVariables(CanonicalDataCase.ConstructorInput);
+        private IEnumerable<string> SutVariableDeclaration => new[] { $"var {SutVariableName} = new {TestedClassName}({ConstructorParameters});" };
+        private IEnumerable<string> ActualVariableDeclaration => new[] { $"var {TestedVariableName} = {TestedMethodInvocation};" };
+
+        public IEnumerable<string> Variables
+        {
+            get
+            {
+                var lines = new List<string>();
+
+                if (_testMethodBody.UseVariablesForInput)
+                    lines.AddRange(InputVariablesDeclaration);
+
+                if (_testMethodBody.UseVariablesForConstructorParameters)
+                    lines.AddRange(ConstructorVariablesDeclaration);
+
+                if (CanonicalDataCase.TestedMethodType == TestedMethodType.Instance)
+                    lines.AddRange(SutVariableDeclaration);
+
+                if (_testMethodBody.UseVariableForTested)
+                    lines.AddRange(ActualVariableDeclaration);
+
+                if (_testMethodBody.UseVariableForExpected)
+                    lines.AddRange(ExpectedVariableDeclaration);
+
+                return lines;
+            }
+        }
+
+        public string TestedMethodInvocation
+        {
+            get
+            {
+                switch (CanonicalDataCase.TestedMethodType)
+                {
+                    case TestedMethodType.Static:
+                        return $"{TestedClassName}.{TestedMethodName}({InputParameters})";
+                    case TestedMethodType.Instance:
+                        return $"{SutVariableName}.{TestedMethodName}({InputParameters})";
+                    case TestedMethodType.Extension:
+                        return $"{InputParameters}.{TestedMethodName}()";
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+    }
+}

data/tracks/csharp/generators/Output/TestMethodBodyWithBooleanCheck.cs

@@ -0,0 +1,16 @@
+using System;
+using Generators.Input;
+
+namespace Generators.Output
+{
+    public class TestMethodBodyWithBooleanCheck : TestMethodBody
+    {
+        public TestMethodBodyWithBooleanCheck(CanonicalDataCase canonicalDataCase, CanonicalData canonicalData) : base(canonicalDataCase, canonicalData)
+        {
+            AssertTemplateName = "AssertBoolean";
+            AssertTemplateParameters = new { BooleanAssertMethod, Data.TestedValue };
+        }
+
+        private string BooleanAssertMethod => Convert.ToBoolean(CanonicalDataCase.Expected).ToString();
+    }
+}

data/tracks/csharp/generators/Output/TestMethodBodyWithEqualityCheck.cs

@@ -0,0 +1,21 @@
+using System.Collections;
+using Generators.Input;
+
+namespace Generators.Output
+{
+    public class TestMethodBodyWithEqualityCheck : TestMethodBody
+    {
+        public TestMethodBodyWithEqualityCheck(CanonicalDataCase canonicalDataCase, CanonicalData canonicalData) : base(canonicalDataCase, canonicalData)
+        {
+            AssertTemplateName = ExpectedIsEmptyEnumerable ? "AssertEqual_Empty" : "AssertEqual";
+            AssertTemplateParameters = new { Data.ExpectedParameter, Data.TestedValue };
+        }
+
+        public override bool UseVariableForExpected => base.UseVariableForExpected && !ExpectedIsEmptyEnumerable;
+
+        private bool ExpectedIsEmptyEnumerable =>
+            !(CanonicalDataCase.Expected is string) &&
+            CanonicalDataCase.Expected is IEnumerable enumerable 
+            && enumerable.GetEnumerator().MoveNext() == false;
+    }
+}

data/tracks/csharp/generators/Output/TestMethodBodyWithExceptionCheck.cs

@@ -0,0 +1,18 @@
+using Generators.Input;
+
+namespace Generators.Output
+{
+    public class TestMethodBodyWithExceptionCheck : TestMethodBody
+    {
+        public TestMethodBodyWithExceptionCheck(CanonicalDataCase canonicalDataCase, CanonicalData canonicalData) : base(canonicalDataCase, canonicalData)
+        {
+            AssertTemplateName = "AssertThrowsException";
+            AssertTemplateParameters = new { ExceptionType, Data.TestedValue };
+        }
+
+        public override bool UseVariableForExpected => false;
+        public override bool UseVariableForTested => false;
+
+        private string ExceptionType => CanonicalDataCase.ExceptionThrown.Name;
+    }
+}

data/tracks/csharp/generators/Output/TestMethodBodyWithNullCheck.cs

@@ -0,0 +1,13 @@
+using Generators.Input;
+
+namespace Generators.Output
+{
+    public class TestMethodBodyWithNullCheck : TestMethodBody
+    {
+        public TestMethodBodyWithNullCheck(CanonicalDataCase canonicalDataCase, CanonicalData canonicalData) : base(canonicalDataCase, canonicalData)
+        {
+            AssertTemplateName = "AssertNull";
+            AssertTemplateParameters = new { Data.TestedValue };
+        }
+    }
+}

data/tracks/csharp/generators/Output/UnescapedValue.cs

@@ -1,11 +1,15 @@
-namespace Generators.Output
+using DotLiquid;
+
+namespace Generators.Output
 {
-    public class UnescapedValue
+    public class UnescapedValue : ILiquidizable
     {
         private readonly string _value;
 
         public UnescapedValue(string value) => _value = value;
 
         public override string ToString() => _value;
+
+        public object ToLiquid() => _value;
     }
 }

data/tracks/csharp/generators/Output/ValueFormatter.cs

@@ -78,16 +78,7 @@ private static string[] FormatMultiLineVariable(IEnumerable<string> enumerable,
                 .AddTrailingSemicolon()
                 .Prepend($"var {name} = {constructor}")
                 .ToArray();
-
-        private static string EscapeControlCharacters(this string s)
-            => s.Replace("\n", "\\n")
-                .Replace("\t", "\\t")
-                .Replace("\r", "\\r");
-
-        private static string Quote(this string s) => $"\"{s}\"";
-
-        private static string Indent(this string s, int level = 1) => $"{new string(' ', 4 * level)}{s}";
-
+        
         private static IEnumerable<string> AddTrailingSemicolon(this IEnumerable<string> enumerable)
         {
             var array = enumerable.ToArray();

data/tracks/csharp/generators/Program.cs

@@ -1,16 +1,27 @@
-using CommandLine;
+using System;
+using CommandLine;
+using Generators.Input;
 using Serilog;
 
 namespace Generators
 {
     public static class Program
     {
-        public static void Main(string[] args)
+        public static int Main(string[] args)
         {
             SetupLogger();
 
-            Parser.Default.ParseArguments<Options>(args)
-                .WithParsed(Generate);
+            try
+            {
+                Parser.Default.ParseArguments<Options>(args)
+                    .WithParsed(RegenerateTestClasses);
+                return 0;
+            }
+            catch (Exception exception)
+            {
+                Log.Error(exception, "Exception occured: {Message}", exception.Message);
+                return 1;
+            }
         }
 
         private static void SetupLogger()
@@ -20,14 +31,29 @@ private static void SetupLogger()
                 .CreateLogger();
         }
 
-        private static void Generate(Options options)
+        private static void RegenerateTestClasses(Options options)
         {
-            Log.Information("Generating tests...");
+            Log.Information("Re-generating test classes...");
+            
+            var canonicalDataParser = CreateCanonicalDataParser(options);
 
             foreach (var exercise in new ExerciseCollection(options.Exercises))
-                exercise.Generate();
+            {
+                var canonicalData = canonicalDataParser.Parse(exercise);
+                exercise.Regenerate(canonicalData);
+            }
 
-            Log.Information("Generated tests.");
+            Log.Information("Re-generated test classes.");
+        }
+
+        private static CanonicalDataParser CreateCanonicalDataParser(Options options)
+        {
+            var canonicalDataOptions = new CanonicalDataOptions
+            {
+                CanonicalDataDirectory = options.CanonicalDataDirectory,
+                CacheCanonicalData = options.CacheCanonicalData
+            };
+            return new CanonicalDataParser(canonicalDataOptions);
         }
     }
 }

data/tracks/delphi/config/maintainers.json

@@ -15,7 +15,7 @@
       "show_on_website": true,
       "alumnus": false,
       "name": "Ryan Potts",
-      "bio": "I have been using Delphi professionally since 1996, Delphi 1.  My day job has me developing software used in the control of various types of electromechanical testing machines used by the auto industry.  Exercism is my first real push into Open Source and I'm happy to have the opportunity here to teach and share the virtures of this programming language with others.",
+      "bio": "I have been using Delphi professionally since 1996, Delphi 1.  At my day job I develope software used in the control of various types of test machines used by the auto industry.  Exercism is my first real push into Open Source and I'm happy to have this opportunity to teach and share the virtures of Delphi with others.",
       "link_text": null,
       "link_url": null,
       "avatar_url": null

data/tracks/fsharp/config.json

@@ -45,6 +45,17 @@
         "Lists",
         "Transforming"
       ]
+    },
+	{
+      "uuid": "2ee3cc7a-db3f-4668-9983-ed6d0fea95d1",
+      "slug": "two-fer",
+      "core": true,
+      "unlocked_by": "null",
+      "difficulty": 1,
+      "topics": [
+        "Strings",
+        "Optional values"
+      ]
     },
     {
       "uuid": "277d05db-0ba0-4de6-b5f8-090c251afffc",
@@ -181,8 +192,8 @@
     {
       "uuid": "4e786e56-2658-445f-ac91-64dd9c38dbb3",
       "slug": "binary-search-tree",
-      "core": true,
-      "unlocked_by": null,
+      "core": false,
+      "unlocked_by": "two-fer",
       "difficulty": 5,
       "topics": [
         "Searching",
@@ -769,7 +780,7 @@
       "uuid": "cb629d30-0351-4023-bd51-423267164c24",
       "slug": "bank-account",
       "core": false,
-      "unlocked_by": "binary-search-tree",
+      "unlocked_by": "two-fer",
       "difficulty": 5,
       "topics": [
         "Optional values",
@@ -1125,7 +1136,7 @@
       "uuid": "5369eea9-00c8-4044-b272-1ce8d0590ecf",
       "slug": "zipper",
       "core": false,
-      "unlocked_by": "binary-search-tree",
+      "unlocked_by": "two-fer",
       "difficulty": 10,
       "topics": [
         "Trees",
@@ -1148,7 +1159,7 @@
       "uuid": "a6082751-98ca-45dc-aeed-cdd19a8da0ca",
       "slug": "pov",
       "core": false,
-      "unlocked_by": "binary-search-tree",
+      "unlocked_by": "two-fer",
       "difficulty": 10,
       "topics": [
         "Graphs",

data/tracks/fsharp/config/maintainers.json

@@ -22,10 +22,10 @@
     },
     {
       "github_username": "robkeim",
-      "show_on_website": false,
+      "show_on_website": true,
       "alumnus": false,
-      "name": null,
-      "bio": null,
+      "name": "Rob Keim",
+      "bio": "I stumbled upon this site when I was trying to learn about functional programming and F#. Little did I know, I'd wind up becoming a contributor and learning a whole lot more than what I originally intended to. I had never contributed to an open source project before, and it's been a very rewarding experience.",
       "link_text": null,
       "link_url": null,
       "avatar_url": null