trackler 2.2.1.47 → 2.2.1.48

data/tracks/lua/exercises/react/example.lua

@@ -0,0 +1,108 @@
+local function InputCell(value)
+  local children = {}
+
+  return {
+    get_value = function()
+      return value
+    end,
+
+    set_value = function(new_value)
+      value = new_value
+      for _, child in ipairs(children) do
+        child._propagate()
+      end
+      for _, child in ipairs(children) do
+        child._update()
+      end
+    end,
+
+    _add_child = function(child)
+      table.insert(children, child)
+    end
+  }
+end
+
+local function ComputeCell(...)
+  local callbacks = {}
+  local children = {}
+  local value
+  local previous_value
+  local cell = {}
+
+  local inputs, f do
+    local args = table.pack(...)
+    if args.n == 3 then
+      inputs = { args[1], args[2] }
+      f = args[3]
+    else
+      inputs = { args[1] }
+      f = args[2]
+    end
+  end
+
+  local function calculate_value()
+    local args = {}
+    for _, input in ipairs(inputs) do
+      table.insert(args, input.get_value())
+    end
+    return f(table.unpack(args))
+  end
+
+  function cell.get_value()
+    return value
+  end
+
+  function cell.watch(callback)
+    table.insert(callbacks, callback)
+  end
+
+  function cell.unwatch(callback)
+    for i, _callback in ipairs(callbacks) do
+      if callback == _callback then
+        table.remove(callbacks, i)
+        return
+      end
+    end
+  end
+
+  function cell._propagate()
+    value = calculate_value()
+    for _, child in ipairs(children) do
+      child._propagate()
+    end
+  end
+
+  function cell._update()
+    if previous_value ~= value then
+      previous_value = value
+      for _, callback in ipairs(callbacks) do
+        callback(value)
+      end
+    end
+    for _, child in ipairs(children) do
+      child._update()
+    end
+  end
+
+  function cell._add_child(child)
+    table.insert(children, child)
+  end
+
+  value = calculate_value()
+  previous_value = value
+
+  for _, input in ipairs(inputs) do
+    input._add_child(cell)
+  end
+
+  return cell
+end
+
+local function Reactor()
+  return {
+    InputCell = InputCell,
+    ComputeCell = ComputeCell
+  }
+end
+
+return { Reactor = Reactor }

data/tracks/lua/exercises/react/react_spec.lua

@@ -0,0 +1,160 @@
+local react = require 'react'
+
+describe('react', function()
+  it('input cells have a value', function()
+    local r = react.Reactor()
+    local input = r.InputCell(2)
+
+    assert.are.equal(2, input.get_value())
+  end)
+
+  it("an input cell's value can be set", function()
+    local r = react.Reactor()
+    local input = r.InputCell(4)
+
+    input.set_value(20)
+    assert.are.equal(20, input.get_value())
+  end)
+
+  it('compute cells calculate initial value', function()
+    local r = react.Reactor()
+    local input = r.InputCell(1)
+    local output = r.ComputeCell(input, function(x) return x + 1 end)
+
+    assert.are.equal(2, output.get_value())
+  end)
+
+  it('compute cells take inputs in the right order', function()
+    local r = react.Reactor()
+    local one = r.InputCell(1)
+    local two = r.InputCell(2)
+    local output = r.ComputeCell(one, two, function(x, y) return x + y * 10 end)
+
+    assert.are.equal(21, output.get_value())
+  end)
+
+  it('compute cells update value when dependencies are changed', function()
+    local r = react.Reactor()
+    local input = r.InputCell(1)
+    local output = r.ComputeCell(input, function(x) return x + 1 end)
+
+    input.set_value(3)
+    assert.are.equal(4, output.get_value())
+  end)
+
+  it('compute cells can depend on other compute cells', function()
+    local r = react.Reactor()
+    local input = r.InputCell(1)
+    local times_two = r.ComputeCell(input, function(x) return x * 2 end)
+    local times_thirty = r.ComputeCell(input, function(x) return x * 30 end)
+    local output = r.ComputeCell(times_two, times_thirty, function(x, y) return x + y end)
+
+    assert.are.equal(32, output.get_value())
+
+    input.set_value(3)
+    assert.are.equal(96, output.get_value())
+  end)
+
+  it('compute cells fire callbacks', function()
+    local r = react.Reactor()
+    local input = r.InputCell(1)
+    local output = r.ComputeCell(input, function(x) return x + 1 end)
+    local callback = spy.new(function() end)
+
+    output.watch(callback)
+    input.set_value(3)
+    assert.spy(callback).was_called(1)
+    assert.spy(callback).was_called_with(4)
+  end)
+
+  it('callbacks only fire on change', function()
+    local r = react.Reactor()
+    local input = r.InputCell(1)
+    local output = r.ComputeCell(input, function(x)
+      if x < 3 then
+        return 111
+      else
+        return 222
+      end
+    end)
+    local callback = spy.new(function() end)
+
+    output.watch(callback)
+
+    input.set_value(2)
+    assert.spy(callback).was_called(0)
+
+    input.set_value(4)
+    assert.spy(callback).was_called(1)
+    assert.spy(callback).was_called_with(222)
+  end)
+
+  it('callbacks can be added and removed', function()
+    local r = react.Reactor()
+    local input = r.InputCell(11)
+    local output = r.ComputeCell(input, function(x) return x + 1 end)
+    local callback1 = spy.new(function() end)
+    local callback2 = spy.new(function() end)
+    local callback3 = spy.new(function() end)
+
+    output.watch(callback1)
+    output.watch(callback2)
+    input.set_value(31)
+
+    output.unwatch(callback1)
+    output.watch(callback3)
+    input.set_value(41)
+
+    assert.spy(callback1).was_called(1)
+    assert.spy(callback1).was_called_with(32)
+    assert.spy(callback2).was_called(2)
+    assert.spy(callback2).was_called_with(42)
+    assert.spy(callback3).was_called(1)
+    assert.spy(callback3).was_called_with(42)
+  end)
+
+  it("removing a callback multiple times doesn't interfere with other callbacks", function()
+    local r = react.Reactor()
+    local input = r.InputCell(1)
+    local output = r.ComputeCell(input, function(x) return x + 1 end)
+    local callback1 = spy.new(function() end)
+    local callback2 = spy.new(function() end)
+
+    output.watch(callback1)
+    output.watch(callback2)
+    for i = 1, 10 do output.unwatch(callback1) end
+    input.set_value(2)
+
+    assert.spy(callback1).was_called(0)
+    assert.spy(callback2).was_called(1)
+    assert.spy(callback2).was_called_with(3)
+  end)
+
+  it('callbacks only called once even if multiple inputs change', function()
+    local r = react.Reactor()
+    local input = r.InputCell(1)
+    local plus_one = r.ComputeCell(input, function(x) return x + 1 end)
+    local minus_one1 = r.ComputeCell(input, function(x) return x - 1 end)
+    local minus_one2 = r.ComputeCell(minus_one1, function(x) return x - 1 end)
+    local output = r.ComputeCell(plus_one, minus_one2, function(x, y) return x * y end)
+    local callback = spy.new(function() end)
+
+    output.watch(callback)
+    input.set_value(4)
+    assert.spy(callback).was_called(1)
+    assert.spy(callback).was_called_with(10)
+  end)
+
+  it("callbacks not called if inputs change but output doesn't", function()
+    local r = react.Reactor()
+    local input = r.InputCell(1)
+    local plus_one = r.ComputeCell(input, function(x) return x + 1 end)
+    local minus_one = r.ComputeCell(input, function(x) return x - 1 end)
+    local always_two = r.ComputeCell(plus_one, minus_one, function(x, y) return x - y end)
+    local callback = spy.new(function() end)
+
+    always_two.watch(callback)
+    for i = 1, 10 do input.set_value(i) end
+    assert.spy(callback).was_called(0)
+  end)
+end)

data/tracks/lua/exercises/rectangles/README.md

@@ -2,7 +2,7 @@
 
 Count the rectangles in an ASCII diagram like the one below.
 
-```
+```text
    +--+
   ++  |
 +-++--+
@@ -12,7 +12,7 @@ Count the rectangles in an ASCII diagram like the one below.
 
 The above diagram contains 6 rectangles:
 
-```
+```text
 
 
 +-----+
@@ -20,7 +20,7 @@ The above diagram contains 6 rectangles:
 +-----+
 ```
 
-```
+```text
    +--+
    |  |
    |  |
@@ -28,7 +28,7 @@ The above diagram contains 6 rectangles:
    +--+
 ```
 
-```
+```text
    +--+
    |  |
    +--+
@@ -36,7 +36,7 @@ The above diagram contains 6 rectangles:
 
 ```
 
-```
+```text
        
        
    +--+
@@ -44,7 +44,7 @@ The above diagram contains 6 rectangles:
    +--+
 ```
 
-```
+```text
        
        
 +--+
@@ -52,7 +52,7 @@ The above diagram contains 6 rectangles:
 +--+
 ```
 
-```
+```text
        
   ++   
   ++   

data/tracks/lua/exercises/roman-numerals/README.md

@@ -14,7 +14,7 @@ The Romans wrote numbers using letters - I, V, X, L, C, D, M. (notice
 these letters have lots of straight lines and are hence easy to hack
 into stone tablets).
 
-```
+```text
  1  => I
 10  => X
  7  => VII

data/tracks/lua/exercises/run-length-encoding/README.md

@@ -7,20 +7,20 @@ Run-length encoding (RLE) is a simple form of data compression, where runs
 
 For example we can represent the original 53 characters with only 13.
 
-```
+```text
 "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"  ->  "12WB12W3B24WB"
 ```
 
 RLE allows the original data to be perfectly reconstructed from
 the compressed data, which makes it a lossless data compression.
 
-```
+```text
 "AABCCCDEEEE"  ->  "2AB3CD4E"  ->  "AABCCCDEEEE"
 ```
 
 For simplicity, you can assume that the unencoded string will only contain
-the letters A through Z (either lower or upper case) and whitespace. This way 
-data to be encoded will never contain any numbers and numbers inside data to 
+the letters A through Z (either lower or upper case) and whitespace. This way
+data to be encoded will never contain any numbers and numbers inside data to
 be decoded always represent the count for the following character.
 
 ## Running the tests

data/tracks/lua/exercises/scrabble-score/README.md

@@ -6,7 +6,7 @@ Given a word, compute the scrabble score for that word.
 
 You'll need these:
 
-```plain
+```text
 Letter                           Value
 A, E, I, O, U, L, N, R, S, T       1
 D, G                               2
@@ -18,6 +18,7 @@ Q, Z                               10
 ```
 
 ## Examples
+
 "cabbage" should be scored as worth 14 points:
 
 - 3 points for C
@@ -34,6 +35,7 @@ And to total:
 - = 14
 
 ## Extensions
+
 - You can play a double or a triple letter.
 - You can play a double or a triple word.
 

data/tracks/lua/exercises/secret-handshake/README.md

@@ -6,7 +6,7 @@
 You and your fellow cohort of those in the "know" when it comes to
 binary decide to come up with a secret "handshake".
 
-```
+```text
 1 = wink
 10 = double blink
 100 = close your eyes

data/tracks/lua/exercises/space-age/README.md

@@ -12,7 +12,8 @@ Given an age in seconds, calculate how old someone would be on:
    - Neptune: orbital period 164.79132 Earth years
 
 So if you were told someone were 1,000,000,000 seconds old, you should
-be able to say that they're 31 Earth-years old.
+be able to say that they're 31.69 Earth-years old. Round all ages to
+the nearest hundredth of a year.
 
 If you're wondering why Pluto didn't make the cut, go watch [this
 youtube video](http://www.youtube.com/watch?v=Z_2gbGXzFbs).

data/tracks/lua/exercises/sum-of-multiples/README.md

@@ -8,9 +8,6 @@ multiples of either 3 or 5, we get 3, 5, 6 and 9, 10, 12, 15, and 18.
 
 The sum of these multiples is 78.
 
-Given a number, find the sum of the multiples of a given set of numbers,
-up to but not including that number.
-
 ## Running the tests
 
 To run the tests, run the command `busted .` from within the exercise directory.

data/tracks/lua/exercises/tournament/README.md

@@ -5,7 +5,7 @@ Tally the results of a small football competition.
 Based on an input file containing which team played against which and what the
 outcome was, create a file with a table like this:
 
-```
+```text
 Team                           | MP |  W |  D |  L |  P
 Devastating Donkeys            |  3 |  2 |  1 |  0 |  7
 Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6
@@ -31,7 +31,7 @@ Input
 
 Your tallying program will receive input that looks like:
 
-```
+```text
 Allegoric Alaskans;Blithering Badgers;win
 Devastating Donkeys;Courageous Californians;draw
 Devastating Donkeys;Allegoric Alaskans;win
@@ -42,7 +42,7 @@ Allegoric Alaskans;Courageous Californians;win
 
 The result of the match refers to the first team listed. So this line
 
-```
+```text
 Allegoric Alaskans;Blithering Badgers;win
 ```
 
@@ -50,7 +50,7 @@ Means that the Allegoric Alaskans beat the Blithering Badgers.
 
 This line:
 
-```
+```text
 Courageous Californians;Blithering Badgers;loss
 ```
 
@@ -58,7 +58,7 @@ Means that the Blithering Badgers beat the Courageous Californians.
 
 And this line:
 
-```
+```text
 Devastating Donkeys;Courageous Californians;draw
 ```