trackler 2.2.1.12 → 2.2.1.13

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

@@ -0,0 +1,15 @@
+using Generators.Input;
+
+namespace Generators.Exercises
+{
+    public class PhoneNumber : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in CanonicalData.Cases)
+            {
+                canonicalDataCase.UseVariablesForInput = true;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+namespace Generators.Exercises
+{
+    public class PrimeFactors : Exercise
+    {
+    }
+}

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

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using Generators.Input;
+
+namespace Generators.Exercises
+{
+    public class RailFenceCipher : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in CanonicalData.Cases)
+            {
+                canonicalDataCase.ConstructorInput = new Dictionary<string, object>
+                {
+                    ["rails"] = canonicalDataCase.Properties["rails"]
+                };
+                canonicalDataCase.Input.Remove("rails");
+                canonicalDataCase.TestedMethodType = TestedMethodType.Instance;
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.UseVariableForExpected = true;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+namespace Generators.Exercises
+{
+    public class RnaTranscription : Exercise
+    {
+    }
+}

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

@@ -1,8 +1,10 @@
-namespace Generators.Exercises
+using Generators.Input;
+
+namespace Generators.Exercises
 {
     public class RomanNumerals : Exercise
     {
-        public RomanNumerals()
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in CanonicalData.Cases)
             {

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

@@ -0,0 +1,40 @@
+using Generators.Input;
+using Generators.Output;
+
+namespace Generators.Exercises
+{
+    public class RunLengthEncoding : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in CanonicalData.Cases)
+            {
+                // Prefix the test name with encode/decode because both functions are tested with the same cases
+                canonicalDataCase.Description = $"{canonicalDataCase.Property} {canonicalDataCase.Description}";
+            }
+        }
+
+        protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
+        {
+            if (testMethodBody.CanonicalDataCase.Property == "consistency")
+            {
+                return RenderConsistencyToAssert(testMethodBody);
+            }
+
+            return base.RenderTestMethodBodyAssert(testMethodBody);
+        }
+
+        private static string RenderConsistencyToAssert(TestMethodBody testMethodBody)
+        {
+            const string template = @"Assert.Equal(""{{ExpectedOutput}}"", {{ExerciseName}}.Decode({{ExerciseName}}.Encode(""{{ExpectedOutput}}"")));";
+
+            var templateParameters = new
+            {
+                ExpectedOutput = testMethodBody.CanonicalDataCase.Expected,
+                ExerciseName = testMethodBody.CanonicalData.Exercise.ToTestedClassName()
+            };
+
+            return TemplateRenderer.RenderInline(template, templateParameters);
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+namespace Generators.Exercises
+{
+    public class ScrabbleScore : Exercise
+    {
+    }
+}

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

@@ -0,0 +1,15 @@
+using Generators.Input;
+
+namespace Generators.Exercises
+{
+    public class SecretHandshake : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in CanonicalData.Cases)
+            {
+                canonicalDataCase.Expected = canonicalDataCase.Expected.ConvertToEnumerable<string>();
+            }
+        }
+    }
+}

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

@@ -1,20 +1,20 @@
 using System.Collections.Generic;
-using Newtonsoft.Json.Linq;
+using Generators.Input;
 
 namespace Generators.Exercises
 {
     public class Transpose : Exercise
     {
-        public Transpose()
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in CanonicalData.Cases)
             {
                 canonicalDataCase.Property = "String";
                 canonicalDataCase.Input = new Dictionary<string, object>
                 {
-                    ["input"] = string.Join("\n", (JArray)canonicalDataCase.Input["input"])
+                    ["input"] = canonicalDataCase.Input["input"].ConvertMultiLineString()
                 };
-                canonicalDataCase.Expected = string.Join("\n", (JArray)canonicalDataCase.Expected);
+                canonicalDataCase.Expected = canonicalDataCase.Expected.ConvertMultiLineString();
                 canonicalDataCase.UseVariablesForInput = true;
                 canonicalDataCase.UseVariableForExpected = true;
             }

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

@@ -0,0 +1,6 @@
+namespace Generators.Exercises
+{
+    public class TwoFer : Exercise
+    {
+    }
+}

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

@@ -1,22 +1,14 @@
 using System;
-using Generators.Output;
+using Generators.Input;
 
 namespace Generators.Exercises
 {
     public class Wordy : Exercise
     {
-        public Wordy()
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
         {
             foreach (var canonicalDataCase in CanonicalData.Cases)
                 canonicalDataCase.ExceptionThrown = canonicalDataCase.Expected is bool ? typeof(ArgumentException) : null;
         }
-
-        protected override TestClass CreateTestClass()
-        {
-            var testClass = base.CreateTestClass();
-            testClass.UsingNamespaces.Add(typeof(ArgumentException).Namespace);
-
-            return testClass;
-        }
     }
 }

data/tracks/csharp/generators/Generators.csproj

@@ -13,8 +13,6 @@
     <PackageReference Include="serilog.sinks.literate" Version="2.1.0" />
   </ItemGroup>
   <ItemGroup>
-    <None Update="Output\*.liquid">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </None>
+    <EmbeddedResource Include="Output\Templates\*.liquid" />
   </ItemGroup>
 </Project>

data/tracks/csharp/generators/Input/CanonicalDataFile.cs

@@ -1,28 +1,65 @@
 using System.IO;
 using System.Linq;
 using LibGit2Sharp;
+using Serilog;
 
 namespace Generators.Input
 {
-    public static class CanonicalDataFile
+    public class CanonicalDataFile
     {
-        private const string CacheDir = "./.cache";
         private const string ProblemSpecificationsGitUrl = "https://github.com/exercism/problem-specifications.git";
-        private const string RemoteName = "origin";
+        private const string ProblemSpecificationsBranch = "master";
+        private const string ProblemSpecificationsRemote = "origin";
+        private const string ProblemSpecificationsRemoteBranch = ProblemSpecificationsRemote + "/" + ProblemSpecificationsBranch;
 
-        static CanonicalDataFile()
+        private readonly CanonicalDataOptions _options;
+
+        public CanonicalDataFile(CanonicalDataOptions options)
+        {
+            _options = options;
+        }
+        
+        public string Contents(string exercise)
         {
-            if (!Directory.Exists(CacheDir))
-                Repository.Clone(ProblemSpecificationsGitUrl, CacheDir);
+            var exerciseCanonicalDataPath = Path.Combine(_options.CanonicalDataDirectory, "exercises", exercise, "canonical-data.json");
+            return File.ReadAllText(exerciseCanonicalDataPath);
+        }
 
-            using (var repository = new Repository(CacheDir))
-                Commands.Fetch(repository, RemoteName, Enumerable.Empty<string>(), new FetchOptions(), null);
+        public void DownloadData()
+        {
+            CloneRepository();
+
+            if (_options.CacheCanonicalData)
+                return;
+
+            UpdateToLatestVersion();
         }
 
-        public static string Contents(string exercise)
+        private void CloneRepository()
         {
-            var exerciseCanonicalDataPath = Path.Combine(CacheDir, "exercises", exercise, "canonical-data.json");
-            return File.ReadAllText(exerciseCanonicalDataPath);
+            if (Directory.Exists(_options.CanonicalDataDirectory))
+                return;
+
+            Log.Information("Cloning repository...");
+
+            Repository.Clone(ProblemSpecificationsGitUrl, _options.CanonicalDataDirectory);
+
+            Log.Information("Repository cloned.");
+        }
+
+        private void UpdateToLatestVersion()
+        {
+            Log.Information("Updating repository to latest version...");
+
+            using (var repository = new Repository(_options.CanonicalDataDirectory))
+            {
+                Commands.Fetch(repository, ProblemSpecificationsRemote, Enumerable.Empty<string>(), new FetchOptions(), null);
+                
+                var remoteBranch = repository.Branches[ProblemSpecificationsRemoteBranch];
+                repository.Reset(ResetMode.Hard, remoteBranch.Tip);
+            }   
+
+            Log.Information("Updated repository to latest version.");
         }
     }
 }

data/tracks/csharp/generators/Input/CanonicalDataOptions.cs

@@ -0,0 +1,8 @@
+namespace Generators.Input
+{
+    public class CanonicalDataOptions
+    {
+        public string CanonicalDataDirectory { get; set; }
+        public bool CacheCanonicalData { get; set; }
+    }
+}

data/tracks/csharp/generators/Input/CanonicalDataParser.cs

@@ -3,11 +3,19 @@
 
 namespace Generators.Input
 {
-    public static class CanonicalDataParser
+    public class CanonicalDataParser
     {
-        public static CanonicalData Parse(string exercise)
+        private readonly CanonicalDataFile _canonicalDataFile;
+
+        public CanonicalDataParser(CanonicalDataOptions options)
+        {
+            _canonicalDataFile = new CanonicalDataFile(options);
+            _canonicalDataFile.DownloadData();
+        }
+
+        public CanonicalData Parse(Exercise exercise)
         {
-            var canonicalDataJson = CanonicalDataFile.Contents(exercise);
+            var canonicalDataJson = _canonicalDataFile.Contents(exercise.Name);
             var canonicalData = JsonConvert.DeserializeObject<CanonicalData>(canonicalDataJson);
             
             Validator.ValidateObject(canonicalData, new ValidationContext(canonicalData));

data/tracks/csharp/generators/Options.cs

@@ -8,5 +8,13 @@ public class Options
         [Option('e', "exercises", Required = false, 
             HelpText = "Exercises to generate (if not specified, defaults to all exercises).")]
         public IEnumerable<string> Exercises { get; set; }
+        
+        [Option('d', "canonicaldatadirectory", Required = false, Default = "./.problem-specifications",
+            HelpText = "Canonical data directory. If the directory does not exist, the canonical data will be downloaded.")]
+        public string CanonicalDataDirectory { get; set; }
+
+        [Option('c', "cachecanonicaldata", Required = false, Default = false,
+            HelpText = "Use the cached canonical data and don't update the data.")]
+        public bool CacheCanonicalData { get; set; }
     }
 }

data/tracks/csharp/generators/Output/{TestClassFile.cs → ExerciseWriter.cs}

@@ -3,14 +3,15 @@
 
 namespace Generators.Output
 {
-    public static class TestClassFile
+    public class ExerciseWriter
     {
-        public static void Write(Exercise exercise, string contents)
+        public virtual void WriteToFile(Exercise exercise)
         {
             var testClassFilePath = TestClassFilePath(exercise);
+            var testClassContents = exercise.Render();
 
             Directory.CreateDirectory(Path.GetDirectoryName(testClassFilePath));
-            File.WriteAllText(testClassFilePath, contents);
+            File.WriteAllText(testClassFilePath, testClassContents);
 
             Log.Information("Generated tests for {Exercise} exercise in {TestFile}", exercise.Name, testClassFilePath);
         }

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

@@ -0,0 +1,14 @@
+namespace Generators.Output
+{
+    public static class FormattingExtensions
+    {
+        public static string Indent(this string str, int level = 1) => $"{new string(' ', 4 * level)}{str}";
+
+        public static string EscapeControlCharacters(this string s)
+            => s.Replace("\n", "\\n")
+                .Replace("\t", "\\t")
+                .Replace("\r", "\\r");
+
+        public static string Quote(this string s) => $"\"{s}\"";
+    }
+}

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

@@ -0,0 +1,13 @@
+using System;
+using System.Linq;
+
+namespace Generators.Output
+{
+    public class IndentFilter
+    {
+        public static string Indent(string input) 
+            => string.Join(Environment.NewLine, input
+                .Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(x => x.Indent()));
+    }
+}

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

@@ -0,0 +1,23 @@
+using System.Reflection;
+using DotLiquid;
+using DotLiquid.FileSystems;
+
+namespace Generators.Output
+{
+    public static class TemplateRenderer
+    {
+        private static readonly string EmbeddedTemplatesNamespace = $"{typeof(TemplateRenderer).Namespace}.Templates";
+
+        static TemplateRenderer()
+        {
+            Template.RegisterFilter(typeof(IndentFilter));
+            Template.FileSystem = new EmbeddedFileSystem(Assembly.GetEntryAssembly(), EmbeddedTemplatesNamespace);
+        }
+
+        public static string RenderInline(string template, object parameters)
+            => Template.Parse(template).Render(Hash.FromAnonymousObject(parameters));
+
+        public static string RenderPartial(string template, object parameters) 
+            => Template.Parse($"{{% include \"{template}\" %}}").Render(Hash.FromAnonymousObject(parameters));
+    }
+}

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,3 @@
+{%- for variable in Variables -%}
+{{ variable }}
+{%- endfor -%}

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

@@ -0,0 +1 @@
+Assert.{{ BooleanAssertMethod}}({{ TestedValue }});

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

@@ -0,0 +1 @@
+Assert.Equal({{ ExpectedParameter }}, {{ TestedValue }});

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

@@ -0,0 +1 @@
+Assert.Empty({{ TestedValue }});

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

@@ -0,0 +1 @@
+Assert.Null({{ TestedValue }});

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

@@ -0,0 +1 @@
+Assert.Throws<{{ ExceptionType }}>(() => {{ TestedValue }});

data/tracks/csharp/generators/Output/{TestClass.liquid → Templates/_TestClass.liquid}

@@ -6,14 +6,8 @@ using {{ namespace }};
 
 public class {{ClassName}}
 {
-{%- for testMethod in TestMethods -%}
-    [Fact{% if forloop.first == false %}(Skip = "Remove to run test"){% endif %}]
-    public void {{testMethod.Name}}()
-    {
-    {%- for line in testMethod.Body -%}
-        {{ line }}
-    {%- endfor -%}
-    }
+{%- for method in Methods -%}
+{{ method | indent }}
 {%- if forloop.last == false %}
 {% endif -%}
 {%- endfor -%}