trackler 2.2.1.85 → 2.2.1.86

data/tracks/crystal/.github/stale.yml

@@ -0,0 +1,18 @@
+# Number of days of inactivity before an Issue or Pull Request becomes stale
+daysUntilStale: 180
+# Number of days of inactivity before a stale Issue or Pull Request is closed
+daysUntilClose: 7
+# Issues or Pull Requests with these labels will never be considered stale
+exemptLabels:
+  - pinned
+# Label to use when marking as stale
+staleLabel: stale
+# Comment to post when marking as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale Issue or Pull Request. Set to `false` to disable
+closeComment: false
+# Limit to only `issues` or `pulls`
+# only: issues

data/tracks/csharp/exercises/bob/README.md

@@ -6,8 +6,9 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
-He says 'Fine. Be that way!' if you address him without actually saying
-anything.
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
+He says 'Fine. Be that way!' if you address him without actually saying anything.
 
 He answers 'Whatever.' to anything else.
 

data/tracks/ecmascript/config.json

@@ -794,7 +794,7 @@
       ]
     },
     {
-      "uuid": "03889544-064a-a980-2c2a-c7eb7d8407f8f737fb8",
+      "uuid": "a8b7187d-12eb-4efc-b966-87823654ccda",
       "slug": "house",
       "core": false,
       "unlocked_by": "bob",
@@ -1211,7 +1211,7 @@
       ]
     },
     {
-      "uuid": "eec93b8b-0b50-3380-bd75-c53210c48ac5bffc8af",
+      "uuid": "c1abafcc-0d44-4fb5-afae-bff3ce2e1b39",
       "slug": "spiral-matrix",
       "core": false,
       "unlocked_by": "matrix",
@@ -1225,7 +1225,7 @@
       ]
     },
     {
-      "uuid": "a7277814-0582-ce80-6451-7352158be58a36d5c3d",
+      "uuid": "f8c6786e-bf93-4f35-b649-03f4e39bb094",
       "slug": "rectangles",
       "core": false,
       "unlocked_by": "matrix",
@@ -1239,7 +1239,7 @@
       ]
     },
     {
-      "uuid": "28d75cd0-0ab4-ed80-6010-6a0a9b61a3388455777",
+      "uuid": "34625b04-844e-41e3-b02b-3443b6b0b7cb",
       "slug": "rotational-cipher",
       "core": false,
       "unlocked_by": "simple-cipher",

data/tracks/fsharp/exercises/bob/README.md

@@ -6,10 +6,12 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
-He says 'Fine. Be that way!' if you address him without actually saying
-anything.
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
+He says 'Fine. Be that way!' if you address him without actually saying anything.
 
 He answers 'Whatever.' to anything else.
+
 ## Source
 
 Inspired by the 'Deaf Grandma' exercise in Chris Pine's Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=06](http://pine.fm/LearnToProgram/?Chapter=06)

data/tracks/fsharp/exercises/react/ReactTest.fs

@@ -1,98 +1,161 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 module ReactTest
 
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open React
 
 [<Fact>]
-let ``Setting the value of an input cell changes the observable value`` () =
-  let reactor = new Reactor()
-  let inputCell1 = reactor.createInputCell 1
+let ``Input cells have a value`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 10
+    input.Value |> should equal 10
+    
 
-  inputCell1.Value |> should equal 1
-  inputCell1.Value <- 2
-  inputCell1.Value |> should equal 2
+[<Fact(Skip = "Remove to run test")>]
+let ``An input cell's value can be set`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 4
+    input.Value <- 20
+    input.Value |> should equal 20
+    
 
 [<Fact(Skip = "Remove to run test")>]
-let ``The value of a compute is determined by the value of the dependencies`` () =
-  let reactor = new Reactor()
-  let inputCell1 = reactor.createInputCell 1    
-  let computeCell1 = reactor.createComputeCell [inputCell1] (fun values -> values.[0] + 1)
+let ``Compute cells calculate initial value`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 1
+    let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
+    output.Value |> should equal 2
+    
 
-  computeCell1.Value |> should equal 2  
-  inputCell1.Value <- 2
-  computeCell1.Value |> should equal 3
+[<Fact(Skip = "Remove to run test")>]
+let ``Compute cells take inputs in the right order`` () =
+    let reactor = new Reactor()
+    let one = reactor.createInputCell 1
+    let two = reactor.createInputCell 2
+    let output = reactor.createComputeCell [one; two] (fun values -> values.[0] + values.[1] * 10)
+    output.Value |> should equal 21
+    
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Compute cells update value when dependencies are changed`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 1
+    let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
+    input.Value <- 3
+    output.Value |> should equal 4
+    
 
 [<Fact(Skip = "Remove to run test")>]
 let ``Compute cells can depend on other compute cells`` () =
-  let reactor = new Reactor()
-  let inputCell1 = reactor.createInputCell 1
-  let computeCell1 = reactor.createComputeCell [inputCell1] (fun values -> values.[0] + 1)
-  let computeCell2 = reactor.createComputeCell [inputCell1] (fun values -> values.[0] - 1)
-  let computeCell3 = reactor.createComputeCell [computeCell1; computeCell2] (fun values -> values.[0] * values.[1])
-  
-  computeCell3.Value |> should equal 0  
-  inputCell1.Value <- 3
-  computeCell3.Value |> should equal 8
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 1
+    let times_two = reactor.createComputeCell [input] (fun values -> values.[0] * 2)
+    let times_thirty = reactor.createComputeCell [input] (fun values -> values.[0] * 30)
+    let output = reactor.createComputeCell [times_two; times_thirty] (fun values -> values.[0] + values.[1])
+    output.Value |> should equal 32
+    input.Value <- 3
+    output.Value |> should equal 96
+    
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Compute cells can have callbacks`` () =
-  let reactor = new Reactor()
-  let inputCell1 = reactor.createInputCell 1
-  let computeCell1 = reactor.createComputeCell [inputCell1] (fun values -> values.[0] + 1)
-  let mutable observed = []
-  computeCell1.Changed.Add(fun value -> observed <- observed @ [value]) |> ignore
-  
-  observed |> should be Empty
-  inputCell1.Value <- 2
-  observed |> should equal [3]
+let ``Compute cells fire callbacks`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 1
+    let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
+    let mutable callback1 = []
+    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    output.Changed.AddHandler callback1Handler
+    input.Value <- 3
+    callback1 |> should equal [4]
+    
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Callbacks only trigger on change`` () =
-  let reactor = new Reactor()
-  let inputCell1 = reactor.createInputCell 1
-  let computecell1 = reactor.createComputeCell [inputCell1] (fun values -> if values.[0] > 2 then values.[0] + 1 else 2)
-  let mutable observerCalled = 0
-  computecell1.Changed.Add(fun value -> observerCalled <- observerCalled + 1) |> ignore
-
-  inputCell1.Value <- 1
-  observerCalled |> should equal 0
-  inputCell1.Value <- 2
-  observerCalled |> should equal 0
-  inputCell1.Value <- 3
-  observerCalled |> should equal 1
+let ``Callback cells only fire on change`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 1
+    let output = reactor.createComputeCell [input] (fun values -> if values.[0] < 3 then 111 else 222)
+    let mutable callback1 = []
+    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    output.Changed.AddHandler callback1Handler
+    input.Value <- 2
+    callback1 |> should equal List.empty<int>
+    input.Value <- 4
+    callback1 |> should equal [222]
+    
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Callbacks can be removed`` () =
-  let reactor = new Reactor()
-  let inputCell1 = reactor.createInputCell 1
-  let computeCell1 = reactor.createComputeCell [inputCell1] (fun values -> values.[0] + 1)
-  let mutable observed1 = []
-  let mutable observed2 = []
-
-  let changedHandler1 = Handler<int>(fun _ value -> observed1 <- observed1 @ [value])
-  computeCell1.Changed.AddHandler changedHandler1
-  computeCell1.Changed.Add(fun value -> observed2 <- observed2 @ [value]) |> ignore
+let ``Callbacks can be added and removed`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 11
+    let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
+    let mutable callback1 = []
+    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    output.Changed.AddHandler callback1Handler
+    let mutable callback2 = []
+    let callback2Handler = Handler<int>(fun _ value -> callback2 <- callback2 @ [value])
+    output.Changed.AddHandler callback2Handler
+    input.Value <- 31
+    output.Changed.RemoveHandler callback1Handler
+    let mutable callback3 = []
+    let callback3Handler = Handler<int>(fun _ value -> callback3 <- callback3 @ [value])
+    output.Changed.AddHandler callback3Handler
+    input.Value <- 41
+    callback1 |> should equal [32]
+    callback2 |> should equal [32; 42]
+    callback3 |> should equal [42]
     
-  inputCell1.Value <- 2
-  observed1 |> should equal [3]  
-  observed2 |> should equal [3]
 
-  computeCell1.Changed.RemoveHandler changedHandler1
-  inputCell1.Value <- 3
-  observed1 |> should equal [3]  
-  observed2 |> should equal [3; 4]
+[<Fact(Skip = "Remove to run test")>]
+let ``Removing a callback multiple times doesn't interfere with other callbacks`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 1
+    let output = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
+    let mutable callback1 = []
+    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    output.Changed.AddHandler callback1Handler
+    let mutable callback2 = []
+    let callback2Handler = Handler<int>(fun _ value -> callback2 <- callback2 @ [value])
+    output.Changed.AddHandler callback2Handler
+    output.Changed.RemoveHandler callback1Handler
+    output.Changed.RemoveHandler callback1Handler
+    output.Changed.RemoveHandler callback1Handler
+    input.Value <- 2
+    callback1 |> should equal List.empty<int>
+    callback2 |> should equal [3]
+    
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Callbacks should only be called once even if multiple dependencies have changed`` () =
-  let reactor = new Reactor()
-  let inputCell1 = reactor.createInputCell 1
-  let computeCell1 = reactor.createComputeCell [inputCell1] (fun values -> values.[0] + 1)
-  let computeCell2 = reactor.createComputeCell [inputCell1] (fun values -> values.[0] - 1)
-  let computeCell3 = reactor.createComputeCell [computeCell2] (fun values -> values.[0] - 1)
-  let computeCell4 = reactor.createComputeCell [computeCell1; computeCell3] (fun values -> values.[0] * values.[1])
-  let mutable changed4 = 0
-  computeCell4.Changed.Add(fun value -> changed4 <- changed4 + 1) |> ignore
-  inputCell1.Value <- 3
-  changed4 |> should equal 1  
+let ``Callbacks should only be called once even if multiple dependencies change`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 1
+    let plus_one = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
+    let minus_one1 = reactor.createComputeCell [input] (fun values -> values.[0] - 1)
+    let minus_one2 = reactor.createComputeCell [minus_one1] (fun values -> values.[0] - 1)
+    let output = reactor.createComputeCell [plus_one; minus_one2] (fun values -> values.[0] * values.[1])
+    let mutable callback1 = []
+    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    output.Changed.AddHandler callback1Handler
+    input.Value <- 4
+    callback1 |> should equal [10]
+    
+
+[<Fact(Skip = "Remove to run test")>]
+let ``Callbacks should not be called if dependencies change but output value doesn't change`` () =
+    let reactor = new Reactor()
+    let input = reactor.createInputCell 1
+    let plus_one = reactor.createComputeCell [input] (fun values -> values.[0] + 1)
+    let minus_one = reactor.createComputeCell [input] (fun values -> values.[0] - 1)
+    let always_two = reactor.createComputeCell [plus_one; minus_one] (fun values -> values.[0] - values.[1])
+    let mutable callback1 = []
+    let callback1Handler = Handler<int>(fun _ value -> callback1 <- callback1 @ [value])
+    always_two.Changed.AddHandler callback1Handler
+    input.Value <- 2
+    input.Value <- 3
+    input.Value <- 4
+    input.Value <- 5
+    callback1 |> should equal List.empty<int>
+    
+

data/tracks/fsharp/generators/Generators.fs

@@ -656,6 +656,82 @@ type RailFenceCipher() =
 type Raindrops() =
     inherit GeneratorExercise()
 
+type React() = 
+    inherit GeneratorExercise()
+
+    override __.PropertiesWithIdentifier _ = []
+
+    member private __.RenderCells canonicalDataCase = 
+        let reactorVar = sprintf "let %s = new %s()" "reactor" "Reactor"
+        let cellVars = 
+            canonicalDataCase.Properties.["cells"] :?> JArray
+            |> Seq.map (fun (cellValue: JToken) -> 
+                let cell = cellValue :?> JObject
+                let cellName = cell.["name"].ToObject<string>()
+                match cell.["type"].ToObject<string>() with
+                | "compute" ->
+                    let funBody = 
+                        cell.["compute_function"].ToObject<string>().Replace ("inputs", "values.")
+                    let inputParams = 
+                        (cell.["inputs"].ToObject<seq<string>>() |> formatList)
+                    
+                    sprintf "let %s = reactor.createComputeCell %s (fun values -> %s)" cellName inputParams funBody
+                | "input" -> 
+                    let initialValue = cell.["initial_value"].ToObject<int64>()
+                    sprintf "let %s = reactor.createInputCell %s" cellName (formatValue initialValue)
+                | _ -> ""
+            )
+            |> Seq.toList
+        [ reactorVar ] @ cellVars
+     
+    member private __.RenderOperations canonicalDataCase = 
+        canonicalDataCase.Properties.["operations"] :?> JArray
+        // we can generate more than 1 line per operation
+        // so we need to flatten results here
+        // collect does it automatically for us 
+        // and every operation should emit seq<string>
+        |> Seq.collect (fun (opToken: JToken) -> 
+            let op = opToken :?> JObject
+            match op.["type"].ToObject<string>() with
+            | "expect_cell_value" -> seq { 
+                let cellName = op.["cell"].ToObject<string>()
+                let expectedValue = op.["value"].ToObject<int>()
+                yield sprintf "%s.Value |> should equal %i" cellName expectedValue }
+            | "set_value" -> seq { 
+                let cellName = op.["cell"].ToObject<string>()
+                let cellValue = op.["value"].ToObject<int>()
+                yield sprintf "%s.Value <- %i" cellName cellValue }
+            | "add_callback" -> seq { 
+                let callbackName = op.["name"].ToObject<string>()
+                let cellName = op.["cell"].ToObject<string>() 
+                yield sprintf "let mutable %s = []" callbackName 
+                yield sprintf "let %sHandler = Handler<int>(fun _ value -> %s <- %s @ [value])" callbackName callbackName callbackName
+                yield sprintf "%s.Changed.AddHandler %sHandler" cellName callbackName }
+            | "expect_callback_values" -> seq {
+                let callbackName = op.["callback"].ToObject<string>()
+                let callbackValues = op.["values"].ToObject<string[]>()
+                if callbackValues.Length = 0 then
+                    yield sprintf "%s |> should equal List.empty<int>" callbackName
+                else
+                    yield sprintf "%s |> should equal %s" callbackName (formatList callbackValues) }
+            | "remove_callback" -> seq {
+                let cellName = op.["cell"].ToObject<string>()
+                let callbackName = op.["name"].ToObject<string>()
+                yield sprintf "%s.Changed.RemoveHandler %sHandler" cellName callbackName }
+            | _ -> seq { yield "" }
+        )
+        |> Seq.toList
+
+    override __.RenderAssert _ = 
+        // skip this method 
+        // because for this task we have multiple assert statements
+        ""
+
+    override this.RenderArrange canonicalDataCase =
+        let initialVars = this.RenderCells canonicalDataCase
+        let operations = this.RenderOperations canonicalDataCase
+        initialVars @ operations
+
 type Rectangles() = 
     inherit GeneratorExercise()
 

data/tracks/go/exercises/tree-building/tree_test.go

@@ -158,6 +158,21 @@ var failureTestCases = []struct {
 			{ID: 1, Parent: 0},
 		},
 	},
+	{
+		name: "duplicate node",
+		input: []Record{
+			{ID: 0, Parent: 0},
+			{ID: 1, Parent: 0},
+			{ID: 1, Parent: 0},
+		},
+	},
+	{
+		name: "duplicate root",
+		input: []Record{
+			{ID: 0, Parent: 0},
+			{ID: 0, Parent: 0},
+		},
+	},
 	{
 		name: "non-continuous",
 		input: []Record{

data/tracks/haskell/.travis.yml

@@ -12,7 +12,7 @@ cache:
     - $HOME/.foldercache # Per exercise `.stack-work` cache.
 
 env:
- - RESOLVER="lts-9.11" CURRENT="YES" # Equal to each stack.yaml.
+ - RESOLVER="lts-10.2" CURRENT="YES" # Equal to each stack.yaml.
  - RESOLVER="nightly"                # Latest nightly snapshot.
 
 matrix:

data/tracks/haskell/exercises/accumulate/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/acronym/package.yaml

@@ -1,5 +1,5 @@
 name: acronym
-version: 1.1.0.3
+version: 1.2.0.4
 
 dependencies:
   - base