trackler 2.0.8.24 → 2.0.8.26

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

@@ -1,10 +1,20 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
+using Generators.Classes;
+using Generators.Data;
+using Generators.Methods;
 using Humanizer;
+using Newtonsoft.Json.Linq;
+using To = Generators.Helpers.To;
 
 namespace Generators.Exercises
 {
     public abstract class Exercise
     {
+        private static readonly BooleanTestMethodGenerator BooleanTestMethodGenerator = new BooleanTestMethodGenerator();
+        private static readonly EqualityTestMethodGenerator EqualityTestMethodGenerator = new EqualityTestMethodGenerator();
+        private static readonly ExceptionTestMethodGenerator ExceptionTestMethodGenerator = new ExceptionTestMethodGenerator();
+
         protected Exercise(string name)
         {
             Name = name;
@@ -14,12 +24,57 @@ namespace Generators.Exercises
 
         public TestClass CreateTestClass(CanonicalData canonicalData)
         {
-            return new TestClass
+            var testClass = new TestClass
             {
                 ClassName = Name.Transform(To.TestClassName),
-                TestMethods = canonicalData.Cases.Select((canonicalDataCase, index) => CreateTestMethod(canonicalData, canonicalDataCase, index)).ToArray()
+                TestMethods = CreateTestMethods(canonicalData).ToArray()
             };
+
+            AddTestMethodUsingNamespaces(testClass);
+
+            return testClass;
+        }
+
+        private static void AddTestMethodUsingNamespaces(TestClass testClass)
+        {
+            foreach (var testMethod in testClass.TestMethods)
+                testClass.UsingNamespaces.UnionWith(testMethod.UsingNamespaces);
+        }
+
+        protected abstract TestMethod CreateTestMethod(TestMethodData testMethodData);
+
+        protected virtual IEnumerable<TestMethod> CreateTestMethods(CanonicalData canonicalData) 
+            => canonicalData.Cases.Select((t, i) => CreateTestMethod(canonicalData, t, i));
+        
+        protected virtual TestMethod CreateTestMethod(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
+        {
+            var testMethodData = CreateTestMethodData(canonicalData, canonicalDataCase, index);
+            
+            if (testMethodData.CanonicalDataCase.Expected is JObject jObject)
+                return CreateExceptionTestMethod(testMethodData);
+
+            return CreateTestMethod(testMethodData);
         }
-        protected abstract TestMethod CreateTestMethod(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index);
+
+        protected virtual TestMethodData CreateTestMethodData(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index) 
+            => new TestMethodData
+                {
+                    CanonicalData = canonicalData,
+                    CanonicalDataCase = canonicalDataCase,
+                    Index = index,
+                    Options = CreateTestMethodOptions(canonicalData, canonicalDataCase, index)
+                };
+
+        protected virtual TestMethodOptions CreateTestMethodOptions(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index) 
+            => new TestMethodOptions();
+
+        protected virtual TestMethod CreateBooleanTestMethod(TestMethodData testMethodData) 
+            => BooleanTestMethodGenerator.Create(testMethodData);
+
+        protected virtual TestMethod CreateEqualityTestMethod(TestMethodData testMethodData) 
+            => EqualityTestMethodGenerator.Create(testMethodData);
+
+        protected virtual TestMethod CreateExceptionTestMethod(TestMethodData testMethodData)
+            => ExceptionTestMethodGenerator.Create(testMethodData);
     }
 }

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

@@ -0,0 +1,9 @@
+namespace Generators.Exercises
+{
+    public class IsogramExercise : BooleanExercise
+    {
+        public IsogramExercise() : base("isogram")
+        {
+        }
+    }
+}

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

@@ -1,12 +1,9 @@
 namespace Generators.Exercises
 {
-    public class LeapExercise : Exercise
+    public class LeapExercise : BooleanExercise
     {
         public LeapExercise() : base("leap")
         {
         }
-
-        protected override TestMethod CreateTestMethod(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
-            =>  new BooleanTestMethod(canonicalData, canonicalDataCase, index);
     }
 }

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

@@ -0,0 +1,25 @@
+using System;
+using Generators.Data;
+using Generators.Methods;
+using Humanizer;
+
+namespace Generators.Exercises
+{
+    public class NthPrimeExercise : EqualityExercise
+    {
+        public NthPrimeExercise() : base("nth-prime")
+        {
+        }
+
+        protected override TestMethod CreateTestMethod(TestMethodData testMethodData)
+        {
+            if (testMethodData.CanonicalDataCase.Expected is bool b)
+            {
+                testMethodData.Options.ExceptionType = typeof(ArgumentOutOfRangeException);
+                return CreateExceptionTestMethod(testMethodData);
+            }
+
+            return CreateEqualityTestMethod(testMethodData);
+        }   
+    }
+}

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

@@ -0,0 +1,29 @@
+using System;
+using Generators.Data;
+using Generators.Methods;
+using Humanizer;
+
+namespace Generators.Exercises
+{
+    public class PerfectNumbersExercise : EqualityExercise
+    {
+        public PerfectNumbersExercise() : base("perfect-numbers")
+        {
+        }
+
+        protected override TestMethodData CreateTestMethodData(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
+        {
+            var testMethodData = base.CreateTestMethodData(canonicalData, canonicalDataCase, index);
+            testMethodData.Options.ExceptionType = typeof(ArgumentOutOfRangeException);
+            testMethodData.Options.FormatExpected = false;
+
+            if (testMethodData.CanonicalDataCase.Expected is string classificationType)
+                testMethodData.CanonicalDataCase.Expected = GetClassification(classificationType);
+
+            return testMethodData;
+        }
+
+        private static string GetClassification(string classificationType) 
+            => $"Classification.{classificationType.Transform(Humanizer.To.TitleCase)}";
+    }
+}

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

@@ -0,0 +1,9 @@
+namespace Generators.Exercises
+{
+    public class PigLatinExercise : EqualityExercise
+    {
+        public PigLatinExercise() : base("pig-latin")
+        {
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+using Generators.Data;
+using Generators.Methods;
+
+namespace Generators.Exercises
+{
+    public class RaindropsExercise : EqualityExercise
+    {
+        public RaindropsExercise() : base("raindrops")
+        {
+        }
+
+        protected override TestMethodOptions CreateTestMethodOptions(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
+        {
+            var testMethodOptions = base.CreateTestMethodOptions(canonicalData, canonicalDataCase, index);
+            testMethodOptions.InputProperty = "number";
+
+            return testMethodOptions;
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+using Generators.Data;
+using Generators.Methods;
+
+namespace Generators.Exercises
+{
+    public class RomanNumeralsExercise : EqualityExercise
+    {
+        public RomanNumeralsExercise() : base("roman-numerals")
+        {
+        }
+
+        protected override TestMethodData CreateTestMethodData(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index) 
+        {
+            var testMethodData = base.CreateTestMethodData(canonicalData, canonicalDataCase, index);
+            testMethodData.CanonicalDataCase.Property = "ToRoman";
+            testMethodData.CanonicalDataCase.Description = "Number_" + testMethodData.CanonicalDataCase.Description;
+
+            return testMethodData;
+        }
+
+        protected override TestMethodOptions CreateTestMethodOptions(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index) 
+        {
+            var testMethodOptions = new TestMethodOptions();
+            testMethodOptions.InputProperty = "number";
+            testMethodOptions.TestedMethodType = TestedMethodType.Extension;
+
+            return testMethodOptions;
+        }
+    }
+}

data/tracks/csharp/generators/Helpers/StringExtensions.cs

@@ -0,0 +1,8 @@
+namespace Generators.Helpers
+{
+    public static class StringExtensions
+    {
+        public static string EnsureStartsWith(this string str, string value)
+            => str.StartsWith(value) ? str : value + str;
+    }
+}

data/tracks/csharp/generators/{To.cs → Helpers/To.cs}

@@ -1,4 +1,7 @@
-namespace Generators
+using Generators.Classes;
+using Generators.Methods;
+
+namespace Generators.Helpers
 {
     public static class To
     {

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

@@ -0,0 +1,32 @@
+using System;
+using Generators.Helpers;
+
+namespace Generators.Methods
+{
+    public class BooleanTestMethodGenerator : TestMethodGenerator
+    {
+        protected override string Body
+        {
+            get
+            {
+                switch (TestMethodData.Options.TestedMethodType)
+                {
+                    case TestedMethodType.Static:
+                        return $"{Assertion}({TestedClassName}.{TestedMethod}({Input}));";
+                    case TestedMethodType.Instance:
+                        return $"var sut = new {TestedClassName}();\n    {Assertion}(sut.{TestedMethod}({Input}));";
+                    case TestedMethodType.Extension:
+                        return $"{Assertion}({Input}.{TestedMethod}());";
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+
+        private string Assertion
+            => $"Assert.{Convert.ToBoolean(TestMethodData.CanonicalDataCase.Expected)}";
+
+        protected override string TestedMethod
+            => base.TestedMethod.EnsureStartsWith("Is");
+    }
+}

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

@@ -0,0 +1,25 @@
+using System;
+
+namespace Generators.Methods
+{
+    public class EqualityTestMethodGenerator : TestMethodGenerator
+    {
+        protected override string Body 
+        {
+            get
+            {
+                switch (TestMethodData.Options.TestedMethodType)
+                {
+                    case TestedMethodType.Static:
+                        return $"Assert.Equal({Expected}, {TestedClassName}.{TestedMethod}({Input}));";
+                    case TestedMethodType.Instance:
+                        return $"var sut = new {TestedClassName}();\n    Assert.Equal({Expected}, sut.{TestedMethod}({Input}));";
+                    case TestedMethodType.Extension:
+                        return $"Assert.Equal({Expected}, {Input}.{TestedMethod}());";
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        } 
+    }
+}

data/tracks/csharp/generators/Methods/ExceptionTestMethodGenerator.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+
+namespace Generators.Methods
+{
+    public class ExceptionTestMethodGenerator : TestMethodGenerator
+    {
+        protected override string Body 
+        {
+            get
+            {
+                switch (TestMethodData.Options.TestedMethodType)
+                {
+                    case TestedMethodType.Static:
+                        return $"Assert.Throws<{ExceptionType}>(() => {TestedClassName}.{TestedMethod}({Input}));";
+                    case TestedMethodType.Instance:
+                        return $"var sut = new {TestedClassName}();\n    Assert.Throws<{ExceptionType}>(() => sut.{TestedMethod}({Input}));;";
+                    case TestedMethodType.Extension:
+                        return $"Assert.Throws<{ExceptionType}>(() => {Input}.{TestedMethod}());";
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+
+        protected override ISet<string> UsingNamespaces => new HashSet<string> { TestMethodData.Options.ExceptionType.Namespace };
+
+        protected virtual string ExceptionType => TestMethodData.Options.ExceptionType.Name;
+    }
+}

data/tracks/csharp/generators/{TestMethod.cs → Methods/TestMethod.cs}

@@ -1,9 +1,12 @@
-namespace Generators
+using System.Collections.Generic;
+
+namespace Generators.Methods
 {
     public class TestMethod
     {
-        public int Index { get; set; }
+        public ISet<string> UsingNamespaces { get; set; } = new HashSet<string>();
         public string MethodName { get; set; }
         public string Body { get; set; }
+        public int Index { get; set; }
     }
-}
+}

data/tracks/csharp/generators/Methods/TestMethodData.cs

@@ -0,0 +1,12 @@
+using Generators.Data;
+
+namespace Generators.Methods
+{
+    public class TestMethodData
+    {
+        public CanonicalData CanonicalData { get; set; }
+        public CanonicalDataCase CanonicalDataCase { get; set;}
+        public int Index { get; set; }
+        public TestMethodOptions Options { get; set; } = new TestMethodOptions();
+    }
+}

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

@@ -0,0 +1,64 @@
+using System.Collections.Generic;
+using Humanizer;
+using To = Generators.Helpers.To;
+
+namespace Generators.Methods
+{
+    public abstract class TestMethodGenerator
+    {
+        public TestMethod Create(TestMethodData testMethodData)
+        {
+            TestMethodData = testMethodData;
+
+            return new TestMethod
+            {
+                MethodName = MethodName,
+                Body = Body,
+                Index = TestMethodData.Index,
+                UsingNamespaces = UsingNamespaces
+            };
+        }
+
+        protected TestMethodData TestMethodData { get; private set; }
+
+        protected abstract string Body { get; }
+
+        protected virtual ISet<string> UsingNamespaces 
+            => new HashSet<string>();
+
+        protected virtual string MethodName
+            => TestMethodData.CanonicalDataCase.Description.Replace(":", " is").Transform(To.TestMethodName);    
+
+        protected virtual string TestedClassName
+            => TestMethodData.CanonicalData.Exercise.Transform(To.TestedClassName);
+
+        protected virtual string TestedMethod
+            => TestMethodData.CanonicalDataCase.Property.Transform(To.TestedMethodName);
+
+        protected virtual object Input => 
+            TestMethodData.Options.FormatInput 
+                ? FormatValue(InputValue) 
+                : InputValue;
+
+        protected virtual object Expected => 
+            TestMethodData.Options.FormatExpected 
+                ? FormatValue(TestMethodData.CanonicalDataCase.Expected) 
+                : TestMethodData.CanonicalDataCase.Expected;
+
+        protected virtual object InputValue 
+            => TestMethodData.Options.InputProperty == null 
+                ? TestMethodData.CanonicalDataCase.Input 
+                : TestMethodData.CanonicalDataCase.Data[TestMethodData.Options.InputProperty];
+
+        protected virtual object FormatValue(object val)
+        {
+            switch (val)
+            {
+                case string s:
+                    return $"\"{s}\"";
+                default:
+                    return val;
+            }
+        }
+    }
+}

data/tracks/csharp/generators/Methods/TestMethodNameTransformer.cs

@@ -0,0 +1,23 @@
+using System.Text.RegularExpressions;
+using Humanizer;
+
+namespace Generators.Methods
+{
+    public class TestMethodNameTransformer : IStringTransformer
+    {
+        public string Transform(string input)
+        {
+            var methodName = Regex.Replace(input, @"[^\w]+", "_", RegexOptions.Compiled)
+                .Underscore()
+                .Transform(To.TitleCase);
+
+            if (char.IsDigit(methodName[0]))
+                return "Number_" + methodName;
+
+            if (!char.IsLetter(methodName[0]))
+                return "Test_";
+
+            return methodName;
+        }
+    }
+}

data/tracks/csharp/generators/Methods/TestMethodOptions.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Generators.Methods
+{
+    public class TestMethodOptions
+    {
+        public string InputProperty { get; set; }
+        public bool FormatInput { get; set; } = true;
+        public bool FormatExpected { get; set; } = true;
+        public Type ExceptionType { get; set; } = typeof(ArgumentException);
+        public TestedMethodType TestedMethodType { get; set; } = TestedMethodType.Static;
+    }
+}

data/tracks/csharp/generators/{TestMethodRenderer.cs → Methods/TestMethodRenderer.cs}

@@ -1,4 +1,4 @@
-namespace Generators
+namespace Generators.Methods
 {
     public static class TestMethodRenderer
     {

data/tracks/csharp/generators/{TestedMethodNameTransformer.cs → Methods/TestedMethodNameTransformer.cs}

@@ -1,6 +1,6 @@
 using Humanizer;
 
-namespace Generators
+namespace Generators.Methods
 {
     public class TestedMethodNameTransformer : IStringTransformer
     {

data/tracks/csharp/generators/Methods/TestedMethodType.cs

@@ -0,0 +1,9 @@
+namespace Generators.Methods
+{
+    public enum TestedMethodType
+    {
+        Static,
+        Instance,
+        Extension
+    }
+}

data/tracks/csharp/generators/Program.cs

@@ -1,5 +1,7 @@
 using Generators.Exercises;
 using System.IO;
+using Generators.Classes;
+using Generators.Data;
 using Serilog;
 
 namespace Generators

data/tracks/elixir/config.json

@@ -318,6 +318,13 @@
       "topics": [
       ]
     },
+    {
+      "slug": "diffie-hellman",
+      "difficulty": 4,
+      "topics": [
+        "math"
+      ]
+    },
     {
       "slug": "sieve",
       "difficulty": 5,

data/tracks/elixir/exercises/diffie-hellman/HINTS.md

@@ -0,0 +1,10 @@
+For generating random numbers, Erlang's `:rand.uniform` or `Enum.random` are
+good places to start.
+
+`:math.pow |> round` can be used to find the power of a number, and `rem` for
+the modulus.
+
+Neither of those works particularly well (or quickly) for very large integers.
+Cryptography generally makes use of numbers larger than 1024 bits. Erlang's
+:crypto module has a useful function for finding the modulus of a power,
+particularly for enormous integers, but you might need :binary to decode it.

data/tracks/elixir/exercises/diffie-hellman/diffie_hellman.exs

@@ -0,0 +1,61 @@
+defmodule DiffieHellman do
+  @moduledoc """
+  Diffie-Hellman is a method of securely exchanging keys in a public-key
+  cryptosystem. Two users, Alice and Bob, want to share a secret between
+  themselves, while ensuring nobody else can read it.
+
+  Step 0: Alice and Bob agree on two prime numbers, P and G. An attacker, Eve,
+  can intercept these numbers, but without one of Alice or Bob's private keys,
+  we'll see Eve can't do anything useful with them.
+
+  Step 1: Alice and Bob each generate a private key between 1 and P-1.
+  P).
+
+  Step 2: Using the initial primes P and G, Alice and Bob calculate their
+  public keys by raising G to the power of their private key, then calculating
+  the modulus of that number by P. ((G**private_key) % P)
+
+  Step 3: Alice and Bob exchange public keys. Alice and Bob calculate a secret
+  shared key by raising the other's public key to the power of their private
+  key, then doing a modulus of the result by P. Due to the way modulus math
+  works, they should both generate the same shared key.
+
+  Alice calculates: (bob_public ** alice_private) % P
+  Bob calculates: (alice_public ** bob_private) % P
+
+  As long as their private keys are never lost or transmitted, only they know
+  their private keys, so even if Eve has P, G, and both public keys, she can't
+  do anything with them.
+
+  A video example is available at:
+  https://www.khanacademy.org/computing/computer-science/cryptography/modern-crypt/v/diffie-hellman-key-exchange-part-2
+  """
+
+  @doc """
+  Given a prime integer `prime_p`, return a random integer between 1 and `prime_p` - 1
+  """
+  @spec generate_private_key(prime_p :: integer) :: integer
+  def generate_private_key(prime_p) do
+  end
+
+  @doc """
+  Given two prime integers as generators (`prime_p` and `prime_g`), and a private key,
+  generate a public key using the mathematical formula:
+
+  (prime_g **  private_key) % prime_p
+  """
+  @spec generate_public_key(prime_p :: integer, prime_g :: integer, private_key :: integer) :: integer
+  def generate_public_key(prime_p, prime_g, private_key) do
+  end
+
+  @doc """
+  Given a prime integer `prime_p`, user B's public key, and user A's private key,
+  generate a shared secret using the mathematical formula:
+
+  (public_key_b ** private_key_a) % prime_p
+  """
+  @spec generate_shared_secret(prime_p :: integer, public_key_b :: integer, private_key_a :: integer) :: integer
+  def generate_shared_secret(prime_p, public_key_b, private_key_a) do
+  end
+end
+