trackler 2.2.1.151 → 2.2.1.152

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

@@ -26,11 +26,6 @@ public class ConfigExercise
         {
             public string Name => Slug.ToExerciseName();
             public string Slug { get; set; }
-            public bool Core { get; set; }
-            public int Difficulty { get; set; }
-            public string[] Topics { get; set; }
-            public string Unlocked_By { get; set; }
-            public string UUID { get; set; }
             public bool Deprecated { get; set; }
         }
     }

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

@@ -3,5 +3,25 @@
     public static class ConvertHelper
     {
         public static string ToMultiLineString(this object obj) => string.Join("\n", obj as object[]);
+
+        public static string ToMultiLineString(this object obj, string empty)
+        {
+            var arr = obj as object[];
+
+            if (arr == null || arr.Length == 0)
+                return empty;
+
+            return string.Join("\n", obj as object[]);
+        }
+
+        public static T[] ToArray<T>(this object obj)
+        {
+            var arr = obj as T[];
+
+            if (arr == null || arr.Length == 0)
+                return new T[0];
+
+            return arr;
+        }
     }
 }

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

@@ -0,0 +1,14 @@
+// This file was auto-generated based on version {{CanonicalDataVersion}} of the canonical data.
+
+{%- for namespace in UsingNamespaces -%}
+using {{ namespace }};
+{%- endfor -%}
+
+public class {{ClassName}} : IDisposable
+{
+{%- for method in Methods -%}
+{{ method | indent }}
+{%- if forloop.last == false %}
+{% endif -%}
+{%- endfor -%}
+}

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

@@ -13,15 +13,12 @@ public class TestMethodBodyData
 
         private readonly TestMethodBody _testMethodBody;
 
-        public TestMethodBodyData(TestMethodBody testMethodBody)
-        {
-            _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 => key.ToVariableName())) : Input;
-        public object ExpectedParameter => _testMethodBody.UseVariableForExpected ? ExpectedVariableName : Expected;
-        public object ConstructorParameters => _testMethodBody.UseVariablesForConstructorParameters ? string.Join(", ", CanonicalDataCase.ConstructorInput.Keys.Select(key => key.ToVariableName())) : ConstructorInput;
+        public string TestedValue => _testMethodBody.UseVariableForTested ? TestedVariableName : TestedMethodInvocation;
+        public string InputParameters => _testMethodBody.UseVariablesForInput ? string.Join(", ", CanonicalDataCase.InputParameters.Select(key => key.ToVariableName())) : ValueFormatter.Format(Input);
+        public string ExpectedParameter => _testMethodBody.UseVariableForExpected ? ExpectedVariableName : ValueFormatter.Format(CanonicalDataCase.Expected);
+        public string ConstructorParameters => _testMethodBody.UseVariablesForConstructorParameters ? string.Join(", ", CanonicalDataCase.ConstructorInputParameters.Select(key => key.ToVariableName())) : ValueFormatter.Format(ConstructorInput);
 
         private CanonicalDataCase CanonicalDataCase => _testMethodBody.CanonicalDataCase;
         private CanonicalData CanonicalData => _testMethodBody.CanonicalData;
@@ -29,13 +26,13 @@ public TestMethodBodyData(TestMethodBody testMethodBody)
         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 IDictionary<string, object> Input => CanonicalDataCase.InputParameters.ToDictionary(key => key, key => CanonicalDataCase.Input[key]); 
+        private IDictionary<string, object> ConstructorInput => CanonicalDataCase.ConstructorInputParameters.ToDictionary(key => key, key => CanonicalDataCase.Input[key]);
+        private object Expected => CanonicalDataCase.Expected;
 
-        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> InputVariablesDeclaration => ValueFormatter.FormatVariables(Input);
+        private IEnumerable<string> ExpectedVariableDeclaration => ValueFormatter.FormatVariable(Expected, ExpectedVariableName);
+        private IEnumerable<string> ConstructorVariablesDeclaration => ValueFormatter.FormatVariables(ConstructorInput);
         private IEnumerable<string> SutVariableDeclaration => new[] { $"var {SutVariableName} = new {TestedClassName}({ConstructorParameters});" };
         private IEnumerable<string> ActualVariableDeclaration => new[] { $"var {TestedVariableName} = {TestedMethodInvocation};" };
 

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

@@ -8,7 +8,7 @@ namespace Generators.Output
 {
     public static class ValueFormatter
     {
-        public static object Format(object val)
+        public static string Format(object val)
         {
             switch (val)
             {
@@ -25,14 +25,15 @@ public static object Format(object val)
                 case IDictionary<string, object> dict: return dict.Format();
                 case IDictionary<char, int> dict: return dict.Format();
                 case IDictionary<string, int> dict: return dict.Format();
+                case IDictionary<int, string[]> dict: return dict.Format();
                 case JArray jArray: return jArray.Format();
                 case int[,] multidimensionalArray: return multidimensionalArray.Format();
                 case IEnumerable<Tuple<string, object>> tuples: return tuples.Format();
-                default: return val;
+                default: return val?.ToString();
             }
         }
 
-        public static string[] FormatVariables(IReadOnlyDictionary<string, object> dict)
+        public static string[] FormatVariables(IDictionary<string, object> dict)
             => dict.Keys.SelectMany(key => FormatVariable(dict[key], key.ToVariableName())).ToArray();
 
         public static string[] FormatVariable(object val, string name)
@@ -41,10 +42,19 @@ public static string[] FormatVariable(object val, string name)
             {
                 case string str when str.Contains("\n"):
                     return FormatMultiLineString(name, str);
+                case IEnumerable<string> strings:
+                    if (!strings.Any())
+                    {
+                        return new[] { $"var {name} = new string[0];" };
+                    }
+
+                    return FormatMultiLineEnumerable(strings.Select((str, i) => str.Format() + (i < strings.Count() - 1 ? "," : "")), name, "new[]");
                 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>");
                 case IDictionary<string, int> dict:
                     return FormatMultiLineEnumerable(dict.Keys.Select((key, i) => $"[{Format(key)}] = {Format(dict[key])}" + (i < dict.Keys.Count - 1 ? "," : "")), name, "new Dictionary<string, int>");
+                case IDictionary<int, string[]> dict:
+                    return FormatMultiLineEnumerable(dict.Keys.Select((key, i) => $"[{Format(key)}] = {Format(dict[key])}" + (i < dict.Keys.Count - 1 ? "," : "")), name, "new Dictionary<int, string[]>");
                 default:
                     return new[] { $"var {name} = {Format(val)};" };
             }
@@ -75,7 +85,7 @@ public static string[] FormatVariable(object val, string name)
         private static string Format(this IEnumerable<UnescapedValue> unescapedValues) =>
             $"new[] {{ {string.Join(", ", unescapedValues.Select(Format))} }}";
 
-        private static string Format(this IDictionary<string, object> dict) => 
+        private static string Format(this IDictionary<string, object> dict) =>
             string.Join(", ", dict.Values.Select(Format));
 
         private static string Format(this IDictionary<char, int> dict) =>
@@ -84,17 +94,20 @@ public static string[] FormatVariable(object val, string name)
         private static string Format(this IDictionary<string, int> dict) =>
             $"new Dictionary<string, int> {{ {string.Join(", ", dict.Keys.Select(key => $"[{Format(key)}] = {Format(dict[key])}"))} }}";
 
-        private static string Format(this JArray jArray) => 
+        private static string Format(this IDictionary<int, string[]> dict) =>
+            $"new Dictionary<int, string[]> {{ {string.Join(", ", dict.Keys.Select(key => $"[{Format(key)}] = {Format(dict[key])}"))} }}";
+
+        private static string Format(this JArray jArray) =>
             $"new[] {{ {string.Join(", ", jArray.Select(Format))} }}";
 
         private static string Format(this int[,] multidimensionalArray)
         {
-            return multidimensionalArray.GetLength(0) > 1
+            return multidimensionalArray.GetLength(0) > 0
                             ? $"new[,]\r\n{{\r\n    {string.Join(",\r\n    ", Enumerable.Range(0, multidimensionalArray.GetUpperBound(0) + 1).Select(x => multidimensionalArray.SliceRow(x).ToNestedArray()))}\r\n}}"
                             : "new int[,] { }";
         }
 
-        private static string Format(this IEnumerable<Tuple<string, object>> tuples) => 
+        private static string Format(this IEnumerable<Tuple<string, object>> tuples) =>
             $"new[] {{ {string.Join(", ", tuples.Select(Format))} }}";
 
         private static string ToNestedArray<T>(this IEnumerable<T> enumerable) =>

data/tracks/delphi/config.json

@@ -153,6 +153,17 @@
         "recursion"
       ]
     },
+    {
+      "slug": "grade-school",
+      "uuid": "37d13c81-2347-4620-931b-11ae46ea95f8",
+      "core": true,
+      "unlocked_by": null,
+      "difficulty": 2,
+      "topics": [
+        "lists",
+        "sorting"
+      ]
+    },
     {
       "slug": "collatz-conjecture",
       "uuid": "edfc2903-1165-4029-9901-0be72b32865f",
@@ -197,6 +208,17 @@
         "transforming"
       ]
     },
+    {
+      "slug": "proverb",
+      "uuid": "aa42eae2-9a5c-4d01-8900-fad674434cd5",
+      "core": false,
+      "unlocked_by": "raindrops",
+      "difficulty": 3,
+      "topics": [
+        "algorithms",
+        "strings"
+      ]
+    },
     {
       "slug": "secret-handshake",
       "uuid": "2032ba03-845a-460b-ad93-0958e97eb7cc",

data/tracks/delphi/exercises/grade-school/GradeSchool.dpr

@@ -0,0 +1,60 @@
+program BracketPush;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uGradeSchoolTest in 'uGradeSchoolTest.pas',
+  uGradeSchool in 'uGradeSchool.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.

data/tracks/delphi/exercises/grade-school/README.md

@@ -0,0 +1,62 @@
+# Grade School
+
+Given students' names along with the grade that they are in, create a roster
+for the school.
+
+In the end, you should be able to:
+
+- Add a student's name to the roster for a grade
+  - "Add Jim to grade 2."
+  - "OK."
+- Get a list of all students enrolled in a grade
+  - "Which students are in grade 2?"
+  - "We've only got Jim just now."
+- Get a sorted list of all students in all grades.  Grades should sort
+  as 1, 2, 3, etc., and students within a grade should be sorted
+  alphabetically by name.
+  - "Who all is enrolled in school right now?"
+  - "Grade 1: Anna, Barb, and Charlie. Grade 2: Alex, Peter, and Zoe.
+    Grade 3…"
+
+Note that all our students only have one name.  (It's a small town, what
+do you want?)
+
+## For bonus points
+
+Did you get the tests passing and the code clean? If you want to, these
+are some additional things you could try:
+
+- If you're working in a language with mutable data structures and your
+  implementation allows outside code to mutate the school's internal DB
+  directly, see if you can prevent this. Feel free to introduce additional
+  tests.
+
+Then please share your thoughts in a comment on the submission. Did this
+experiment make the code better? Worse? Did you learn anything from it?
+
+## Testing
+
+In order to run the tests for this track, you will need to install
+DUnitX. Please see the [installation](http://www.exercism.io/languages/delphi/installation) instructions for more information.
+
+### Loading Exercises into Delphi
+
+If Delphi is properly installed, and `*.dpr` file types have been associated with Delphi, then double clicking the supplied `*.dpr` file will start Delphi and load the exercise/project.  `control + F9` is the keyboard shortcut to compile the project or pressing `F9` will compile and run the project.
+
+Alternatively you may opt to start Delphi and load your project via. the `File` drop down menu.
+
+### When Questions Come Up
+We monitor the [Pascal-Delphi](https://gitter.im/exercism/Pascal-Delphi) support room on [gitter.im](https://gitter.im) to help you with any questions that might arise.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the exercise file you're submitting is in the `exercism/delphi/<exerciseName>` directory.
+
+For example, if you're submitting `ubob.pas` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/delphi/bob/ubob.pas`.
+
+## Source
+
+A pairing session with Phil Battos at gSchool [http://gschool.it](http://gschool.it)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/delphi/exercises/grade-school/uGradeSchoolExample.pas

@@ -0,0 +1,134 @@
+unit uGradeSchool;
+
+interface
+uses System.Generics.Collections;
+
+type
+  TRoster = TList<string>;
+
+  ISchool = interface(IInterface)
+    ['{8C6DC96D-E56E-4726-B045-F4AFE95DBEB5}']
+    procedure Add(aStudent: string; aGrade: integer);
+    function Roster: TRoster;
+    function Grade(aGrade: integer): TRoster;
+  end;
+
+function NewSchool: ISchool;
+
+implementation
+uses
+  SysUtils;
+
+{ TSchool }
+type
+  TSchool = class(TInterfacedObject, ISchool)
+  private
+    fRoster: TDictionary<integer, TRoster>;
+    fLowGrade: integer;
+    fHighGrade: integer;
+  public
+    constructor create;
+    destructor destroy; override;
+    procedure Add(aStudent: string; aGrade: integer);
+    function Roster: TRoster;
+    function Grade(aGrade: integer): TRoster;
+  end;
+
+function NewSchool: ISchool;
+begin
+  result := TSchool.create;
+end;
+
+procedure TSchool.Add(aStudent: string; aGrade: integer);
+
+    function highGrade: integer;
+    var
+      lItem: TPair<integer, TRoster>;
+    begin
+      result := 0;
+      if fRoster.Count > 0 then
+      begin
+        result := integer.MinValue;
+        for lItem in fRoster do
+          if lItem.Key > result then
+            result := lItem.Key;
+      end;
+    end;
+
+    function lowGrade: integer;
+    var
+      lItem: TPair<integer, TRoster>;
+    begin
+      result := 0;
+      if fRoster.Count > 0 then
+      begin
+        result := integer.MaxValue;
+        for lItem in fRoster do
+          if lItem.Key < result then
+            result := lItem.Key;
+      end;
+    end;
+
+    procedure UpdateHighAndLowGrades;
+    begin
+      fLowGrade := lowGrade;
+      fHighGrade := highGrade;
+    end;
+
+begin
+  if not fRoster.ContainsKey(aGrade) then
+    fRoster.Add(aGrade, TRoster.Create);
+  fRoster[aGrade].Add(aStudent);
+  fRoster[aGrade].Sort;
+  UpdateHighAndLowGrades;
+end;
+
+constructor TSchool.create;
+begin
+  inherited create;
+  fRoster := TDictionary<integer, TRoster>.Create;
+  fLowGrade := 0;
+  fHighGrade := 0;
+end;
+
+destructor TSchool.destroy;
+var
+  lGrade: TPair<integer, TRoster>;
+begin
+  if assigned(fRoster) then
+  begin
+    if fRoster.Count > 0 then
+    begin
+      for lGrade in fRoster do
+      begin
+        lGrade.Value.Clear;
+        lGrade.Value.DisposeOf;
+      end;
+    end;
+    fRoster.DisposeOf;
+  end;
+  inherited;
+end;
+
+function TSchool.Grade(aGrade: integer): TRoster;
+var
+  lStudents: TRoster;
+begin
+  result := TRoster.Create;
+  if fRoster.TryGetValue(aGrade, lStudents) then
+    result.AddRange(lStudents.ToArray);
+end;
+
+function TSchool.Roster: TRoster;
+var
+  lGrade: TPair<integer, TRoster>;
+  lRoster: TRoster;
+  idxGrade: integer;
+begin
+  result := TRoster.Create;
+  for idxGrade := fLowGrade to fHighGrade do
+    if fRoster.TryGetValue(idxGrade, lRoster) then
+      result.AddRange(lRoster.ToArray);
+end;
+
+end.