trackler 2.0.8.19 → 2.0.8.20

data/tracks/csharp/config.json

@@ -857,7 +857,8 @@
   ],
   "ignored": [
     "docs",
-    "img"
+    "img",
+    "generators"
   ],
   "foregone": [    
     "lens-person",

data/tracks/csharp/exercises/leap/LeapTest.cs

@@ -3,26 +3,26 @@ using Xunit;
 public class LeapTest
 {
     [Fact]
-    public void Valid_leap_year()
+    public void Year_not_divisible_by_4_is_common_year()
     {
-        Assert.True(Year.IsLeap(1996));
+        Assert.False(Year.IsLeap(2015));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Invalid_leap_year()
+    public void Year_divisible_by_4_not_divisible_by_100_is_leap_year()
     {
-        Assert.False(Year.IsLeap(1997));
+        Assert.True(Year.IsLeap(2016));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Turn_of_the_20th_century_is_not_a_leap_year()
+    public void Year_divisible_by_100_not_divisible_by_400_is_common_year()
     {
-        Assert.False(Year.IsLeap(1900));
+        Assert.False(Year.IsLeap(2100));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Turn_of_the_25th_century_is_a_leap_year()
+    public void Year_divisible_by_400_is_leap_year()
     {
-        Assert.True(Year.IsLeap(2400));
+        Assert.True(Year.IsLeap(2000));
     }
 }

data/tracks/csharp/generators/CanonicalData.cs

@@ -0,0 +1,19 @@
+using System.ComponentModel.DataAnnotations;
+using Newtonsoft.Json;
+
+namespace Generators
+{
+    public class CanonicalData
+    {
+        [Required]
+        public string Exercise { get; set; }
+
+        [Required]
+        public string Version { get; set; }
+
+        public string[] Comments { get; set; }
+        
+        [JsonConverter(typeof(CanonicalDataCasesJsonConverter))]
+        public CanonicalDataCase[] Cases { get; set; }
+    }
+}

data/tracks/csharp/generators/CanonicalDataCase.cs

@@ -0,0 +1,24 @@
+using Newtonsoft.Json;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace Generators
+{
+    [JsonConverter(typeof(CanonicalDataCaseJsonConverter))]
+    public class CanonicalDataCase
+    {
+        [Required]
+        public string Description { get; set; }
+
+        [Required]
+        public string Property { get; set; }
+
+        public string[] Comments { get; set; }
+
+        public object Input { get; set; }
+
+        public object Expected { get; set; }
+
+        public IDictionary<string, object> Data { get; set; }
+    }
+}

data/tracks/csharp/generators/CanonicalDataCaseJsonConverter.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Generators
+{
+    public class CanonicalDataCaseJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(CanonicalDataCase) == objectType;
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var jToken = JToken.ReadFrom(reader);
+
+            var canonicalDataCase = new CanonicalDataCase();
+            serializer.Populate(new JTokenReader(jToken), canonicalDataCase);
+
+            canonicalDataCase.Data = jToken.ToObject<IDictionary<string, object>>();
+
+            return canonicalDataCase;
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

data/tracks/csharp/generators/CanonicalDataCasesJsonConverter.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System.Linq;
+
+namespace Generators
+{
+    public class CanonicalDataCasesJsonConverter : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return typeof(IEnumerable<CanonicalData>).GetTypeInfo().IsAssignableFrom(objectType);
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            var casesToken = JToken.ReadFrom(reader);
+            var caseTokens = casesToken.SelectTokens("$..*[?(@.property)]").ToArray();
+            
+            return new JArray(caseTokens).ToObject(objectType);            
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

data/tracks/csharp/generators/CanonicalDataParser.cs

@@ -0,0 +1,28 @@
+using Newtonsoft.Json;
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.Net.Http;
+
+namespace Generators
+{
+    public static class CanonicalDataParser
+    {
+        private static readonly HttpClient httpClient = new HttpClient();
+
+        public static CanonicalData Parse(string exercise)
+        {
+            var canonicalDataJson = DownloadCanonicalDataJson(exercise);
+            var canonicalData = JsonConvert.DeserializeObject<CanonicalData>(canonicalDataJson);
+
+            Validator.ValidateObject(canonicalData, new ValidationContext(canonicalData));
+
+            return canonicalData;
+        }
+
+        private static string DownloadCanonicalDataJson(string exercise)
+            => httpClient.GetStringAsync(GetCanonicalDataUrl(exercise)).GetAwaiter().GetResult();
+
+        private static Uri GetCanonicalDataUrl(string exercise)
+            => new Uri($"https://raw.githubusercontent.com/exercism/x-common/master/exercises/{exercise}/canonical-data.json");
+    }
+}

data/tracks/csharp/generators/ExerciseCollection.cs

@@ -0,0 +1,23 @@
+using Generators.Exercises;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace Generators
+{
+    public class ExerciseCollection : IEnumerable<Exercise>
+    {
+        private readonly IEnumerable<Exercise> generators = GetDefinedGenerators();
+
+        public IEnumerator<Exercise> GetEnumerator() => generators.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        private static IEnumerable<Exercise> GetDefinedGenerators() =>
+            from type in Assembly.GetEntryAssembly().GetTypes()
+            where typeof(Exercise).IsAssignableFrom(type) && !type.GetTypeInfo().IsAbstract
+            select (Exercise)Activator.CreateInstance(type);
+    }
+}

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

@@ -0,0 +1,14 @@
+namespace Generators.Exercises
+{
+    public abstract class Exercise
+    {
+        protected Exercise(string name)
+        {
+            Name = name;
+        }
+
+        public string Name { get; }
+
+        public abstract TestClass CreateTestClass(CanonicalData canonicalData);
+    }
+}

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

@@ -0,0 +1,35 @@
+using System;
+using System.Linq;
+using Humanizer;
+
+namespace Generators.Exercises
+{
+    public class LeapExercise : Exercise
+    {
+        public LeapExercise() : base("leap")
+        {
+        }
+
+        public override TestClass CreateTestClass(CanonicalData canonicalData)
+        {
+            return new TestClass
+            {
+                ClassName = "Leap",
+                TestMethods = canonicalData.Cases.Select(CreateTestMethod).ToArray()
+            };
+        }
+
+        private static TestMethod CreateTestMethod(CanonicalDataCase canonicalDataCase, int index)
+        {
+            var year = Convert.ToInt32(canonicalDataCase.Input);
+            var isTrue = Convert.ToBoolean(canonicalDataCase.Expected);
+
+            return new TestMethod
+            {
+                Index = index,
+                MethodName = canonicalDataCase.Description.Replace(":", " is").Transform(To.TestMethodName),
+                Body = $"Assert.{isTrue}(Year.IsLeap({year}));"
+            };
+        }
+    }
+}

data/tracks/csharp/generators/Generators.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.1</TargetFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Humanizer" Version="2.1.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="9.0.1" />
+    <PackageReference Include="serilog" Version="2.4.0" />
+    <PackageReference Include="serilog.sinks.literate" Version="2.1.0" />
+  </ItemGroup>
+</Project>

data/tracks/csharp/generators/Generators.csproj.user

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ShowAllFiles>false</ShowAllFiles>
+  </PropertyGroup>
+</Project>

data/tracks/csharp/generators/Generators.sln

@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26228.4
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Generators", "Generators.csproj", "{F310316B-5E18-4E7F-A77D-D26AD8D92307}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F310316B-5E18-4E7F-A77D-D26AD8D92307}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F310316B-5E18-4E7F-A77D-D26AD8D92307}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F310316B-5E18-4E7F-A77D-D26AD8D92307}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F310316B-5E18-4E7F-A77D-D26AD8D92307}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

data/tracks/csharp/generators/Program.cs

@@ -0,0 +1,59 @@
+using Generators.Exercises;
+using System.IO;
+using Humanizer;
+using Serilog;
+
+namespace Generators
+{
+    public static class Program
+    {
+        public static void Main()
+        {
+            SetupLogger();
+            GenerateAll();
+        }
+
+        private static void SetupLogger()
+        {
+            Log.Logger = new LoggerConfiguration()
+                .WriteTo.LiterateConsole()
+                .CreateLogger();
+        }
+
+        private static void GenerateAll()
+        {
+            Log.Information("Start generating tests...");
+
+            foreach (var exercise in new ExerciseCollection())
+                TestFileGenerator.Generate(exercise);
+
+            Log.Information("Finished generating tests for all supported exercises.");
+        }
+    }
+
+    public static class TestFileGenerator
+    {   
+        public static void Generate(Exercise exercise)
+        {
+            var testClassContents = GenerateTestClassContents(exercise);
+            var testClassFilePath = TestFilePath(exercise);
+
+            SaveTestClassContentsToFile(testClassFilePath, testClassContents);
+            Log.Information("Generated tests for {Exercise} exercise in {TestFile}.", exercise.Name, testClassFilePath);
+        }
+
+        private static string GenerateTestClassContents(Exercise exercise)
+        {
+            var canonicalData = CanonicalDataParser.Parse(exercise.Name);
+            var testClass = exercise.CreateTestClass(canonicalData);
+            return TestClassRenderer.Render(testClass);
+        }
+
+        private static void SaveTestClassContentsToFile(string testClassFilePath, string testClassContents) => 
+            File.WriteAllText(testClassFilePath, testClassContents);
+
+        private static string TestFilePath(Exercise exercise) => Path.Combine("..", "exercises", exercise.Name, TestFileName(exercise));
+
+        private static string TestFileName(Exercise exercise) => $"{exercise.Name.Transform(Humanizer.To.TitleCase)}Test.cs";
+    }
+}

data/tracks/csharp/generators/TestClass.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace Generators
+{
+    public class TestClass
+    {
+        public ISet<string> UsingNamespaces { get; set; } = new HashSet<string> { "Xunit" };
+        public string ClassName { get; set; }
+        public string BeforeTestMethods { get; set; }
+        public TestMethod[] TestMethods { get; set; }
+        public string AfterTestMethods { get; set; }
+    }    
+}

data/tracks/csharp/generators/TestClassRenderer.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Generators
+{
+    public static class TestClassRenderer
+    {
+        private const string TestClassTemplate =
+@"{UsingNamespaces}
+
+public class {ClassName}Test
+{
+{Body}
+}";
+
+        public static string Render(TestClass testClass) =>
+            TestClassTemplate
+                .Replace("{UsingNamespaces}", RenderUsingNamespaces(testClass))
+                .Replace("{ClassName}", testClass.ClassName)
+                .Replace("{Body}", RenderBody(testClass));
+
+        private static string RenderUsingNamespaces(TestClass testClass) =>
+           string.Join("\n", testClass.UsingNamespaces.Select(usingNamespace => $"using {usingNamespace};"));
+
+        private static string RenderBody(TestClass testClass) =>
+           string.Join("\n\n", GetBodyParts(testClass));
+
+        private static IEnumerable<string> GetBodyParts(TestClass testClass) =>
+            from bodyPart in new [] { testClass.BeforeTestMethods, RenderTestMethods(testClass), testClass.AfterTestMethods }
+            where !string.IsNullOrWhiteSpace(bodyPart)
+            select bodyPart;
+
+        private static string RenderTestMethods(TestClass testClass) =>
+           string.Join("\n\n", testClass.TestMethods.Select(TestMethodRenderer.Render));
+    }
+}

data/tracks/csharp/generators/TestMethod.cs

@@ -0,0 +1,9 @@
+namespace Generators
+{
+    public class TestMethod
+    {
+        public int Index { get; set; }
+        public string MethodName { get; set; }
+        public string Body { get; set; }
+    }
+}

data/tracks/csharp/generators/TestMethodNameTransformer.cs

@@ -0,0 +1,11 @@
+using System.Text.RegularExpressions;
+using Humanizer;
+
+namespace Generators
+{
+    public class TestMethodNameTransformer : IStringTransformer
+    {
+        public string Transform(string input) 
+            => Regex.Replace(input, @"[^\w]+", "_", RegexOptions.Compiled).Underscore().Transform(Humanizer.To.TitleCase);
+    }
+}