trackler 2.1.0.53 → 2.1.0.54

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

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
@@ -21,20 +20,18 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 
             canonicalDataCase.Properties = jToken.ToObject<IDictionary<string, object>>();
             canonicalDataCase.Input = GetInputProperty(jToken);
+            canonicalDataCase.ConstructorInput = new Dictionary<string, object>();
 
             return canonicalDataCase;
         }
 
-        private static object GetInputProperty(JToken jToken)
+        private static IDictionary<string, object> GetInputProperty(JToken jToken)
         {
             var allProperties = jToken.ToObject<IDictionary<string, object>>();
 
             foreach (var nonInputProperty in NonInputProperties)
                 allProperties.Remove(nonInputProperty);
 
-            if (allProperties.Keys.Count == 1)
-                return allProperties[allProperties.Keys.First()];
-
             return allProperties;
         }
 

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

@@ -0,0 +1,28 @@
+using System.IO;
+using System.Linq;
+using LibGit2Sharp;
+
+namespace Generators.Input
+{
+    public static class CanonicalDataFile
+    {
+        private const string CacheDir = "./.cache";
+        private const string ProblemSpecificationsGitUrl = "https://github.com/exercism/problem-specifications.git";
+        private const string RemoteName = "origin";
+
+        static CanonicalDataFile()
+        {
+            if (!Directory.Exists(CacheDir))
+                Repository.Clone(ProblemSpecificationsGitUrl, CacheDir);
+
+            using (var repository = new Repository(CacheDir))
+                Commands.Fetch(repository, RemoteName, Enumerable.Empty<string>(), new FetchOptions(), null);
+        }
+
+        public static string Contents(string exercise)
+        {
+            var exerciseCanonicalDataPath = Path.Combine(CacheDir, "exercises", exercise, "canonical-data.json");
+            return File.ReadAllText(exerciseCanonicalDataPath);
+        }
+    }
+}

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

@@ -1,28 +1,18 @@
-using System;
-using System.ComponentModel.DataAnnotations;
-using System.Net.Http;
+using System.ComponentModel.DataAnnotations;
 using Newtonsoft.Json;
 
 namespace Generators.Input
 {
     public static class CanonicalDataParser
     {
-        private static readonly HttpClient HttpClient = new HttpClient();
-
         public static CanonicalData Parse(string exercise)
         {
-            var canonicalDataJson = DownloadCanonicalDataJson(exercise);
+            var canonicalDataJson = CanonicalDataFile.Contents(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/Options.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using CommandLine;
+
+namespace Generators
+{
+    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; }
+    }
+}

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

@@ -6,7 +6,7 @@ namespace Generators.Output
 {
     public class BooleanTestMethodGenerator : TestMethodGenerator
     {
-        protected override IEnumerable<string> Body => Variables.Append($"Assert.{BooleanAssertMethod}({TestedMethodInvocation});");
+        protected override IEnumerable<string> Body => Variables.Append($"Assert.{BooleanAssertMethod}({TestedValue});");
 
         private string BooleanAssertMethod => Convert.ToBoolean(CanonicalDataCase.Expected).ToString();
     }

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

@@ -1,3 +1,4 @@
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -5,6 +6,22 @@ namespace Generators.Output
 {
     public class EqualityTestMethodGenerator : TestMethodGenerator
     {
-        protected override IEnumerable<string> Body => Variables.Append($"Assert.Equal({ExpectedParameter}, {TestedMethodInvocation});");
+        protected override IEnumerable<string> Body
+        {
+            get
+            {
+                if (ExpectedIsEmptyEnumerable)
+                    return Variables.Append($"Assert.Empty({TestedValue});");
+
+                return Variables.Append($"Assert.Equal({ExpectedParameter}, {TestedValue});");
+            }
+        }
+
+        protected 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/ExceptionTestMethodGenerator.cs

@@ -5,8 +5,11 @@ namespace Generators.Output
 {
     public class ExceptionTestMethodGenerator : TestMethodGenerator
     {
-        protected override IEnumerable<string> Body => Variables.Append($"Assert.Throws<{ExceptionType}>(() => {TestedMethodInvocation});");
-        
-        private string ExceptionType => CanonicalDataCase.ExceptionThrown.FullName;
+        protected override IEnumerable<string> Body => Variables.Append($"Assert.Throws<{ExceptionType}>(() => {TestedValue});");
+
+        protected override bool UseVariableForExpected => false;
+        protected override bool UseVariableForTested => false;
+
+        private string ExceptionType => CanonicalDataCase.ExceptionThrown.Name;
     }
 }

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

@@ -12,7 +12,7 @@ public static void Write(Exercise exercise, string contents)
             Directory.CreateDirectory(Path.GetDirectoryName(testClassFilePath));
             File.WriteAllText(testClassFilePath, contents);
 
-            Log.Information("Generated tests for {Exercise} exercise in {TestFile}.", exercise.Name, testClassFilePath);
+            Log.Information("Generated tests for {Exercise} exercise in {TestFile}", exercise.Name, testClassFilePath);
         }
 
         private static string TestClassFilePath(Exercise exercise) => Path.Combine("..", "exercises", exercise.Name, TestClassFileName(exercise));

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

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using Generators.Input;
 
 namespace Generators.Output
 {
@@ -6,5 +7,6 @@ public class TestMethod
     {
         public string MethodName { get; set; }
         public IEnumerable<string> Body { get; set; }
+        public CanonicalDataCase GeneratedFrom { get; set; }
     }
 }

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

@@ -8,7 +8,7 @@ namespace Generators.Output
     public abstract class TestMethodGenerator
     {
         protected const string SutVariableName = "sut";
-        protected const string InputVariableName = "input";
+        protected const string TestedVariableName = "actual";
         protected const string ExpectedVariableName = "expected";
 
         public TestMethod Create(CanonicalDataCase canonicalDataCase, Exercise exercise)
@@ -16,7 +16,7 @@ public TestMethod Create(CanonicalDataCase canonicalDataCase, Exercise exercise)
             CanonicalDataCase = canonicalDataCase;
             CanonicalData = exercise.CanonicalData;
 
-            return new TestMethod { MethodName = TestMethodName, Body = Body };
+            return new TestMethod { MethodName = TestMethodName, Body = Body, GeneratedFrom = CanonicalDataCase };
         }
 
         protected abstract IEnumerable<string> Body { get; }
@@ -30,31 +30,24 @@ public TestMethod Create(CanonicalDataCase canonicalDataCase, Exercise exercise)
 
         protected object Input => ValueFormatter.Format(CanonicalDataCase.Input);
         protected object Expected => ValueFormatter.Format(CanonicalDataCase.Expected);
+        protected object ConstructorInput => ValueFormatter.Format(CanonicalDataCase.ConstructorInput);
 
-        protected object InputParameters => UseVariablesForInput ? string.Join(", ", InputVariableNames) : Input;
+        protected object InputParameters => UseVariablesForInput ? string.Join(", ", CanonicalDataCase.Input.Keys.Select(key => key.ToVariableName())) : Input;
         protected object ExpectedParameter => UseVariableForExpected ? ExpectedVariableName : Expected;
+        protected object ConstructorParameters => UseVariablesForConstructorParameters ? string.Join(", ", CanonicalDataCase.ConstructorInput.Keys.Select(key => key.ToVariableName())) : ConstructorInput;
+        protected object TestedValue => UseVariableForTested ? TestedVariableName : TestedMethodInvocation;
 
-        protected IEnumerable<string> InputVariablesDeclaration => ValueFormatter.FormatVariables(CanonicalDataCase.Input, InputVariableNames);
+        protected IEnumerable<string> InputVariablesDeclaration => ValueFormatter.FormatVariables(CanonicalDataCase.Input);
         protected IEnumerable<string> ExpectedVariableDeclaration => ValueFormatter.FormatVariable(CanonicalDataCase.Expected, ExpectedVariableName);
-        protected IEnumerable<string> SutVariableDeclaration => new [] {$"var {SutVariableName} = new {TestedClassName}();" };
+        protected IEnumerable<string> ConstructorVariablesDeclaration => ValueFormatter.FormatVariables(CanonicalDataCase.ConstructorInput);
+        protected IEnumerable<string> SutVariableDeclaration => new [] {$"var {SutVariableName} = new {TestedClassName}({ConstructorParameters});" };
+        protected IEnumerable<string> ActualVariableDeclaration => new [] {$"var {TestedVariableName} = {TestedMethodInvocation};" };
 
-        protected bool UseVariablesForInput => CanonicalDataCase.UseInputParameters;
-        protected bool UseVariableForExpected => CanonicalDataCase.UseExpectedParameter;
+        protected virtual bool UseVariablesForInput => CanonicalDataCase.UseVariablesForInput;
+        protected virtual bool UseVariablesForConstructorParameters => CanonicalDataCase.UseVariablesForConstructorParameters;
+        protected virtual bool UseVariableForExpected => CanonicalDataCase.UseVariableForExpected;
+        protected virtual bool UseVariableForTested => CanonicalDataCase.UseVariableForTested;
 
-        protected IEnumerable<string> InputVariableNames
-        {
-            get
-            {
-                switch (CanonicalDataCase.Input)
-                {
-                    case IDictionary<string, object> dict:
-                        return dict.Keys.Select(key => key.ToVariableName());
-                    default:
-                        return new [] { InputVariableName };
-                }
-            }
-        }
-        
         protected IEnumerable<string> Variables
         {
             get
@@ -63,13 +56,19 @@ protected IEnumerable<string> Variables
 
                 if (UseVariablesForInput)
                     lines.AddRange(InputVariablesDeclaration);
-
-                if (UseVariableForExpected)
-                    lines.AddRange(ExpectedVariableDeclaration);
+                
+                if (UseVariablesForConstructorParameters)
+                    lines.AddRange(ConstructorVariablesDeclaration);
 
                 if (CanonicalDataCase.TestedMethodType == TestedMethodType.Instance)
                     lines.AddRange(SutVariableDeclaration);
 
+                if (UseVariableForTested)
+                    lines.AddRange(ActualVariableDeclaration);
+
+                if (UseVariableForExpected)
+                    lines.AddRange(ExpectedVariableDeclaration);
+
                 return lines;
             }
         }

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

@@ -14,6 +14,8 @@ public static object Format(object val)
             {
                 case IDictionary<string, object> dict:
                     return string.Join(", ", dict.Values.Select(Format));
+                case IDictionary<char, int> dict:
+                    return $"new Dictionary<char, int> {{ {string.Join(", ", dict.Keys.Select(key => $"[{Format(key)}] = {Format(dict[key])}"))} }}";
                 case Enum enumeration:
                     return $"{enumeration.GetType().Name}.{enumeration}";
                 case JArray jArray:
@@ -23,26 +25,20 @@ public static object Format(object val)
                 case IEnumerable<int> ints:
                     return ints.Any() ? $"new[] {{ {string.Join(", ", ints)} }}" : "new int[0]";
                 case IEnumerable<string> strings:
-                    return strings.Any() ? $"new[] {{ {string.Join(", ", strings)} }}" : "new string[0]";
+                    return strings.Any() ? $"new[] {{ {string.Join(", ", strings.Select(Format) )} }}" : "new string[0]";
                 case double dbl:
                     return dbl.ToString(CultureInfo.InvariantCulture);
                 case float flt:
                     return flt.ToString(CultureInfo.InvariantCulture);
+                case char c:
+                    return $"'{c}'";
                 default:
                     return val;
             }
         }
 
-        public static string[] FormatVariables(object val, IEnumerable<string> names)
-        {
-            switch (val)
-            {
-                case IDictionary<string, object> dict:
-                    return dict.Keys.SelectMany((key, i) => FormatVariable(dict[key], names.ElementAt(i))).ToArray();
-                default:
-                    return FormatVariable(val, names.First());
-            }
-        }
+        public static string[] FormatVariables(IDictionary<string, object> dict) 
+            => dict.Keys.SelectMany((key, i) => FormatVariable(dict[key], key.ToVariableName())).ToArray();
 
         public static string[] FormatVariable(object val, string name)
         {
@@ -54,6 +50,8 @@ public static string[] FormatVariable(object val, string name)
                     return FormatMultiLineEnumerable(ints.Select(x => x.ToString(CultureInfo.InvariantCulture)), name);
                 case string[] strings when strings.Any():
                     return FormatMultiLineEnumerable(strings, name);
+                case IDictionary<char, int> dict:
+                    return FormatMultiLineEnumerable(dict.Keys.Select((key, i) => $"[{Format(key)}] = {Format(dict[key])}" + (i < dict.Keys.Count - 1 ? "," : "")), name, "new Dictionary<char, int>");
                 default:
                     return new[] {$"var {name} = {Format(val)};"};
             }
@@ -72,13 +70,13 @@ private static string[] FormatMultiLineString(string name, string str)
             return FormatMultiLineVariable(formattedStrings, name);
         }
 
-        private static string[] FormatMultiLineEnumerable(IEnumerable<string> enumerable, string name) 
-            => FormatMultiLineVariable(enumerable.Prepend("{").Append("}"), name);
+        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) 
-            => enumerable.Select(line => line.Indent())
+        private static string[] FormatMultiLineVariable(IEnumerable<string> enumerable, string name, string constructor = null) 
+            => enumerable.Select(line => line == "{" || line == "}" ? line : line.Indent())
                 .AddTrailingSemicolon()
-                .Prepend($"var {name} = ")
+                .Prepend($"var {name} = {constructor}")
                 .ToArray();
 
         private static string EscapeControlCharacters(this string s)

data/tracks/csharp/generators/Program.cs

@@ -1,4 +1,4 @@
-using Generators.Input;
+using CommandLine;
 using Serilog;
 
 namespace Generators
@@ -8,7 +8,9 @@ public static class Program
         public static void Main(string[] args)
         {
             SetupLogger();
-            Generate(args);
+
+            Parser.Default.ParseArguments<Options>(args)
+                .WithParsed(Generate);
         }
 
         private static void SetupLogger()
@@ -18,17 +20,14 @@ private static void SetupLogger()
                 .CreateLogger();
         }
 
-        private static void Generate(string[] exerciseNames)
+        private static void Generate(Options options)
         {
             Log.Information("Generating tests...");
 
-            foreach (var exercise in GetExercises(exerciseNames))
+            foreach (var exercise in new ExerciseCollection(options.Exercises))
                 exercise.Generate();
 
             Log.Information("Generated tests.");
         }
-
-        private static ExerciseCollection GetExercises(string[] exerciseNames) 
-            => exerciseNames.Length == 0 ? new ExerciseCollection() : new ExerciseCollection(exerciseNames);
     }
 }

data/tracks/dart/.travis.yml

@@ -24,4 +24,4 @@ before_script:
 
 script:
   - bin/fetch-configlet
-  - bin/configlet .
+  - bin/configlet lint .

data/tracks/dart/README.md

@@ -1,6 +1,6 @@
 # Exercism Dart Track
 
-![build status](https://travis-ci.org/exercism/dartlang.svg?branch=master)
+![build status](https://travis-ci.org/exercism/dart.svg?branch=master)
 
 Exercism exercises in Dart.
 

data/tracks/delphi/.travis.yml

@@ -2,4 +2,4 @@ language: bash
 
 script:
   - bin/fetch-configlet
-  - bin/configlet .
+  - bin/configlet lint .

data/tracks/delphi/config.json

@@ -200,6 +200,15 @@
       "slug": "book-store",
       "difficulty": 6
     },
+    {
+      "slug": "wordy",
+      "difficulty": 7,
+      "topics": [
+        "Parsing",
+        "Strings",
+        "Transforming"
+      ]
+    },
     {
       "slug": "poker",
       "difficulty": 7,

data/tracks/delphi/docs/TESTS.md

@@ -1,6 +1,6 @@
-## Running The Tests
+## Running The Tests 
 
-Exercises that have been fetched using the Exercism.io [command line client](http://www.exercism.io/cli) are delivered with a minimum of three files: a `readme.md` file, a `.dpr` file, and a `.pas` file.  The `.dpr` file is the Delphi project file and the `.pas` file is the test runner.  Load the Delphi project by either double clicking on the `.dpr` file or by opening the project from with in Delphi.  You will be responsible for creating a new `.pas` file that will contain your solution code that the tests will be run against.  Refer to the `readme.md` file for instruction on how to compile and execute your code.
+Exercises that have been fetched using the [Exercism command line client](http://www.exercism.io/cli) are delivered with a minimum of three files: a `readme.md` file, a `.dpr` file, and a `.pas` file.  The `.dpr` file is the Delphi project file and the `.pas` file is the test runner.  Load the Delphi project by either double clicking on the `.dpr` file or by opening the project from within Delphi.  You will be responsible for creating a new `.pas` file that will contain your solution code that the tests will be run against.  Refer to the `readme.md` file for instruction on how to compile and execute your code.
 
 All tests have been ignored except the first one for you to work on. To continue, just comment the `[Ignore]` attribute on the test to start working on it.
 

data/tracks/delphi/exercises/wordy/Wordy.dpr

@@ -0,0 +1,60 @@
+program Wordy;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uWordyTests in 'uWordyTests.pas',
+  uWordy in 'uWordy.pas';
+
+var
+  runner : ITestRunner;
+  results : IRunResults;
+  logger : ITestLogger;
+  nunitLogger : ITestLogger;
+begin
+{$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX.RunRegisteredTests;
+  exit;
+{$ENDIF}
+  try
+    //Check command line options, will exit if invalid
+    TDUnitX.CheckCommandLine;
+    //Create the test runner
+    runner := TDUnitX.CreateRunner;
+    //Tell the runner to use RTTI to find Fixtures
+    runner.UseRTTI := True;
+    //tell the runner how we will log things
+    //Log to the console window
+    logger := TDUnitXConsoleLogger.Create(true);
+    runner.AddLogger(logger);
+    //Generate an NUnit compatible XML File
+    nunitLogger := TDUnitXXMLNUnitFileLogger.Create(TDUnitX.Options.XMLOutputFile);
+    runner.AddLogger(nunitLogger);
+    runner.FailsOnNoAsserts := False; //When true, Assertions must be made during tests;
+
+    //Run tests
+    results := runner.Execute;
+    if not results.AllPassed then
+      System.ExitCode := EXIT_ERRORS;
+
+    {$IFNDEF CI}
+    //We don't want this happening when running under CI.
+    if TDUnitX.Options.ExitBehavior = TDUnitXExitBehavior.Pause then
+    begin
+      System.Write('Done.. press <Enter> key to quit.');
+      System.Readln;
+    end;
+    {$ENDIF}
+  except
+    on E: Exception do
+      System.Writeln(E.ClassName, ': ', E.Message);
+  end;
+end.