trackler 2.2.1.151 → 2.2.1.152

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

@@ -0,0 +1,44 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Generators.Input;
+using Generators.Output;
+
+namespace Generators.Exercises
+{
+    public class VariableLengthQuantity : GeneratorExercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseVariableForExpected = true;
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.Input["integers"] = FormatUInt32Array(canonicalDataCase.Input["integers"]);
+
+                if (canonicalDataCase.Expected == null)
+                    canonicalDataCase.ExceptionThrown = typeof(InvalidOperationException);
+                else
+                    canonicalDataCase.Expected = FormatUInt32Array(canonicalDataCase.Expected);
+            }
+        }
+
+        private dynamic FormatUInt32Array(dynamic input)
+        {
+            var numbers = ToUInt32Array(input as IEnumerable);
+            if (!numbers.Any())
+            {
+                return new UnescapedValue("new uint[0]");
+            }
+
+            return numbers.Select(number => new UnescapedValue(string.Format("0x{0:X}u", number))).ToArray();
+        }
+
+        private IEnumerable<uint> ToUInt32Array(IEnumerable input)
+        {
+            foreach (var number in input)
+                yield return Convert.ToUInt32(number.ToString());
+        }
+    }
+}

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

@@ -5,16 +5,17 @@
 
 namespace Generators.Exercises
 {
-    public class Yacht: GeneratorExercise
+    public class Yacht : GeneratorExercise
     {
-	protected override void UpdateCanonicalData(CanonicalData canonicalData)
-	{
-	   canonicalData.Exercise = "yacht-game";
-	   foreach (var canonicalDataCase in canonicalData.Cases)
-	   {				
-              var input = canonicalDataCase.Properties["input"] as System.Collections.Generic.Dictionary<string,object>;
-	      input["category"] = new UnescapedValue($"YachtCategory.{input["category"].ToString().Dehumanize()}");
-	   }
-	}
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            canonicalData.Exercise = "yacht-game";
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                var category = canonicalDataCase.Input["category"].ToString();
+                var formattedCategory = StringDehumanizeExtensions.Dehumanize(category);
+                canonicalDataCase.Input["category"] = new UnescapedValue($"YachtCategory.{formattedCategory}");
+            }
+        }
     }
 }

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

@@ -0,0 +1,19 @@
+using System;
+using Generators.Input;
+using Generators.Output;
+using Humanizer;
+
+namespace Generators.Exercises
+{
+    public class ZebraPuzzle : GeneratorExercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                var nationality = canonicalDataCase.Expected as string;
+                canonicalDataCase.Expected = new UnescapedValue($"Nationality.{nationality.Humanize()}");
+            }
+        }
+    }
+}

data/tracks/csharp/generators/GeneratorExercise.cs

@@ -9,7 +9,7 @@ public abstract class GeneratorExercise : Exercise
     {
         private static readonly ExerciseWriter ExerciseWriter = new ExerciseWriter();
         private CanonicalData _canonicalData;
-        
+
         public override string Name => GetType().ToExerciseName();
 
         public void Regenerate(CanonicalData canonicalData)
@@ -59,7 +59,7 @@ private HashSet<string> GetUsingNamespaces()
 
         private string[] RenderTestMethods() => _canonicalData.Cases.Select(RenderTestMethod).Concat(RenderAdditionalMethods()).ToArray();
 
-        private TestClass CreateTestClass() => new TestClass
+        protected virtual TestClass CreateTestClass() => new TestClass
         {
             ClassName = Name.ToTestClassName(),
             Methods = RenderTestMethods(),
@@ -69,15 +69,15 @@ private HashSet<string> GetUsingNamespaces()
 
         private string RenderTestMethod(CanonicalDataCase canonicalDataCase, int index) => CreateTestMethod(canonicalDataCase, index).Render();
 
-        private TestMethod CreateTestMethod(CanonicalDataCase canonicalDataCase, int index) => new TestMethod
+        protected virtual TestMethod CreateTestMethod(CanonicalDataCase canonicalDataCase, int index) => new TestMethod
         {
             Skip = index > 0,
             Name = ToTestMethodName(canonicalDataCase),
             Body = RenderTestMethodBody(canonicalDataCase)
         };
 
-        private static string ToTestMethodName(CanonicalDataCase canonicalDataCase) 
-            => canonicalDataCase.UseFullDescriptionPath 
+        private static string ToTestMethodName(CanonicalDataCase canonicalDataCase)
+            => canonicalDataCase.UseFullDescriptionPath
                 ? string.Join(" - ", canonicalDataCase.DescriptionPath).ToTestMethodName()
                 : canonicalDataCase.Description.ToTestMethodName();
 
@@ -91,7 +91,7 @@ private string RenderTestMethodBody(CanonicalDataCase canonicalDataCase)
             return testMethodBody.Render();
         }
 
-        private TestMethodBody CreateTestMethodBody(CanonicalDataCase canonicalDataCase)
+        protected virtual TestMethodBody CreateTestMethodBody(CanonicalDataCase canonicalDataCase)
         {
             if (canonicalDataCase.ExceptionThrown != null)
             {

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

@@ -1,17 +1,14 @@
-using System.ComponentModel.DataAnnotations;
-using Newtonsoft.Json;
-
-namespace Generators.Input
+namespace Generators.Input
 {
     public class CanonicalData
     {
-        [Required]
+        public CanonicalData(string exercise, string version, CanonicalDataCase[] cases)
+            => (Exercise, Version, Cases) = (exercise, version, cases);
+
         public string Exercise { get; set; }
 
-        [Required]
-        public string Version { get; set; }
+        public string Version { get; }
 
-        [JsonConverter(typeof(CanonicalDataCasesJsonConverter))]
-        public CanonicalDataCase[] Cases { get; set; }
+        public CanonicalDataCase[] Cases { get; }
     }
 }

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

@@ -2,78 +2,45 @@
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
-using Newtonsoft.Json;
 
 namespace Generators.Input
 {
-    [JsonConverter(typeof(CanonicalDataCaseJsonConverter))]
     public class CanonicalDataCase
     {
-        private readonly HashSet<string> _inputParameters = new HashSet<string>();
-        private readonly HashSet<string> _constructorInputParameters = new HashSet<string>();
+        public IDictionary<string, dynamic> Properties { get; set; }
+        public IDictionary<string, dynamic> Input { get; set; }
+        public dynamic Expected { get; set; }
 
-        [Required]
         public string Property { get; set; }
-
-        [Required]
         public string Description { get; set; }
-
-        [JsonIgnore]
         public string[] DescriptionPath { get; set; }
 
-        [JsonIgnore]
-        public IReadOnlyDictionary<string, dynamic> Input
-            => _inputParameters.ToDictionary(parameter => parameter, parameter => Properties[parameter]);
-
-        [JsonIgnore]
-        public IReadOnlyDictionary<string, dynamic> ConstructorInput 
-            => _constructorInputParameters.ToDictionary(parameter => parameter, parameter => Properties[parameter]);
-
-        [JsonIgnore]
-        public IDictionary<string, dynamic> Properties { get; set; }
-
-        [JsonIgnore]
-        public dynamic Expected
-        {
-            get => Properties["expected"];
-            set => Properties["expected"] = value;
-        }
-
-        [JsonIgnore]
         public bool UseVariablesForInput { get; set; }
-
-        [JsonIgnore]
         public bool UseVariableForExpected { get; set; }
-
-        [JsonIgnore]
         public bool UseVariablesForConstructorParameters { get; set; }
-
-        [JsonIgnore]
         public bool UseVariableForTested { get; set; }
-
-        [JsonIgnore]
         public bool UseFullDescriptionPath { get; set; }
 
-        [JsonIgnore]
         public TestedMethodType TestedMethodType { get; set; }
-
-        [JsonIgnore]
         public Type ExceptionThrown { get; set; }
 
+        public HashSet<string> InputParameters { get; } = new HashSet<string>();
+        public HashSet<string> ConstructorInputParameters { get; } = new HashSet<string>();
+
         public void SetInputParameters(params string[] properties)
         {
-            _inputParameters.Clear();
-            _inputParameters.UnionWith(properties);
+            InputParameters.Clear();
+            InputParameters.UnionWith(properties);
 
-            _constructorInputParameters.ExceptWith(properties);
+            ConstructorInputParameters.ExceptWith(properties);
         }
 
         public void SetConstructorInputParameters(params string[] properties)
         {
-            _constructorInputParameters.Clear();
-            _constructorInputParameters.UnionWith(properties);
-            
-            _inputParameters.ExceptWith(properties);
+            ConstructorInputParameters.Clear();
+            ConstructorInputParameters.UnionWith(properties);
+
+            InputParameters.ExceptWith(properties);
 
             TestedMethodType = TestedMethodType.Instance;
         }

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

@@ -0,0 +1,170 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Input
+{
+    public static class CanonicalDataCaseParser
+    {
+        private const string TokensPath = "$..*[?(@.property)]";
+
+        public static CanonicalDataCase[] Parse(JArray canonicalDataCasesJArray)
+            => canonicalDataCasesJArray
+                .SelectTokens(TokensPath)
+                .Select(Parse)
+                .ToArray();
+
+        private static CanonicalDataCase Parse(JToken canonicalDataCaseJToken)
+        {
+            var canonicalDataCase = new CanonicalDataCase
+            {
+                Property = canonicalDataCaseJToken.Value<string>("property"),
+                Properties = ToDictionary(canonicalDataCaseJToken),
+                Input = ToDictionary(canonicalDataCaseJToken["input"]),
+                Expected = ConvertJToken(canonicalDataCaseJToken["expected"]),
+                Description = canonicalDataCaseJToken.Value<string>("description"),
+                DescriptionPath = GetDescriptionPath(canonicalDataCaseJToken)
+            };
+            canonicalDataCase.SetInputParameters(canonicalDataCase.Input.Keys.ToArray());
+
+            return canonicalDataCase;
+        }
+
+        private static string[] GetDescriptionPath(JToken canonicalDataCaseToken)
+        {
+            var descriptionPath = new Stack<string>();
+            var currentToken = canonicalDataCaseToken;
+
+            while (currentToken != null)
+            {
+                if (currentToken.Type == JTokenType.Object)
+                {
+                    var description = currentToken.SelectToken("description");
+                    if (description == null)
+                        break;
+
+                    descriptionPath.Push(description.ToObject<string>());
+                }
+
+                currentToken = currentToken.Parent;
+            }
+
+            return descriptionPath.Where(x => !string.IsNullOrEmpty(x)).ToArray();
+        }
+
+        private static IDictionary<string, dynamic> ToDictionary(JToken jToken) => ConvertJToken(jToken);
+
+        private static dynamic ConvertJToken(JToken jToken)
+        {
+            switch (jToken?.Type)
+            {
+                case JTokenType.Object:
+                    return ConvertJObject((JObject)jToken);
+                case JTokenType.Array:
+                    return ConvertJArray((JArray)jToken);
+                case JTokenType.Property:
+                    return jToken.ToObject<IDictionary<string, dynamic>>();
+                case JTokenType.Integer:
+                    return ConvertIntegerJToken(jToken);
+                case JTokenType.Float:
+                    return jToken.ToObject<float>();
+                case JTokenType.String:
+                    return jToken.ToObject<string>();
+                case JTokenType.Boolean:
+                    return jToken.ToObject<bool>();
+                case JTokenType.Date:
+                    return jToken.ToObject<DateTime>();
+                case JTokenType.Raw:
+                    return jToken.ToObject<string>();
+                case JTokenType.Bytes:
+                    return jToken.ToObject<byte[]>();
+                case JTokenType.Guid:
+                    return jToken.ToObject<Guid>();
+                case JTokenType.Uri:
+                    return jToken.ToObject<Uri>();
+                case JTokenType.TimeSpan:
+                    return jToken.ToObject<TimeSpan>();
+                default:
+                    return null;
+            }
+        }
+
+        private static dynamic ConvertJObject(JObject jObject)
+        {
+            var properties = jObject.ToObject<IDictionary<string, dynamic>>();
+
+            for (var i = 0; i < properties.Count; i++)
+            {
+                var key = properties.Keys.ElementAt(i);
+                var value = properties[key];
+                properties[key] = value is JToken jToken ? ConvertJToken(jToken) : value;
+            }
+
+            return properties;
+        }
+
+        private static dynamic ConvertJArray(JArray jArray)
+        {
+            // We can't determine the type of the array if the array is empty
+            if (!jArray.Any())
+                return jArray;
+
+            // We can only convert when all values have the same type
+            if (jArray.Select(x => x.Type).Distinct().Count() != 1)
+                return jArray;
+
+            switch (jArray[0].Type)
+            {
+                case JTokenType.Object:
+                    return jArray.Select(ConvertJToken).ToArray();
+                case JTokenType.Integer:
+                    var strings = jArray.ToObject<string[]>();
+                    if (strings.All(str => int.TryParse(str, out var _)))
+                        return jArray.ToObject<int[]>();
+
+                    if (strings.All(str => long.TryParse(str, out var _)))
+                        return jArray.ToObject<long[]>();
+
+                    if (strings.All(str => ulong.TryParse(str, out var _)))
+                        return jArray.ToObject<ulong[]>();
+
+                    return strings;
+                case JTokenType.Float:
+                    return jArray.ToObject<float[]>();
+                case JTokenType.String:
+                    return jArray.ToObject<string[]>();
+                case JTokenType.Boolean:
+                    return jArray.ToObject<bool[]>();
+                case JTokenType.Date:
+                    return jArray.ToObject<DateTime[]>();
+                case JTokenType.Bytes:
+                    return jArray.ToObject<byte[]>();
+                case JTokenType.Guid:
+                    return jArray.ToObject<Guid[]>();
+                case JTokenType.Uri:
+                    return jArray.ToObject<Uri[]>();
+                case JTokenType.TimeSpan:
+                    return jArray.ToObject<TimeSpan[]>();
+                default:
+                    return jArray;
+            }
+        }
+
+        private static dynamic ConvertIntegerJToken(JToken jToken)
+        {
+            var str = jToken.ToObject<string>();
+
+            if (int.TryParse(str, out var i))
+                return i;
+
+            if (long.TryParse(str, out var l))
+                return l;
+
+            if (ulong.TryParse(str, out var ul))
+                return ul;
+
+            return str;
+        }
+    }
+}

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

@@ -1,5 +1,4 @@
-using System;
-using System.IO;
+using System.IO;
 using System.Linq;
 using LibGit2Sharp;
 using Serilog;

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

@@ -1,5 +1,4 @@
-using System.ComponentModel.DataAnnotations;
-using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace Generators.Input
 {
@@ -7,19 +6,24 @@ public class CanonicalDataParser
     {
         private readonly CanonicalDataFile _canonicalDataFile;
 
-        public CanonicalDataParser(CanonicalDataFile canonicalDataFile)
-        {
-            _canonicalDataFile = canonicalDataFile;
-        }
-        
+        public CanonicalDataParser(CanonicalDataFile canonicalDataFile) => _canonicalDataFile = canonicalDataFile;
+
         public CanonicalData Parse(string exercise)
         {
-            var canonicalDataJson = _canonicalDataFile.Contents(exercise);
-            var canonicalData = JsonConvert.DeserializeObject<CanonicalData>(canonicalDataJson);
-            
-            Validator.ValidateObject(canonicalData, new ValidationContext(canonicalData));
+            var canonicalDataJsonContents = _canonicalDataFile.Contents(exercise);
+            var canonicalDataJson = JObject.Parse(canonicalDataJsonContents);
+
+            var name = ParseName(canonicalDataJson);
+            var version = ParseVersion(canonicalDataJson);
+            var canonicalDataCases = ParseCanonicalDataCases(canonicalDataJson);
 
-            return canonicalData;
+            return new CanonicalData(name, version, canonicalDataCases);
         }
+
+        private static string ParseName(JToken canonicalDataJObject) => canonicalDataJObject.Value<string>("exercise");
+
+        private static string ParseVersion(JToken canonicalDataJObject) => canonicalDataJObject.Value<string>("version");
+
+        private static CanonicalDataCase[] ParseCanonicalDataCases(JObject canonicalDataJObject) => CanonicalDataCaseParser.Parse((JArray)canonicalDataJObject["cases"]);
     }
 }