trackler 2.2.1.20 → 2.2.1.21

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

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Generators.Input;
+using Generators.Output;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class ComplexNumbers : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            canonicalData.Exercise = "complex-number";
+
+            // Ensure the Real and Imaginary methods are tested first as they're used later to assert equality between complex numbers
+            canonicalData.Cases = canonicalData.Cases.OrderBy(c => c.Property == "real" || c.Property == "imaginary" ? 0 : 1).ToArray();
+
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.TestedMethodType = TestedMethodType.Instance;
+
+                // Process expected
+                if (IsComplexNumber(canonicalDataCase.Expected))
+                {
+                    canonicalDataCase.UseVariableForExpected = true;
+                }
+
+                canonicalDataCase.Expected = ConvertToType(canonicalDataCase.Expected);
+
+                // Process constructor param
+                var constructorParamName = canonicalDataCase.Input.ContainsKey("input") ? "input" : "z1";
+
+                var constructorParamValues = canonicalDataCase.Input[constructorParamName]
+                    .ConvertToEnumerable<string>()
+                    .Select(v => ConvertMathDouble(v))
+                    .ToArray();
+
+                canonicalDataCase.ConstructorInput = new Dictionary<string, object>
+                {
+                    ["real"] = constructorParamValues[0],
+                    ["imaginary"] = constructorParamValues[1]
+                };
+
+                canonicalDataCase.Input.Remove(constructorParamName);
+
+                // Process function param
+                var keys = canonicalDataCase.Input.Keys.ToArray();
+
+                foreach (var key in keys)
+                {
+                    canonicalDataCase.Input[key] = ConvertToType(canonicalDataCase.Input[key]);
+                }
+            }
+        }
+
+        protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
+        {
+            if (testMethodBody.UseVariableForExpected)
+                return RenderComplexNumberAssert(testMethodBody);
+
+            return base.RenderTestMethodBodyAssert(testMethodBody);
+        }
+
+        private static string RenderComplexNumberAssert(TestMethodBody testMethodBody)
+        {
+            var tmeplate = "Assert.Equal({{ ExpectedParameter }}.Real(), {{ TestedValue }}.Real(), 15);\r\nAssert.Equal({{ ExpectedParameter }}.Imaginary(), {{ TestedValue }}.Imaginary(), 15);";
+
+            return TemplateRenderer.RenderInline(tmeplate, testMethodBody.AssertTemplateParameters);
+        }
+
+        protected override HashSet<string> GetUsingNamespaces()
+        {
+            var usingNamespaces = base.GetUsingNamespaces();
+            usingNamespaces.Add(typeof(Math).Namespace);
+
+            return usingNamespaces;
+        }
+
+        private object ConvertToType(object rawValue)
+        {
+            if (IsComplexNumber(rawValue))
+            {
+                var array = rawValue
+                    .ConvertToEnumerable<string>()
+                    .Select(rv => ConvertToType(rv))
+                    .ToArray();
+
+                return new UnescapedValue($"new ComplexNumber({array[0]}, {array[1]})");
+            }
+            else if (rawValue is string)
+            {
+                return ConvertMathDouble((string)rawValue);
+            }
+            else
+            {
+                return rawValue;
+            }
+        }
+
+        private bool IsComplexNumber(object rawValue)
+        {
+            return rawValue is JArray;
+        }
+
+        private object ConvertMathDouble(string value)
+        {
+            switch (value)
+            {
+                case "e":
+                    return new UnescapedValue("Math.E");
+                case "pi":
+                    return new UnescapedValue("Math.PI");
+                default:
+                    return double.Parse(value);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+using System;
+using Generators.Input;
+
+namespace Generators.Exercises
+{
+    public class Grains : Exercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                if (ShouldThrowException(canonicalDataCase.Expected))
+                {
+                    canonicalDataCase.ExceptionThrown = typeof(ArgumentOutOfRangeException);
+                }
+                else
+                {
+                    canonicalDataCase.Expected = ulong.Parse(canonicalDataCase.Expected.ToString());
+                }
+            }
+        }
+
+        private static bool ShouldThrowException(object value)
+        {
+            return int.TryParse(value.ToString(), out int result)
+                && result == -1;
+        }
+    }
+}

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

@@ -32,6 +32,8 @@ public static object Format(object val)
                     return dbl.ToString(CultureInfo.InvariantCulture);
                 case float flt:
                     return flt.ToString(CultureInfo.InvariantCulture);
+                case ulong ulng:
+                    return $"{ulng}UL";
                 case char c:
                     return $"'{c}'";
                 default:

data/tracks/delphi/exercises/two-fer/utwoferExample.pas

@@ -2,15 +2,12 @@ unit utwofer;
 
 interface
 
-  function twoFer(aName: string=''): string;
+  function twoFer(aName: string='you'): string;
 
 implementation
-uses SysUtils;
 
-function twoFer(aName: string=''): string;
+function twoFer(aName: string='you'): string;
 begin
-  if trim(aName).IsEmpty then
-    aName := 'you';
   result := 'One for ' + aName + ', one for me.';
 end;
 

data/tracks/ecmascript/exercises/queen-attack/example.js

@@ -1,10 +1,34 @@
-const W = 8,
-  H = 8,
-  STARTING = { black: [7, 3], white: [0, 3] };
+const W = 8;
+const H = 8;
+const STARTING = { black: [7, 3], white: [0, 3] };
+
+function samePosition({ white, black }) {
+  return white[0] === black[0] && white[1] === black[1];
+}
+
+function buildRow(cell, colCount) {
+  return Array(...Array(colCount)).map(() => cell);
+}
+
+function concatRows(row, rowCount) {
+  return [...Array.prototype.concat.apply(buildRow(row, rowCount)).join('')];
+}
+
+function constructBoard() {
+  let row = buildRow('_ ', W).join('');
+  row = `${row.substring(0, row.length - 1)}\n`;
+  return concatRows(row, H);
+}
+
+function placePieces(self) {
+  const board = self.board;
+  board[(self.black[0] * W * 2) + (self.black[1] * 2)] = 'B';
+  board[(self.white[0] * W * 2) + (self.white[1] * 2)] = 'W';
+}
 
 const QueenAttack = (params = STARTING) => {
   const self = this instanceof QueenAttack ? this : Object.getPrototypeOf(QueenAttack);
-  if (params && params.white === params.black) {
+  if (samePosition(params)) {
     throw new Error('Queens cannot share the same space');
   }
 
@@ -25,23 +49,4 @@ const QueenAttack = (params = STARTING) => {
   return self;
 };
 
-function constructBoard() {
-  let row = buildRow('_ ', W).join('');
-  row = `${row.substring(0, row.length - 1)}\n`;
-  return concatRows(row, H);
-}
-
-function placePieces(self) {
-  self.board[self.black[0] * W * 2 + self.black[1] * 2] = 'B';
-  self.board[self.white[0] * W * 2 + self.white[1] * 2] = 'W';
-}
-
-function buildRow(cell, colCount) {
-  return Array(...Array(colCount)).map(() => cell);
-}
-
-function concatRows(row, rowCount) {
-  return [...Array.prototype.concat.apply(buildRow(row, rowCount)).join('')];
-}
-
 export default QueenAttack;

data/tracks/ecmascript/exercises/queen-attack/queen-attack.spec.js

@@ -15,26 +15,21 @@ describe('Queens', () => {
 
   xtest('cannot occupy the same space', () => {
     const positioning = { white: [2, 4], black: [2, 4] };
-
-    try {
-      new Queens(positioning);
-    } catch (error) {
-      expect(error).toEqual('Queens cannot share the same space');
-    }
+    const expectedError = 'Queens cannot share the same space';
+    expect(() => new Queens(positioning)).toThrow(expectedError);
   });
 
   xtest('toString representation', () => {
     const positioning = { white: [2, 4], black: [6, 6] };
     const queens = new Queens(positioning);
-    const board = '_ _ _ _ _ _ _ _\n\
-_ _ _ _ _ _ _ _\n\
-_ _ _ _ W _ _ _\n\
-_ _ _ _ _ _ _ _\n\
-_ _ _ _ _ _ _ _\n\
-_ _ _ _ _ _ _ _\n\
-_ _ _ _ _ _ B _\n\
-_ _ _ _ _ _ _ _\n\
-';
+    const board = ['_ _ _ _ _ _ _ _',
+      '_ _ _ _ _ _ _ _',
+      '_ _ _ _ W _ _ _',
+      '_ _ _ _ _ _ _ _',
+      '_ _ _ _ _ _ _ _',
+      '_ _ _ _ _ _ _ _',
+      '_ _ _ _ _ _ B _',
+      '_ _ _ _ _ _ _ _\n'].join('\n');
     expect(queens.toString()).toEqual(board);
   });
 

data/tracks/java/config.json

@@ -1,6 +1,7 @@
 {
   "language": "Java",
   "active": true,
+  "blurb": "Java is a very widely used Object Oriented programming language. It's safe, simple to use and portable so that you can \"write once, run anywhere\".",
   "exercises": [
     {
       "uuid": "f77dc7e3-35a8-4300-a7c8-2c1765e9644d",

data/tracks/r/exercises/perfect-numbers/example.R

@@ -1,4 +1,4 @@
-is_perfect <- function(n){
+number_type <- function(n){
   
   # catch invalid input
   if (n <= 0)

data/tracks/r/exercises/perfect-numbers/perfect-numbers.R

@@ -1,3 +1,3 @@
-is_perfect <- function(n){
+number_type <- function(n){
   
 }

data/tracks/r/exercises/perfect-numbers/test_perfect-numbers.R

@@ -3,73 +3,73 @@ library(testthat)
 
 test_that("Smallest perfect number is classified correctly", {
   n <- 6
-  expect_equal(is_perfect(n), "perfect")
+  expect_equal(number_type(n), "perfect")
 })
 
 test_that("Medium perfect number is classified correctly", {
   n <- 28
-  expect_equal(is_perfect(n), "perfect")
+  expect_equal(number_type(n), "perfect")
 })
 
 test_that("Large perfect number is classified correctly", {
   n <- 33550336
-  expect_equal(is_perfect(n), "perfect")
+  expect_equal(number_type(n), "perfect")
 })
 
 
 
 test_that("Smallest abundant number is classified correctly", {
   n <- 12
-  expect_equal(is_perfect(n), "abundant")
+  expect_equal(number_type(n), "abundant")
 })
 
 test_that("Medium abundant number is classified correctly", {
   n <- 30
-  expect_equal(is_perfect(n), "abundant")
+  expect_equal(number_type(n), "abundant")
 })
 
 test_that("Large abundant number is classified correctly", {
   n <- 33550335
-  expect_equal(is_perfect(n), "abundant")
+  expect_equal(number_type(n), "abundant")
 })
 
 
 
 test_that("Smallest prime deficient number is classified correctly", {
   n <- 2
-  expect_equal(is_perfect(n), "deficient")
+  expect_equal(number_type(n), "deficient")
 })
 
 test_that("Smallest non-prime deficient number is classified correctly", {
   n <- 4
-  expect_equal(is_perfect(n), "deficient")
+  expect_equal(number_type(n), "deficient")
 })
 
 test_that("Medium deficient number is classified correctly", {
   n <- 32
-  expect_equal(is_perfect(n), "deficient")
+  expect_equal(number_type(n), "deficient")
 })
 
 test_that("Large deficient number is classified correctly", {
   n <- 33550337
-  expect_equal(is_perfect(n), "deficient")
+  expect_equal(number_type(n), "deficient")
 })
 
 test_that("Edge case (no factors other than itself) is classified correctly", {
   n <- 1
-  expect_equal(is_perfect(n), "deficient")
+  expect_equal(number_type(n), "deficient")
 })
 
 
 
 test_that("Zero is rejected (not a natural number)", {
   n <- 0
-  expect_error(is_perfect(n))
+  expect_error(number_type(n))
 })
 
 test_that("Negative integer is rejected (not a natural number)", {
   n <- -1
-  expect_error(is_perfect(n))
+  expect_error(number_type(n))
 })
 
 

data/tracks/ruby/docs/24pullrequests.md

@@ -18,4 +18,4 @@ Something missing?  Create a pull request!
 
 Check out the [Getting Involved in a Track](https://github.com/exercism/exercism.io/blob/master/docs/getting-involved-in-a-track.md) documentation, and some [ideas for things we are looking for](http://exercism.io/languages/ruby/todo) for exercises that are needed to be implemented.
 
-We are available to answer questions in the  [![Join the chat at https://gitter.im/exercism/ruby](https://badges.gitter.im/exercism/ruby.svg)](https://gitter.im/exercism/ruby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge).
+We are available to answer questions in the [![Join the chat at https://gitter.im/exercism/ruby](https://badges.gitter.im/exercism/ruby.svg)](https://gitter.im/exercism/ruby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge).

data/tracks/ruby/exercises/hello-world/.meta/generator/test_template.erb

@@ -4,7 +4,7 @@ begin
   require_relative 'hello_world'
 rescue Gem::LoadError => e
   puts "\nMissing Dependency:\n#{e.backtrace.first} #{e.message}"
-  puts 'Minitest 5.0 gem must be installed for the xRuby track.'
+  puts 'Minitest 5.0 gem must be installed for the Ruby track.'
 rescue LoadError => e
   puts "\nError:\n#{e.backtrace.first} #{e.message}"
   puts DATA.read

data/tracks/ruby/exercises/hello-world/hello_world_test.rb

@@ -4,7 +4,7 @@ begin
   require_relative 'hello_world'
 rescue Gem::LoadError => e
   puts "\nMissing Dependency:\n#{e.backtrace.first} #{e.message}"
-  puts 'Minitest 5.0 gem must be installed for the xRuby track.'
+  puts 'Minitest 5.0 gem must be installed for the Ruby track.'
 rescue LoadError => e
   puts "\nError:\n#{e.backtrace.first} #{e.message}"
   puts DATA.read

data/tracks/ruby/test/generator/command_line/generator_optparser_test.rb

@@ -4,7 +4,7 @@ module Generator
   class GeneratorOptparserTest < Minitest::Test
     FixturePaths = Paths.new(
       metadata: 'test/fixtures/metadata',
-      track: 'test/fixtures/xruby'
+      track: 'test/fixtures/ruby'
     )
 
     def default_options

data/tracks/ruby/test/generator/command_line_test.rb

@@ -4,7 +4,7 @@ module Generator
   class CommandLineTest < Minitest::Test
     FixturePaths = Paths.new(
       metadata: 'test/fixtures/metadata',
-      track: 'test/fixtures/xruby'
+      track: 'test/fixtures/ruby'
     )
 
     def test_parse

data/tracks/ruby/test/generator/files/metadata_files_test.rb

@@ -4,7 +4,7 @@ module Generator
     class MetadataFilesTest < Minitest::Test
       FixturePaths = Paths.new(
         metadata: 'test/fixtures/metadata',
-        track: 'test/fixtures/xruby'
+        track: 'test/fixtures/ruby'
       )
 
       class TestMetadataFiles