trackler 2.0.8.19 → 2.0.8.20

data/tracks/csharp/generators/TestMethodRenderer.cs

@@ -0,0 +1,18 @@
+namespace Generators
+{
+    public static class TestMethodRenderer
+    {
+        private const string TestMethodTemplate =
+@"    [Fact{Skip}]
+    public void {Name}()
+    {
+        {Body}
+    }";
+
+        public static string Render(TestMethod testMethod) =>
+            TestMethodTemplate
+                .Replace("{Name}", testMethod.MethodName)
+                .Replace("{Body}", testMethod.Body)
+                .Replace("{Skip}", testMethod.Index == 0 ? "" : "(Skip = \"Remove to run test\")");
+    }
+}

data/tracks/csharp/generators/To.cs

@@ -0,0 +1,7 @@
+namespace Generators
+{
+    public static class To
+    {
+        public static readonly TestMethodNameTransformer TestMethodName = new TestMethodNameTransformer();
+    }
+}

data/tracks/csharp/generators/generate.ps1

@@ -0,0 +1,2 @@
+Invoke-Expression "dotnet restore"
+Invoke-Expression "dotnet run"

data/tracks/csharp/generators/generate.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+exec dotnet restore
+exec dotnet run

data/tracks/delphi/config.json

@@ -164,6 +164,14 @@
         "Transforming"
       ]
     },   
+    {
+      "slug": "roman-numerals",
+      "difficulty": 5,
+      "topics": [
+        "Control-flow (loops)",
+        "Record Helpers"
+      ]
+    },
     {
       "slug": "bowling",
       "difficulty": 6,

data/tracks/delphi/exercises/phone-number/uPhoneNumberExample.pas

@@ -5,10 +5,10 @@ interface
 type
    IPhoneNumber = interface(IInvokable)
    ['{2415B863-E2D7-4E13-BDEF-F7FE9B3E0788}']
-     function GetNumber: string;
+     function GetCleanNumber: string;
      function GetAreaCode: string;
      function ToString: string;
-     property Number: string read GetNumber;
+     property Clean: string read GetCleanNumber;
      property AreaCode: string read GetAreaCode;
    end;
 
@@ -24,7 +24,7 @@ type
      fContainsLetters: TRegex;
      fNumber: string;
      fAreaCode: string;
-     function GetNumber: string;
+     function GetCleanNumber: string;
      function GetAreaCode: string;
      function GetValidatedPhoneNumber(aPhoneNumber: string): string;
      function StripOutNonNumerics(aValue: string): string;
@@ -34,7 +34,7 @@ type
    public
      constructor Create(aPhoneNumber: string);
      function ToString: string;
-     property Number: string read GetNumber;
+     property Clean: string read GetCleanNumber;
      property AreaCode: string read GetAreaCode;
    end;
 
@@ -51,7 +51,7 @@ begin
   fAreaCode := fNumber.Substring(0, 3);
 end;
 
-function TPhoneNumber.GetNumber: string;
+function TPhoneNumber.GetCleanNumber: string;
 begin
   result := fNumber;
 end;
@@ -96,7 +96,7 @@ end;
 
 function TPhoneNumber.ToString: string;
 begin
-  result := Format('(%s) %s-%s',[AreaCode, Number.Substring(3, 3), Number.Substring(6)]);
+  result := Format('(%s) %s-%s',[AreaCode, Clean.Substring(3, 3), Clean.Substring(6)]);
 end;
 
 end.

data/tracks/delphi/exercises/phone-number/uPhoneNumberTests.pas

@@ -17,27 +17,31 @@ type
   public
     [Test]
 //  [Ignore('Comment the "[Ignore]" statement to run the test')]
-    procedure Cleans_parens_spaces_and_dashes;
+    procedure Cleans_the_number;
 
     [Test]
     [Ignore]
     procedure Cleans_numbers_with_dots;
 
+    [Test]
+    [Ignore]
+    procedure Cleans_numbers_with_multiple_spaces;
+
     [Test]
     [Ignore]
     procedure Valid_when_11_digits_and_starting_with_1;
 
     [Test]
     [Ignore]
-    procedure Invalid_when_11_digits;
+    procedure Invalid_when_9_digits;
 
     [Test]
     [Ignore]
-    procedure Invalid_when_12_digits;
+    procedure Invalid_when_11_digits_does_not_start_with_a_1;
 
     [Test]
     [Ignore]
-    procedure Invalid_when_9_digits;
+    procedure Invalid_when_more_than_11_digits;
 
     [Test]
     [Ignore]
@@ -52,7 +56,7 @@ type
     procedure Invalid_with_right_number_of_digits_but_letters_mixed_in;
 
     [Test]
-    [Ignore]
+    [Ignore('This is a bonus test')]
     procedure Has_an_area_code;
 
     [Test]
@@ -63,67 +67,74 @@ type
 implementation
 uses uPhoneNumber;
 
-procedure PhoneNumberTests.Cleans_parens_spaces_and_dashes;
+procedure PhoneNumberTests.Cleans_the_number;
 var phone: IPhoneNumber;
 begin
   phone := NewPhoneNumber('(123) 456-7890');
-  assert.AreEqual('1234567890',phone.Number);
+  assert.AreEqual('1234567890',phone.Clean);
 end;
 
 procedure PhoneNumberTests.Cleans_numbers_with_dots;
 var phone: IPhoneNumber;
 begin
   phone := NewPhoneNumber('123.456.7890');
-  assert.AreEqual('1234567890',phone.Number);
+  assert.AreEqual('1234567890',phone.Clean);
+end;
+
+procedure PhoneNumberTests.Cleans_numbers_with_multiple_spaces;
+var phone: IPhoneNumber;
+begin
+  phone := NewPhoneNumber('123 456   7890   ');
+  assert.AreEqual('1234567890',phone.Clean);
 end;
 
 procedure PhoneNumberTests.Valid_when_11_digits_and_starting_with_1;
 var phone: IPhoneNumber;
 begin
   phone := NewPhoneNumber('11234567890');
-  assert.AreEqual('1234567890', phone.Number);
+  assert.AreEqual('1234567890', phone.Clean);
 end;
 
-procedure PhoneNumberTests.Invalid_when_11_digits;
+procedure PhoneNumberTests.Invalid_when_11_digits_does_not_start_with_a_1;
 var phone: IPhoneNumber;
 begin
   phone := NewPhoneNumber('21234567890');
-  assert.AreEqual('', phone.Number);
+  assert.AreEqual('', phone.Clean);
 end;
 
-procedure PhoneNumberTests.Invalid_when_12_digits;
+procedure PhoneNumberTests.Invalid_when_more_than_11_digits;
 var phone: IPhoneNumber;
 begin
   phone := NewPhoneNumber('321234567890');
-  assert.AreEqual('', phone.Number);
+  assert.AreEqual('', phone.Clean);
 end;
 
 procedure PhoneNumberTests.Invalid_when_9_digits;
 var phone: IPhoneNumber;
 begin
   phone := NewPhoneNumber('123456789');
-  assert.AreEqual('', phone.Number);
+  assert.AreEqual('', phone.Clean);
 end;
 
 procedure PhoneNumberTests.Invalid_with_letters;
 var phone: IPhoneNumber;
 begin
   phone := NewPhoneNumber('123-abc-7890');
-  assert.AreEqual('', phone.Number);
+  assert.AreEqual('', phone.Clean);
 end;
 
 procedure PhoneNumberTests.Invalid_with_punctuations;
 var phone: IPhoneNumber;
 begin
   phone := NewPhoneNumber('123-@:!-7890');
-  assert.AreEqual('', phone.Number);
+  assert.AreEqual('', phone.Clean);
 end;
 
 procedure PhoneNumberTests.Invalid_with_right_number_of_digits_but_letters_mixed_in;
 var phone: IPhoneNumber;
 begin
   phone := NewPhoneNumber('1a2b3c4d5e6f7g8h9i0j');
-  assert.AreEqual('', phone.Number);
+  assert.AreEqual('', phone.Clean);
 end;
 
 procedure PhoneNumberTests.Has_an_area_code;

data/tracks/delphi/exercises/roman-numerals/RomanNumerals.dpr

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

@@ -0,0 +1,49 @@
+unit uRomanNumerals;
+
+interface
+
+type
+  RomanNumeralHelper = record helper for integer
+  public
+    function ToRoman: string;
+  end;
+
+implementation
+uses System.Generics.Collections;
+
+function RomanNumeralHelper.ToRoman: string;
+var ArabicToRomanConversions: TList<TPair<integer, string>>;
+    conversion: TPair<integer, string>;
+    lInt: integer;
+begin
+  result := '';
+  lInt := self;
+  ArabicToRomanConversions := TList<TPair<integer, string>>.create;
+  with ArabicToRomanConversions do
+  begin
+    Add(TPair<integer, string>.Create(1000, 'M'));
+    Add(TPair<integer, string>.Create(900,  'CM'));
+    Add(TPair<integer, string>.Create(500,  'D'));
+    Add(TPair<integer, string>.Create(400,  'CD'));
+    Add(TPair<integer, string>.Create(100,  'C'));
+    Add(TPair<integer, string>.Create(90,   'XC'));
+    Add(TPair<integer, string>.Create(50,   'L'));
+    Add(TPair<integer, string>.Create(40,   'XL'));
+    Add(TPair<integer, string>.Create(10,   'X'));
+    Add(TPair<integer, string>.Create(9,    'IX'));
+    Add(TPair<integer, string>.Create(5,    'V'));
+    Add(TPair<integer, string>.Create(4,    'IV'));
+    Add(TPair<integer, string>.Create(1,    'I'));
+  end;
+
+  for conversion in ArabicToRomanConversions do
+  begin
+    while (lInt div conversion.Key) > 0 do
+    begin
+      lInt := lInt - conversion.Key;
+      result := result + conversion.Value;
+    end;
+  end;
+end;
+
+end.

data/tracks/delphi/exercises/roman-numerals/uRomanNumeralsTest.pas

@@ -0,0 +1,216 @@
+unit uRomanNumeralsTest;
+
+interface
+uses
+  DUnitX.TestFramework;
+
+type
+
+  [TestFixture]
+  RomanNumeralsTest = class(TObject)
+  public
+    [Test]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure One_is_a_single_I;
+
+    [Test]
+    [Ignore]
+    procedure Two_is_two_I_s;
+
+    [Test]
+    [Ignore]
+    procedure Three_is_three_I_s;
+
+    [Test]
+    [Ignore]
+    procedure Four_being_5_minus_1_is_IV;
+
+    [Test]
+    [Ignore]
+    procedure Five_is_a_single_V;
+
+    [Test]
+    [Ignore]
+    procedure Six_being_5_plus_1_is_VI;
+
+    [Test]
+    [Ignore]
+    procedure Nine_being_10_minus_1_is_IX;
+
+    [Test]
+    [Ignore]
+    procedure Twenty_is_two_X_s;
+
+    [Test]
+    [Ignore]
+    procedure Fourty_eight_is_not_50_minus_2_but_rather_40_plus_8;
+
+    [Test]
+    [Ignore]
+    procedure Fifty_is_a_single_L;
+
+    [Test]
+    [Ignore]
+    procedure Ninety_being_100_minus_10_is_XC;
+
+    [Test]
+    [Ignore]
+    procedure One_hundred_is_a_single_C;
+
+    [Test]
+    [Ignore]
+    procedure Sixety_being_50_plus_10_is_LX;
+
+    [Test]
+    [Ignore]
+    procedure Four_hundred_being_500_minus_100_is_CD;
+
+    [Test]
+    [Ignore]
+    procedure Five_hundred_is_a_single_D;
+
+    [Test]
+    [Ignore]
+    procedure Nine_hundred_being_1000_minus_100_is_CM;
+
+    [Test]
+    [Ignore]
+    procedure One_thousand_is_a_single_M;
+
+    [Test]
+    [Ignore]
+    procedure Three_thousand_is_three_M_s;
+  end;
+
+implementation
+uses uRomanNumerals;
+
+procedure RomanNumeralsTest.One_is_a_single_I;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 1;
+  Assert.AreEqual('I', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Two_is_two_I_s;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 2;
+  Assert.AreEqual('II', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Three_is_three_I_s; 
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 3;
+  Assert.AreEqual('III', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Four_being_5_minus_1_is_IV;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 4;
+  Assert.AreEqual('IV', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Five_is_a_single_V;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 5;
+  Assert.AreEqual('V', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Six_being_5_plus_1_is_VI;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 6;
+  Assert.AreEqual('VI', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Nine_being_10_minus_1_is_IX;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 9;
+  Assert.AreEqual('IX', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Twenty_is_two_X_s;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 20;
+  Assert.AreEqual('XX', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Fourty_eight_is_not_50_minus_2_but_rather_40_plus_8;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 48;
+  Assert.AreEqual('XLVIII', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Fifty_is_a_single_L;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 50;
+  Assert.AreEqual('L', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Ninety_being_100_minus_10_is_XC;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 90;
+  Assert.AreEqual('XC', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.One_hundred_is_a_single_C;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 100;
+  Assert.AreEqual('C', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Sixety_being_50_plus_10_is_LX;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 60;
+  Assert.AreEqual('LX', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Four_hundred_being_500_minus_100_is_CD;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 400;
+  Assert.AreEqual('CD', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Five_hundred_is_a_single_D;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 500;
+  Assert.AreEqual('D', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Nine_hundred_being_1000_minus_100_is_CM;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 900;
+  Assert.AreEqual('CM', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.One_thousand_is_a_single_M;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 1000;
+  Assert.AreEqual('M', arabicNumeral.ToRoman);
+end;
+
+procedure RomanNumeralsTest.Three_thousand_is_three_M_s;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 3000;
+  Assert.AreEqual('MMM', arabicNumeral.ToRoman);
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(RomanNumeralsTest);
+end.