trackler 2.1.0.26 → 2.1.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ea219b914ea27b18a90012564e931c53e884090
-  data.tar.gz: df9c745c274ad3550a164005870ea87fd21f3280
+  metadata.gz: e1cea3469c06413e200a4474c5867dc75dedf961
+  data.tar.gz: 66119d1d8e808237e971dcaeb737b52adcfc227a
 SHA512:
-  metadata.gz: a88822ba8bd2eeab47286b16a9fb78aa3b0e6fdc0c99052f864e4f2ae9bd2d1c55a29066273aa8b4d2b8aac598de04cac5a0dd871a18b13bba7cb2271562e4de
-  data.tar.gz: 2f52002a03364a07944ff01a903c4da38d9859362179e043acbb7701ab03beae1eb03a800b9bc034518b732029889e86c4603a1b85c1190d5eb5755d0489c9e9
+  metadata.gz: 6557449b11d4872505295d57268867e5f4cdcb2b6aa6e13be6ac28b3ad2bf97c20cc51bb39a076425ebc0f004ef70d4d26d57b9a738e389e9d070efe6547f1cc
+  data.tar.gz: 977e03371cbdeddb0307091430f425b039be3a52705353b27a0ad0bf272e13211d10fdd246ef576c7c56d5338551e2e3810c52608a29d2a829c78f29f2841df9

data/common/CONTRIBUTING.md

@@ -691,21 +691,6 @@ Optional keys:
 * `ignore_pattern` - A (case insensitive) regex pattern that will cause files matching it to not be served to the student by `exercism fetch`. The default value used if this key is not present is `example`
 * `solution_pattern` - A (case sensitive) regex pattern that matches solution files in the track repository. Used by [configlet](https://github.com/exercism/configlet) to check for the presence of an example solution for each problem implemented by the track.  The default value used if this key is not present is `[Ee]xample`.
 
-### Track-Level Linting With Configlet
-
-If the `config.json` file is incomplete or broken, a lot of other things break.
-To make things easier we made a small tool to help verify the config:
-https://github.com/exercism/configlet#configlet
-
-You can download the latest release from the releases page in the [configlet
-repo](https://github.com/exercism/configlet/releases), or you can use the
-`bin/fetch-configlet` command from the root of the language track repository,
-which will make a guess at what operating system and architecture you have and
-attempt to download the right one.
-
-Verify the config by calling `bin/configlet .` (notice the dot). This says
-_check the config of the language track that is stored right here).
-
 ### Git Basics
 
 If you're concerned that you haven't done it right, don't worry. Submit your pull request, and we'll help you get the details sorted out.

data/common/exercises/secret-handshake/canonical-data.json

@@ -1,6 +1,19 @@
 {
   "exercise": "secret-handshake",
-  "version": "1.0.0",
+  "version": "1.1.0",
+  "comments": [
+    " In a discussion in https://github.com/exercism/x-common/pull/794 and    ",
+    " https://github.com/exercism/x-common/issues/335 it has been decided to  ",
+    " only include numbers between 0 and 31 (00000 to 11111) in the canonical ",
+    " test data.                                                              ",
+    "                                                                         ",
+    " This is to allow for different implementations in different tracks and  ",
+    " not restrict solutions to bitwise or modulo-based algorithms.           ",
+    "                                                                         ",
+    " Tracks may include additional tests for numbers > 31 in their test      ",
+    " suites. In this case, 32 (100000) should yield the same result as 0,    ",
+    " 33 (100001) should yield the same result as 1, and so on.               "
+  ],
   "cases": [
     {
       "description": "Create a handshake for a number",
@@ -70,12 +83,6 @@
           "property": "commands",
           "input": 0,
           "expected": []
-        },
-        {
-          "description": "do nothing if lower 5 bits not set",
-          "property": "commands",
-          "input": 32,
-          "expected": []
         }
       ]
     }

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.1.0.26"
+  VERSION = "2.1.0.27"
 end

data/tracks/dlang/config.json

@@ -12,6 +12,13 @@
         "language basics"
       ]
     },
+    {
+      "slug": "leap",
+      "difficulty": 1,
+      "topics": [
+        "language basics"
+      ]
+    },
     {
       "slug": "gigasecond" ,
       "difficulty": 1,
@@ -139,6 +146,17 @@
         "string manipulation",
         "control-flow"
       ]
+    },
+    {
+      "slug": "react" ,
+      "difficulty": 10,
+      "topics": [
+        "reactive programming",
+        "generics",
+        "nested classes",
+        "higher-order functions",
+        "delegates"
+      ]
     }
   ],
   "deprecated": [

data/tracks/dlang/exercises/leap/leap.d

@@ -0,0 +1,8 @@
+unittest {
+  assert(!is_leap(2015));
+  assert(is_leap(2016));
+  assert(!is_leap(2100));
+  assert(is_leap(2000));
+}
+
+void main() {}

data/tracks/dlang/exercises/leap/leap_example.d

@@ -0,0 +1,15 @@
+bool is_leap(uint year) {
+  bool div_by(uint n) {
+    return year % n == 0;
+  }
+  return div_by(4) && (!div_by(100) || div_by(400));
+}
+
+unittest {
+  assert(!is_leap(2015));
+  assert(is_leap(2016));
+  assert(!is_leap(2100));
+  assert(is_leap(2000));
+}
+
+void main() {}

data/tracks/dlang/exercises/react/react.d

@@ -0,0 +1,211 @@
+module react;
+
+unittest {
+const int allTestsEnabled = 0;
+
+  {
+    // input cells have a value
+    Reactor!(int) r;
+    auto input = r.new InputCell(10);
+
+    assert(input.value == 10);
+  }
+static if (allTestsEnabled) {
+  {
+    // an input cell's value can be set
+    Reactor!(int) r;
+    auto input = r.new InputCell(4);
+
+    input.value = 20;
+    assert(input.value == 20);
+  }
+  {
+    // compute cells calculate initial value
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+
+    assert(output.value == 2);
+  }
+  {
+    // compute cells take inputs in the right order
+    Reactor!(int) r;
+    auto one = r.new InputCell(1);
+    auto two = r.new InputCell(2);
+    auto output = r.new ComputeCell(one, two, (x, y) => x + y * 10);
+
+    assert(output.value == 21);
+  }
+  {
+    // compute cells update value when dependencies are changed
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+
+    input.value = 3;
+    assert(output.value == 4);
+  }
+  {
+    // compute cells can depend on other compute cells
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto timesTwo = r.new ComputeCell(input, (x) => x * 2);
+    auto timesThirty = r.new ComputeCell(input, (x) => x * 30);
+    auto output = r.new ComputeCell(timesTwo, timesThirty, (x, y) => x + y);
+
+    assert(output.value == 32);
+    input.value = 3;
+    assert(output.value == 96);
+  }
+  {
+    // compute cells fire callbacks
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+    int[] vals;
+
+    output.addCallback((int x) { vals ~= [x]; return; });
+
+    input.value = 3;
+    assert(vals.length == 1);
+    assert(vals[0] == 4);
+  }
+  {
+    // compute cells only fire on change
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x < 3 ? 111 : 222);
+    int[] vals;
+
+    output.addCallback((int x) { vals ~= [x]; return; });
+
+    input.value = 2;
+    assert(vals.length == 0);
+    input.value = 3;
+    assert(vals.length == 1);
+    assert(vals[0] == 222);
+  }
+  {
+    // callbacks can be added and removed
+    Reactor!(int) r;
+    auto input = r.new InputCell(11);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+    int[] vals1;
+    int[] vals2;
+    int[] vals3;
+
+    void delegate() cancel1 = output.addCallback((int x) { vals1 ~= [x]; return; });
+    output.addCallback((int x) { vals2 ~= [x]; return; });
+
+    input.value = 31;
+
+    cancel1();
+    output.addCallback((int x) { vals3 ~= [x]; return; });
+
+    input.value = 41;
+
+    assert(vals1.length == 1);
+    assert(vals1[0] == 32);
+    assert(vals2.length == 2);
+    assert(vals2[0] == 32);
+    assert(vals2[1] == 42);
+    assert(vals3.length == 1);
+    assert(vals3[0] == 42);
+  }
+  {
+    // removing a callback multiple times doesn't interfere with other callbacks
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+    int[] vals1;
+    int[] vals2;
+
+    void delegate() cancel1 = output.addCallback((int x) { vals1 ~= [x]; return; });
+    output.addCallback((int x) { vals2 ~= [x]; return; });
+
+    foreach (i; 0 .. 10) {
+      cancel1();
+    }
+
+    input.value = 2;
+
+    assert(vals1.length == 0);
+    assert(vals2.length == 1);
+    assert(vals2[0] == 3);
+  }
+  {
+    // callbacks should only be called once even if multiple dependencies change
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto plusOne = r.new ComputeCell(input, (x) => x + 1);
+    auto minusOne1 = r.new ComputeCell(input, (x) => x - 1);
+    auto minusOne2 = r.new ComputeCell(minusOne1, (x) => x - 1);
+    auto output = r.new ComputeCell(plusOne, minusOne2, (x, y) => x * y);
+    int[] vals;
+
+    output.addCallback((int x) { vals ~= [x]; return; });
+
+    input.value = 4;
+
+    assert(vals.length == 1);
+    assert(vals[0] == 10);
+  }
+  {
+    // callbacks should not be called if dependencies change but output value doesn't change
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto plusOne = r.new ComputeCell(input, (x) => x + 1);
+    auto minusOne = r.new ComputeCell(input, (x) => x - 1);
+    auto alwaysTwo = r.new ComputeCell(plusOne, minusOne, (x, y) => x - y);
+    int[] vals;
+
+    alwaysTwo.addCallback((int x) { vals ~= [x]; return; });
+
+    foreach (i; 0 .. 10) {
+      input.value = i;
+    }
+
+    assert(vals.length == 0);
+  }
+  {
+    // This is a digital logic circuit called an adder:
+    // https://en.wikipedia.org/wiki/Adder_(electronics)
+    Reactor!(bool) r;
+    auto a = r.new InputCell(false);
+    auto b = r.new InputCell(false);
+    auto carryIn = r.new InputCell(false);
+
+    auto aXorB = r.new ComputeCell(a, b, (x, y) => x != y);
+    auto sum = r.new ComputeCell(aXorB, carryIn, (x, y) => x != y);
+
+    auto aXorBAndCin = r.new ComputeCell(aXorB, carryIn, (x, y) => x && y);
+    auto aAndB = r.new ComputeCell(a, b, (x, y) => x && y);
+    auto carryOut = r.new ComputeCell(aXorBAndCin, aAndB, (x, y) => x || y);
+
+    bool[5][] tests = [
+      //            inputs,     expected
+      //   a,     b,   cin,  cout,   sum
+      [false, false, false, false, false],
+      [false, false,  true, false,  true],
+      [false,  true, false, false,  true],
+      [false,  true,  true,  true, false],
+      [ true, false, false, false,  true],
+      [ true, false,  true,  true, false],
+      [ true,  true, false,  true, false],
+      [ true,  true,  true,  true,  true],
+    ];
+
+    foreach (test; tests) {
+      a.value = test[0];
+      b.value = test[1];
+      carryIn.value = test[2];
+
+      assert(carryOut.value == test[3]);
+      assert(sum.value == test[4]);
+    }
+  }
+}
+
+}
+
+void main() {}

data/tracks/dlang/exercises/react/react_example.d

@@ -0,0 +1,291 @@
+module react;
+
+class Reactor(T) {
+  class Cell {
+    @property T value() { return m_value; }
+    private:
+    ComputeCell[] dependents;
+    T m_value;
+  }
+
+  class InputCell: Cell {
+    // If this override getter is not present,
+    // then value becomes write-only.
+    override @property T value() { return super.value; }
+    @property T value(T newValue) {
+      m_value = newValue;
+      foreach (dep; dependents) {
+        dep.propagate();
+      }
+      foreach (dep; dependents) {
+        dep.fireCallbacks();
+      }
+      return newValue;
+    }
+
+    this(T initialValue) {
+      m_value = initialValue;
+    }
+  }
+
+  class ComputeCell: Cell {
+    this(Cell c, T function(T) f) {
+      c.dependents ~= [this];
+      this(() => f(c.value));
+    }
+
+    this(Cell c1, Cell c2, T function(T, T) f) {
+      c1.dependents ~= [this];
+      c2.dependents ~= [this];
+      this(() => f(c1.value, c2.value));
+    }
+
+    void delegate() addCallback(void delegate(T) cb) {
+      int id = callbacksIssued++;
+      callbacks[id] = cb;
+      return () { callbacks.remove(id); };
+    }
+
+    private:
+
+    T delegate() compute;
+    T lastCallbackValue;
+    void delegate(T)[int] callbacks;
+    int callbacksIssued = 0;
+
+    this(T delegate() f) {
+      compute = f;
+      m_value = compute();
+      lastCallbackValue = m_value;
+    }
+
+    void propagate() {
+      T newValue = compute();
+      if (value == newValue) {
+        return;
+      }
+      m_value = newValue;
+      foreach (dep; dependents) {
+        dep.propagate();
+      }
+    }
+
+    void fireCallbacks() {
+      if (value == lastCallbackValue) {
+        return;
+      }
+      lastCallbackValue = value;
+      foreach (cb; callbacks) {
+        cb(value);
+      }
+      foreach (dep; dependents) {
+        dep.fireCallbacks();
+      }
+    }
+  }
+}
+
+unittest {
+  {
+    // input cells have a value
+    Reactor!(int) r;
+    auto input = r.new InputCell(10);
+
+    assert(input.value == 10);
+  }
+  {
+    // an input cell's value can be set
+    Reactor!(int) r;
+    auto input = r.new InputCell(4);
+
+    input.value = 20;
+    assert(input.value == 20);
+  }
+  {
+    // compute cells calculate initial value
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+
+    assert(output.value == 2);
+  }
+  {
+    // compute cells take inputs in the right order
+    Reactor!(int) r;
+    auto one = r.new InputCell(1);
+    auto two = r.new InputCell(2);
+    auto output = r.new ComputeCell(one, two, (x, y) => x + y * 10);
+
+    assert(output.value == 21);
+  }
+  {
+    // compute cells update value when dependencies are changed
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+
+    input.value = 3;
+    assert(output.value == 4);
+  }
+  {
+    // compute cells can depend on other compute cells
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto timesTwo = r.new ComputeCell(input, (x) => x * 2);
+    auto timesThirty = r.new ComputeCell(input, (x) => x * 30);
+    auto output = r.new ComputeCell(timesTwo, timesThirty, (x, y) => x + y);
+
+    assert(output.value == 32);
+    input.value = 3;
+    assert(output.value == 96);
+  }
+  {
+    // compute cells fire callbacks
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+    int[] vals;
+
+    output.addCallback((int x) { vals ~= [x]; return; });
+
+    input.value = 3;
+    assert(vals.length == 1);
+    assert(vals[0] == 4);
+  }
+  {
+    // compute cells only fire on change
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x < 3 ? 111 : 222);
+    int[] vals;
+
+    output.addCallback((int x) { vals ~= [x]; return; });
+
+    input.value = 2;
+    assert(vals.length == 0);
+    input.value = 3;
+    assert(vals.length == 1);
+    assert(vals[0] == 222);
+  }
+  {
+    // callbacks can be added and removed
+    Reactor!(int) r;
+    auto input = r.new InputCell(11);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+    int[] vals1;
+    int[] vals2;
+    int[] vals3;
+
+    void delegate() cancel1 = output.addCallback((int x) { vals1 ~= [x]; return; });
+    output.addCallback((int x) { vals2 ~= [x]; return; });
+
+    input.value = 31;
+
+    cancel1();
+    output.addCallback((int x) { vals3 ~= [x]; return; });
+
+    input.value = 41;
+
+    assert(vals1.length == 1);
+    assert(vals1[0] == 32);
+    assert(vals2.length == 2);
+    assert(vals2[0] == 32);
+    assert(vals2[1] == 42);
+    assert(vals3.length == 1);
+    assert(vals3[0] == 42);
+  }
+  {
+    // removing a callback multiple times doesn't interfere with other callbacks
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto output = r.new ComputeCell(input, (x) => x + 1);
+    int[] vals1;
+    int[] vals2;
+
+    void delegate() cancel1 = output.addCallback((int x) { vals1 ~= [x]; return; });
+    output.addCallback((int x) { vals2 ~= [x]; return; });
+
+    foreach (i; 0 .. 10) {
+      cancel1();
+    }
+
+    input.value = 2;
+
+    assert(vals1.length == 0);
+    assert(vals2.length == 1);
+    assert(vals2[0] == 3);
+  }
+  {
+    // callbacks should only be called once even if multiple dependencies change
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto plusOne = r.new ComputeCell(input, (x) => x + 1);
+    auto minusOne1 = r.new ComputeCell(input, (x) => x - 1);
+    auto minusOne2 = r.new ComputeCell(minusOne1, (x) => x - 1);
+    auto output = r.new ComputeCell(plusOne, minusOne2, (x, y) => x * y);
+    int[] vals;
+
+    output.addCallback((int x) { vals ~= [x]; return; });
+
+    input.value = 4;
+
+    assert(vals.length == 1);
+    assert(vals[0] == 10);
+  }
+  {
+    // callbacks should not be called if dependencies change but output value doesn't change
+    Reactor!(int) r;
+    auto input = r.new InputCell(1);
+    auto plusOne = r.new ComputeCell(input, (x) => x + 1);
+    auto minusOne = r.new ComputeCell(input, (x) => x - 1);
+    auto alwaysTwo = r.new ComputeCell(plusOne, minusOne, (x, y) => x - y);
+    int[] vals;
+
+    alwaysTwo.addCallback((int x) { vals ~= [x]; return; });
+
+    foreach (i; 0 .. 10) {
+      input.value = i;
+    }
+
+    assert(vals.length == 0);
+  }
+  {
+    // This is a digital logic circuit called an adder:
+    // https://en.wikipedia.org/wiki/Adder_(electronics)
+    Reactor!(bool) r;
+    auto a = r.new InputCell(false);
+    auto b = r.new InputCell(false);
+    auto carryIn = r.new InputCell(false);
+
+    auto aXorB = r.new ComputeCell(a, b, (x, y) => x != y);
+    auto sum = r.new ComputeCell(aXorB, carryIn, (x, y) => x != y);
+
+    auto aXorBAndCin = r.new ComputeCell(aXorB, carryIn, (x, y) => x && y);
+    auto aAndB = r.new ComputeCell(a, b, (x, y) => x && y);
+    auto carryOut = r.new ComputeCell(aXorBAndCin, aAndB, (x, y) => x || y);
+
+    bool[5][] tests = [
+      //            inputs,     expected
+      //   a,     b,   cin,  cout,   sum
+      [false, false, false, false, false],
+      [false, false,  true, false,  true],
+      [false,  true, false, false,  true],
+      [false,  true,  true,  true, false],
+      [ true, false, false, false,  true],
+      [ true, false,  true,  true, false],
+      [ true,  true, false,  true, false],
+      [ true,  true,  true,  true,  true],
+    ];
+
+    foreach (test; tests) {
+      a.value = test[0];
+      b.value = test[1];
+      carryIn.value = test[2];
+
+      assert(carryOut.value == test[3]);
+      assert(sum.value == test[4]);
+    }
+  }
+}
+
+void main() {}