trackler 2.0.6.35 → 2.0.6.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b60180d66cb803d7af0b313725e9f050d9dc61b0
-  data.tar.gz: cba72b210897ddba5ce87dc79ca7541e9615ab43
+  metadata.gz: 8b98826af252625c0ee25312e8d6e7d0559d62ce
+  data.tar.gz: 1033d0f0d124ed5a5b5be7be0f905294a10fafe9
 SHA512:
-  metadata.gz: cdaf21409803ea63c534daeca46434a8463f75b65a8e4a3908b924598786f69e90e4c7335b344ba48a60098215eac3c11ec510820e3f36081e1c9baddd23a8b7
-  data.tar.gz: a0b9a0e0ce5411a07b0a5e3221fcebe7da097c20cb83843fb3252d4c9d72f6a44d8861c7925eaf88738fcaff3011cf7e0141c82c38d7a7b2d0b5e45b1cc96bcd
+  metadata.gz: 1cc546d150c52d181ebd3a13e20fcbe0ed2b01c9477d21f43fbd0686af787feead08794076a42f63cb3fb4dcffc8cc0075f83a71a577d64234c3667f7324629d
+  data.tar.gz: 97481fdacba33c88b1910c287ee081abe040e546aa1bf3dee676b8449f9d1e5345ad057c89eba5428ccfd04c923d8a2e9ea35e41cde95cba7b7ce82bf14f7f9b

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.35"
+  VERSION = "2.0.6.36"
 end

data/tracks/fsharp/exercises/acronym/AcronymTest.fs

@@ -6,12 +6,59 @@ open Acronym
 [<Test>]
 let ``Empty string abbreviated to empty string`` () =
     Assert.That(acronym "", Is.EqualTo(""))
-        
-[<TestCase("Portable Network Graphics", ExpectedResult = "PNG", Ignore = "Remove to run test case")>]
-[<TestCase("Ruby on Rails", ExpectedResult = "ROR", Ignore = "Remove to run test case")>]
-[<TestCase("HyperText Markup Language", ExpectedResult = "HTML", Ignore = "Remove to run test case")>]
-[<TestCase("First In, First Out", ExpectedResult = "FIFO", Ignore = "Remove to run test case")>]
-[<TestCase("PHP: Hypertext Preprocessor", ExpectedResult = "PHP", Ignore = "Remove to run test case")>]
-[<TestCase("Complementary metal-oxide semiconductor", ExpectedResult = "CMOS", Ignore = "Remove to run test case")>]
-let ``Phrase abbreviated to acronym`` (phrase: string) =
-    acronym phrase
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Basic`` () =
+    let phrase = "Portable Network Graphics"
+    let expected = "PNG"
+    let actual = acronym phrase
+    Assert.That(expected, Is.EqualTo(actual))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Lowercase words`` () =
+    let phrase = "Ruby on Rails"
+    let expected = "ROR"
+    let actual = acronym phrase
+    Assert.That(expected, Is.EqualTo(actual))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Camel case`` () =
+    let phrase = "HyperText Markup Language"
+    let expected = "HTML"
+    let actual = acronym phrase
+    Assert.That(expected, Is.EqualTo(actual))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Punctuation`` () =
+    let phrase = "First In, First Out"
+    let expected = "FIFO"
+    let actual = acronym phrase
+    Assert.That(expected, Is.EqualTo(actual))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``All-Caps words`` () =
+    let phrase = "PHP: Hypertext Preprocessor"
+    let expected = "PHP"
+    let actual = acronym phrase
+    Assert.That(expected, Is.EqualTo(actual))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Non-acronym all-caps word`` () =
+    let phrase = "GNU Image Manipulation Program"
+    let expected = "GIMP"
+    let actual = acronym phrase
+    Assert.That(expected, Is.EqualTo(actual))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Hyphenated`` () =
+    let phrase = "Complementary metal-oxide semiconductor"
+    let expected = "CMOS"
+    let actual = acronym phrase
+    Assert.That(expected, Is.EqualTo(actual))

data/tracks/fsharp/exercises/atbash-cipher/AtbashTest.fs

@@ -3,12 +3,65 @@ module AtbashTest
 open NUnit.Framework
 open Atbash
 
-[<TestCase("no", ExpectedResult = "ml")>]
-[<TestCase("yes", ExpectedResult = "bvh", Ignore = "Remove to run test case")>]
-[<TestCase("OMG", ExpectedResult = "lnt", Ignore = "Remove to run test case")>]
-[<TestCase("mindblowingly", ExpectedResult = "nrmwy oldrm tob", Ignore = "Remove to run test case")>]
-[<TestCase("Testing, 1 2 3, testing.", ExpectedResult = "gvhgr mt123 gvhgr mt", Ignore = "Remove to run test case")>]
-[<TestCase("Truth is fiction.", ExpectedResult = "gifgs rhurx grlm", Ignore = "Remove to run test case")>]
-[<TestCase("The quick brown fox jumps over the lazy dog.", ExpectedResult = "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt", Ignore = "Remove to run test case")>]
-let ``Encodes words using atbash cipher`` words =        
-    encode words
+[<Test>]
+let ``Encode yes`` () =
+    let phrase = "yes"
+    let expected = "bvh"
+    let actual = encode phrase
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]     
+let ``Encode no`` () =
+    let phrase = "no"
+    let expected = "ml"
+    let actual = encode phrase
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]     
+let ``Encode OMG`` () =
+    let phrase = "OMG"
+    let expected = "lnt"
+    let actual = encode phrase
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]     
+let ``Encode spaces`` () =
+    let phrase = "O M G"
+    let expected = "lnt"
+    let actual = encode phrase
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]     
+let ``Encode mindblowingly`` () =
+    let phrase = "mindblowingly"
+    let expected = "nrmwy oldrm tob"
+    let actual = encode phrase
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]     
+let ``Encode numbers`` () =
+    let phrase = "Testing, 1 2 3, testing."
+    let expected = "gvhgr mt123 gvhgr mt"
+    let actual = encode phrase
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]     
+let ``Encode deep thought`` () =
+    let phrase = "Truth is fiction."
+    let expected = "gifgs rhurx grlm"
+    let actual = encode phrase
+    Assert.That(actual, Is.EqualTo(expected))
+
+[<Test>]
+[<Ignore("Remove to run test")>]     
+let ``Encode all the letters`` () =
+    let phrase = "The quick brown fox jumps over the lazy dog."
+    let expected = "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
+    let actual = encode phrase
+    Assert.That(actual, Is.EqualTo(expected))

data/tracks/fsharp/exercises/clock/ClockTest.fs

@@ -4,17 +4,28 @@ open System
 open NUnit.Framework
 open Clock
 
-[<TestCase(8, "08:00")>]
-[<TestCase(9, "09:00", Ignore = "Remove to run test case")>]
-let ``Prints the hour`` (hours: int, expected: string) =
-    let clock = mkClock hours 0
-    Assert.That(display clock, Is.EqualTo(expected))
-
-[<TestCase(11, 9, "11:09", Ignore = "Remove to run test case")>]
-[<TestCase(11, 19, "11:19", Ignore = "Remove to run test case")>]
-let ``Prints past the hour`` (hours: int) (minutes: int) (expected: string) =
-    let clock = mkClock hours minutes
-    Assert.That(display clock, Is.EqualTo(expected))
+[<Test>]
+let ``Prints 8 o'clock`` () =
+    let clock = mkClock 8 0
+    Assert.That(display clock, Is.EqualTo("08:00"))
+
+[<Test>]
+[<Ignore("Remove to run test")>]     
+let ``Prints 9 o'clock`` () =
+    let clock = mkClock 9 0
+    Assert.That(display clock, Is.EqualTo("09:00"))
+
+[<Test>]
+[<Ignore("Remove to run test")>]     
+let ``Can print single-digit minutes`` () =
+    let clock = mkClock 11 9
+    Assert.That(display clock, Is.EqualTo("11:09"))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Can print double-digit minutes`` () =
+    let clock = mkClock 11 19
+    Assert.That(display clock, Is.EqualTo("11:19"))
 
 [<Test>] 
 [<Ignore("Remove to run test")>]     

data/tracks/java/exercises/etl/src/test/java/EtlTest.java

@@ -1,4 +1,5 @@
 import org.junit.Test;
+import org.junit.Ignore;
 
 import java.util.*;
 
@@ -27,6 +28,7 @@ public class EtlTest {
         assertEquals(expected, etl.transform(old));
     }
 
+    @Ignore
     @Test
     public void testTransformMoreValues() {
         Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {
@@ -50,6 +52,7 @@ public class EtlTest {
         assertEquals(expected, etl.transform(old));
     }
 
+    @Ignore
     @Test
     public void testMoreKeys() {
         Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {
@@ -73,6 +76,7 @@ public class EtlTest {
         assertEquals(expected, etl.transform(old));
     }
 
+    @Ignore
     @Test
     public void testFullDataset() {
         Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {

data/tracks/java/exercises/hello-world/src/test/java/HelloWorldTest.java

@@ -12,6 +12,12 @@ public class HelloWorldTest {
         assertEquals("Hello, World!", HelloWorld.hello(null));
     }
 
+    @Test
+    @Ignore
+    public void emptyStringIsComparedByValue() {
+        assertEquals("Hello, World!", HelloWorld.hello(new String("")));
+    }
+    
     @Test
     @Ignore
     public void helloSampleName() {

data/tracks/julia/config.json

@@ -99,15 +99,24 @@
         "arithmetics",
         "control-flow (conditionals)"
       ]
+    },
+	{
+      "slug": "atbash-cipher",
+      "difficulty": 1,
+      "topics": [
+        "strings",
+        "control-flow (conditionals)",
+        "control-flow (loops)"
+      ]
     },
     {
-        "slug": "roman-numerals",
-        "difficulty": 1,
-        "topics": [
-          "control-flow (loops)",
-          "strings",
-          "mathematics"
-        ]
+      "slug": "roman-numerals",
+      "difficulty": 1,
+      "topics": [
+        "control-flow (loops)",
+        "strings",
+        "mathematics"
+      ]
     },
     {
       "slug": "isogram",

data/tracks/julia/exercises/atbash-cipher/atbash-cipher.jl

@@ -0,0 +1,8 @@
+function encode(input::AbstractString)
+
+end
+
+function decode(input::AbstractString)
+
+end
+

data/tracks/julia/exercises/atbash-cipher/example.jl

@@ -0,0 +1,4 @@
+cipher(input::AbstractString) = map(x->isalpha(x)?Char(219-Int(x)):x, lowercase(filter(isalnum, input)))
+encode(input::AbstractString) = join(matchall(r"(.{1,5})", cipher(input)), ' ')
+decode(input::AbstractString) = cipher(input)
+

data/tracks/julia/exercises/atbash-cipher/runtests.jl

@@ -0,0 +1,56 @@
+using Base.Test
+
+include("atbash-cipher.jl")
+
+@testset "encoding from English to atbash" begin
+	@testset "encode yes" begin
+		@test encode("yes") == "bvh"
+	end
+
+	@testset "encode no" begin
+		@test encode("no") == "ml"
+	end
+
+	@testset "encode OMG" begin
+		@test encode("OMG") == "lnt"
+	end
+
+	@testset "encode spaces" begin
+		@test encode("O M G") == "lnt"
+	end
+
+	@testset "encode mindblowingly" begin
+		@test encode("mindblowingly") == "nrmwy oldrm tob"
+	end
+
+	@testset "encode numbers" begin
+		@test encode("Testing,1 2 3, testing.") == "gvhgr mt123 gvhgr mt"
+	end
+
+	@testset "encode deep thought" begin
+		@test encode("Truth is fiction.") == "gifgs rhurx grlm"
+	end
+
+	@testset "encode all the letters" begin
+		@test encode("The quick brown fox jumps over the lazy dog.") == "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
+	end
+end
+
+@testset "decoding from atbash to English" begin
+	@testset "decode exercism" begin
+		@test decode("vcvix rhn") == "exercism"
+	end
+
+	@testset "decode a sentence" begin
+		@test decode("zmlyh gzxov rhlug vmzhg vkkrm thglm v") == "anobstacleisoftenasteppingstone"
+	end
+
+	@testset "decode numbers" begin
+		@test decode("gvhgr mt123 gvhgr mt") == "testing123testing"
+	end
+
+	@testset "decode all the letters" begin
+		@test decode("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt") == "thequickbrownfoxjumpsoverthelazydog"
+	end
+end
+

data/tracks/kotlin/config.json

@@ -222,6 +222,16 @@
       "difficulty": 1,
       "slug": "change",
       "topics": []
+    },
+    {
+      "difficulty": 10,
+      "slug": "react",
+      "topics": [
+        "Reactive programming",
+        "Generics",
+        "Nested classes",
+        "Higher-order functions"
+      ]
     }
   ]
 }

data/tracks/kotlin/exercises/react/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.0.6'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/kotlin/exercises/react/src/example/kotlin/React.kt

@@ -0,0 +1,65 @@
+class Reactor<T>() {
+    abstract inner class Cell {
+        abstract val value: T
+        internal val dependents = mutableListOf<ComputeCell>()
+    }
+
+    interface Subscription {
+        fun cancel()
+    }
+
+    inner class InputCell(initialValue: T) : Cell() {
+        override var value: T = initialValue
+            set(newValue) {
+                field = newValue
+                dependents.forEach { it.propagate() }
+                dependents.forEach { it.fireCallbacks() }
+            }
+    }
+
+    inner class ComputeCell private constructor(val newValue: () -> T) : Cell() {
+        override var value: T = newValue()
+            private set
+
+        private var lastCallbackValue = value
+        private var callbacksIssued = 0
+        private val activeCallbacks = mutableMapOf<Int, (T) -> Any>()
+
+        constructor(vararg cells: Cell, f: (List<T>) -> T) : this({ f(cells.map { it.value }) }) {
+            for (cell in cells) {
+                cell.dependents.add(this)
+            }
+        }
+
+        fun addCallback(f: (T) -> Any): Subscription {
+            val id = callbacksIssued
+            callbacksIssued++
+            activeCallbacks[id] = f
+            return object : Subscription {
+                override fun cancel() {
+                    activeCallbacks.remove(id)
+                }
+            }
+        }
+
+        internal fun propagate() {
+            val nv = newValue()
+            if (nv == value) {
+                return
+            }
+            value = nv
+            dependents.forEach { it.propagate() }
+        }
+
+        internal fun fireCallbacks() {
+            if (value == lastCallbackValue) {
+                return
+            }
+            lastCallbackValue = value
+            for (cb in activeCallbacks.values) {
+                cb(value)
+            }
+            dependents.forEach { it.fireCallbacks() }
+        }
+    }
+}

data/tracks/kotlin/exercises/react/src/main/kotlin/React.kt

@@ -0,0 +1,7 @@
+class Reactor<T>() {
+    // Your compute cell's addCallback method must return an object
+    // that implements the Subscription interface.
+    interface Subscription {
+        fun cancel()
+    }
+}

data/tracks/kotlin/exercises/react/src/test/kotlin/ReactTest.kt

@@ -0,0 +1,221 @@
+import org.junit.Test
+import org.junit.Ignore
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import kotlin.test.assertEquals
+
+class ReactTest {
+    @Test
+    fun inputCellsHaveValue() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(10)
+        assertEquals(10, input.value)
+    }
+
+    @Ignore
+    @Test
+    fun inputCellsValueCanBeSet() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(4)
+        input.value = 20
+        assertEquals(20, input.value)
+    }
+
+    @Ignore
+    @Test
+    fun computeCellsCalculateInitialValue() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(1)
+        val output = reactor.ComputeCell(input) { it[0] + 1 }
+        assertEquals(2, output.value)
+    }
+
+    @Ignore
+    @Test
+    fun computeCellsTakeInputsInTheRightOrder() {
+        val reactor = Reactor<Int>()
+        val one = reactor.InputCell(1)
+        val two = reactor.InputCell(2)
+        val output = reactor.ComputeCell(one, two) { it[0] + it[1] * 10 }
+        assertEquals(21, output.value)
+    }
+
+    @Ignore
+    @Test
+    fun computeCellsUpdateValueWhenDependenciesAreChanged() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(1)
+        val output = reactor.ComputeCell(input) { it[0] + 1 }
+        input.value = 3
+        assertEquals(4, output.value)
+    }
+
+    @Ignore
+    @Test
+    fun computeCellsCanDependOnOtherComputeCells() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(1)
+        val timesTwo = reactor.ComputeCell(input) { it[0] * 2 }
+        val timesThirty = reactor.ComputeCell(input) { it[0] * 30 }
+        val output = reactor.ComputeCell(timesTwo, timesThirty) { it[0] + it[1] }
+
+        assertEquals(32, output.value)
+        input.value = 3
+        assertEquals(96, output.value)
+    }
+
+    @Ignore
+    @Test
+    fun computeCellsFireCallbacks() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(1)
+        val output = reactor.ComputeCell(input) { it[0] + 1 }
+
+        val vals = mutableListOf<Int>()
+        output.addCallback { vals.add(it) }
+
+        input.value = 3
+        assertEquals(listOf(4), vals)
+    }
+
+    @Ignore
+    @Test
+    fun callbacksOnlyFireOnChange() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(1)
+        val output = reactor.ComputeCell(input) { if (it[0] < 3) 111 else 222 }
+
+        val vals = mutableListOf<Int>()
+        output.addCallback { vals.add(it) }
+
+        input.value = 2
+        assertEquals(listOf<Int>(), vals)
+
+        input.value = 4
+        assertEquals(listOf(222), vals)
+    }
+
+    @Ignore
+    @Test
+    fun callbacksCanBeAddedAndRemoved() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(11)
+        val output = reactor.ComputeCell(input) { it[0] + 1 }
+
+        val vals1 = mutableListOf<Int>()
+        val sub1 = output.addCallback { vals1.add(it) }
+        val vals2 = mutableListOf<Int>()
+        output.addCallback { vals2.add(it) }
+
+        input.value = 31
+        sub1.cancel()
+
+        val vals3 = mutableListOf<Int>()
+        output.addCallback { vals3.add(it) }
+
+        input.value = 41
+
+        assertEquals(listOf(32), vals1)
+        assertEquals(listOf(32, 42), vals2)
+        assertEquals(listOf(42), vals3)
+    }
+
+    @Ignore
+    @Test
+    fun removingACallbackMultipleTimesDoesntInterfereWithOtherCallbacks() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(1)
+        val output = reactor.ComputeCell(input) { it[0] + 1 }
+
+        val vals1 = mutableListOf<Int>()
+        val sub1 = output.addCallback { vals1.add(it) }
+        val vals2 = mutableListOf<Int>()
+        output.addCallback { vals2.add(it) }
+
+        for (i in 1..10) {
+            sub1.cancel()
+        }
+
+        input.value = 2
+        assertEquals(listOf<Int>(), vals1)
+        assertEquals(listOf(3), vals2)
+    }
+
+    @Ignore
+    @Test
+    fun callbacksShouldOnlyBeCalledOnceEvenIfMultipleDependenciesChange() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(1)
+        val plusOne = reactor.ComputeCell(input) { it[0] + 1 }
+        val minusOne1 = reactor.ComputeCell(input) { it[0] - 1 }
+        val minusOne2 = reactor.ComputeCell(minusOne1) { it[0] - 1 }
+        val output = reactor.ComputeCell(plusOne, minusOne2) { it[0] * it[1] }
+
+        val vals = mutableListOf<Int>()
+        output.addCallback { vals.add(it) }
+
+        input.value = 4
+        assertEquals(listOf(10), vals)
+    }
+
+    @Ignore
+    @Test
+    fun callbacksShouldNotBeCalledIfDependenciesChangeButOutputValueDoesntChange() {
+        val reactor = Reactor<Int>()
+        val input = reactor.InputCell(1)
+        val plusOne = reactor.ComputeCell(input) { it[0] + 1 }
+        val minusOne = reactor.ComputeCell(input) { it[0] - 1 }
+        val alwaysTwo = reactor.ComputeCell(plusOne, minusOne) { it[0] - it[1] }
+
+        val vals = mutableListOf<Int>()
+        alwaysTwo.addCallback { vals.add(it) }
+
+        for (i in 1..10) {
+            input.value = i
+        }
+
+        assertEquals(listOf<Int>(), vals)
+    }
+}
+
+@RunWith(Parameterized::class)
+// This is a digital logic circuit called an adder:
+// https://en.wikipedia.org/wiki/Adder_(electronics)
+class ReactAdderTest(val input: Input, val expected: Expected) {
+
+    companion object {
+        data class Input(val a: Boolean, val b: Boolean, val carryIn: Boolean)
+        data class Expected(val carryOut: Boolean, val sum: Boolean)
+
+        @JvmStatic
+        @Parameterized.Parameters(name = "{index}: {0} = {1}")
+        fun data() = listOf(
+                arrayOf(Input(a=false, b=false, carryIn=false), Expected(carryOut=false, sum=false)),
+                arrayOf(Input(a=false, b=false, carryIn=true),  Expected(carryOut=false, sum=true)),
+                arrayOf(Input(a=false, b=true,  carryIn=false), Expected(carryOut=false, sum=true)),
+                arrayOf(Input(a=false, b=true,  carryIn=true),  Expected(carryOut=true,  sum=false)),
+                arrayOf(Input(a=true,  b=false, carryIn=false), Expected(carryOut=false, sum=true)),
+                arrayOf(Input(a=true,  b=false, carryIn=true),  Expected(carryOut=true,  sum=false)),
+                arrayOf(Input(a=true,  b=true,  carryIn=false), Expected(carryOut=true,  sum=false)),
+                arrayOf(Input(a=true,  b=true,  carryIn=true),  Expected(carryOut=true,  sum=true))
+        )
+    }
+
+    @Ignore
+    @Test
+    fun test() {
+        val reactor = Reactor<Boolean>()
+        val a = reactor.InputCell(input.a)
+        val b = reactor.InputCell(input.b)
+        val carryIn = reactor.InputCell(input.carryIn)
+
+        val aXorB = reactor.ComputeCell(a, b) { it[0].xor(it[1]) }
+        val sum = reactor.ComputeCell(aXorB, carryIn) { it[0].xor(it[1]) }
+
+        val aXorBAndCin = reactor.ComputeCell(aXorB, carryIn) { it[0] && it[1] }
+        val aAndB = reactor.ComputeCell(a, b) { it[0] && it[1] }
+        val carryOut = reactor.ComputeCell(aXorBAndCin, aAndB) { it[0] || it[1] }
+
+        assertEquals(expected, Expected(sum=sum.value, carryOut=carryOut.value))
+    }
+}

data/tracks/kotlin/exercises/settings.gradle

@@ -24,6 +24,7 @@ include 'pascals-triangle'
 include 'phone-number'
 include 'pig-latin'
 include 'raindrops'
+include 'react'
 include 'rna-transcription'
 include 'robot-name'
 include 'roman-numerals'

data/tracks/lua/README.md

@@ -4,44 +4,54 @@
 
 Exercism exercises in Lua
 
-## Setup Dev environment for contributing
+## Setup dev environment for contributing
 
-### Mac OS
+Install Lua, Luarocks, and the Busted testing framework according to the
+[installation instructions][1] for your platform.
 
-For Mac OS, you can use [homebrew][1] to install Lua and [luarocks][2]
+To contribute a patch you will need a GitHub account and you will need to fork
+the *exercism/xlua* repo to your account.
+Clone your fork with the command: `git clone https://github.com/<your_username>/xlua`.
+Create your patch and open a pull request to the exercism/xlua repo.
 
-    $ brew install lua
+See the GitHub Help for [forking a repo][2] and [creating a pull request][3]
+if you are unfamiliar with this process.
 
-Then install [busted][3] testing framework for lua. Busted is similiar to Jasmine testing framework in Javascript.
+To contribute a new exercise, create a folder named after the exercise within the
+*xlua/exercises* directory. Create your files for a new test, test class and the implementation.
 
-    $ luarocks install busted
+For example, for the [Bob][4] exercise:
 
-Then create a folder for a new test, test class and the implementation.
+    $ tree bob
+    bob
+    ├── bob_spec.lua
+    └── bob.lua
 
-    → ls -l
-    total 16
-    -rw-r--r--@ 1 aarti  staff  1111 Nov 25 14:05 bob_test.lua
-    -rw-r--r--@ 1 aarti  staff   453 Nov 25 14:05 bob.lua
+    0 directories, 2 files
 
 Run the test
 
     $ busted .
 
-Rename bob.lua to example.lua, add test to config.json
+Rename *bob.lua* to *example.lua*, and add the exercise to the [xlua/config.json][5] file.
 
-    → ls -l
-    total 16
-    -rw-r--r--@ 1 aarti  staff  1111 Nov 25 14:05 bob_test.lua
-    -rw-r--r--@ 1 aarti  staff   453 Nov 25 14:05 example.lua
+    $ tree bob
+    bob
+    ├── bob_spec.lua
+    └── example.lua
 
-Other resources
-
-  1. [Lua Style Guide][4]
-  2. [Learn Lua in 15 minutes][5]
+    0 directories, 2 files
 
 ## Contributing Guide
 
-Please see the [contributing guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data)
+Please be familiar with the [contributing guide][6] in the x-common repository.
+This describes how all the language tracks are put together, as well as details
+about the common metadata, and high-level information about contributing to
+existing problems and adding new problems.
+
+## Other Resources
+
+Pleases see the [Useful Lua Resources][7] page.
 
 ## License
 
@@ -49,11 +59,13 @@ The MIT License (MIT)
 
 Copyright (c) 2014 Katrina Owen, _@kytrinyx.com
 
-### Lua icon
+## Lua icon
 The Lua icon is inspired by the [Lua logo](http://www.lua.org/images/), which was designed by Alexandre Nakonechnyj.
 
-[1]: http://brew.sh/
-[2]: http://luarocks.org/
-[3]: http://olivinelabs.com/busted/
-[4]: https://github.com/Olivine-Labs/lua-style-guide
-[5]: http://tylerneylon.com/a/learn-lua/
+[1]: http://exercism.io/languages/lua/installing
+[2]: https://help.github.com/articles/fork-a-repo/
+[3]: https://help.github.com/articles/creating-a-pull-request/
+[4]: https://github.com/exercism/xlua/tree/master/exercises/bob
+[5]: https://github.com/exercism/xlua/blob/master/config.json
+[6]: https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md
+[7]: http://exercism.io/languages/lua/resources

data/tracks/lua/docs/RESOURCES.md

@@ -5,7 +5,12 @@ There are many great free online resources for Lua including:
 3.  For an official definition of the Lua language, consult the [Lua 5.1 Reference Manual][7], by R. Ierusalimschy, L. H. de Figueiredo, W. Celes.
 4.  [Lua Style Guide][4]
 5.  [Learn Lua in 15 minutes][5]
-6.  [Some][9] [options][10] [for][11] [linting][12]
+6.  Some options for linting
+    -   [lua-checker][9]
+    -   [Lua Lint][10]
+    -   [Lua Inspect][11]
+    -   [luacheck][12]
+    -   [Detecting Undefined Variables][13]
 
 [4]: https://github.com/Olivine-Labs/lua-style-guide
 [5]: http://tylerneylon.com/a/learn-lua/
@@ -15,4 +20,5 @@ There are many great free online resources for Lua including:
 [9]: https://code.google.com/p/lua-checker/
 [10]: http://lua-users.org/wiki/LuaLint
 [11]: http://lua-users.org/wiki/LuaInspect
-[12]: http://lua-users.org/wiki/DetectingUndefinedVariables
+[12]: https://github.com/mpeterv/luacheck
+[13]: http://lua-users.org/wiki/DetectingUndefinedVariables

data/tracks/rust/exercises/luhn/example.rs

@@ -1,5 +1,6 @@
 pub fn is_valid(candidate: &str) -> bool {
-    if candidate.chars().any(|c| c.is_alphabetic()) || candidate.chars().count() == 1 {
+    if candidate.chars().filter(|c| c.is_digit(10)).take(2).count() <= 1 ||
+       candidate.chars().any(|c| !c.is_digit(10) && c != ' ') {
         return false;
     }
 

data/tracks/rust/exercises/luhn/tests/luhn.rs

@@ -13,6 +13,12 @@ fn single_zero_string_is_invalid() {
     assert!(!is_valid("0"));
 }
 
+#[test]
+#[ignore]
+fn simple_valid_sin() {
+    assert!(is_valid(" 5 9 "));
+}
+
 #[test]
 #[ignore]
 fn valid_canadian_sin_is_valid() {
@@ -36,3 +42,39 @@ fn invalid_credit_card_is_invalid() {
 fn strings_that_contain_non_digits_are_invalid() {
     assert!(!is_valid("046a 454 286"));
 }
+
+#[test]
+#[ignore]
+fn punctuation_is_invalid() {
+    assert!(!is_valid("055-444-285"));
+}
+
+#[test]
+#[ignore]
+fn symbols_are_invalid() {
+    assert!(!is_valid("055£ 444$ 285"));
+}
+
+#[test]
+#[ignore]
+fn single_digit_with_space_is_invalid() {
+    assert!(!is_valid(" 0"));
+}
+
+#[test]
+#[ignore]
+fn lots_of_zeros_are_valid() {
+    assert!(is_valid(" 00000"));
+}
+
+#[test]
+#[ignore]
+fn another_valid_sin() {
+    assert!(is_valid("055 444 285"));
+}
+
+#[test]
+#[ignore]
+fn nine_doubled_is_nine() {
+    assert!(is_valid("091"));
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.6.35
+  version: 2.0.6.36
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-09 00:00:00.000000000 Z
+date: 2017-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -4274,6 +4274,9 @@ files:
 - tracks/julia/exercises/anagram/anagram.jl
 - tracks/julia/exercises/anagram/example.jl
 - tracks/julia/exercises/anagram/runtests.jl
+- tracks/julia/exercises/atbash-cipher/atbash-cipher.jl
+- tracks/julia/exercises/atbash-cipher/example.jl
+- tracks/julia/exercises/atbash-cipher/runtests.jl
 - tracks/julia/exercises/bob/bob.jl
 - tracks/julia/exercises/bob/example.jl
 - tracks/julia/exercises/bob/runtests.jl
@@ -4485,6 +4488,10 @@ files:
 - tracks/kotlin/exercises/raindrops/src/example/kotlin/Raindrops.kt
 - tracks/kotlin/exercises/raindrops/src/main/kotlin/.keep
 - tracks/kotlin/exercises/raindrops/src/test/kotlin/RaindropsTest.kt
+- tracks/kotlin/exercises/react/build.gradle
+- tracks/kotlin/exercises/react/src/example/kotlin/React.kt
+- tracks/kotlin/exercises/react/src/main/kotlin/React.kt
+- tracks/kotlin/exercises/react/src/test/kotlin/ReactTest.kt
 - tracks/kotlin/exercises/rna-transcription/build.gradle
 - tracks/kotlin/exercises/rna-transcription/src/example/kotlin/RnaTranscription.kt
 - tracks/kotlin/exercises/rna-transcription/src/main/kotlin/RnaTranscription.kt
@@ -4874,7 +4881,6 @@ files:
 - tracks/lua/.travis.yml
 - tracks/lua/LICENSE
 - tracks/lua/README.md
-- tracks/lua/SETUP.md
 - tracks/lua/bin/fetch-configlet
 - tracks/lua/bin/test-all
 - tracks/lua/config.json

data/tracks/lua/SETUP.md

@@ -1,76 +0,0 @@
-### Getting started
-#### MacOS
-First install Lua and [Luarocks][2] using [Homebrew][1]:
-
-```shell
-$ brew install lua
-```
-
-Then install the [Busted][3] testing framework for Lua:
-
-```shell
-$ luarocks install busted
-```
-
-Then run your tests:
-
-```shell
-$ busted .
-```
-
-#### Ubuntu
-First install Lua and [Luarocks][2] using [Apt][6]:
-
-```shell
-$ sudo apt-get install lua5.3 luarocks
-```
-
-Then install the [Busted][3] testing framework for Lua:
-
-```shell
-$ luarocks install busted
-```
-
-If this fails, you may need to use `sudo`:
-
-```shell
-$ sudo luarocks install busted
-```
-
-Then run your tests:
-
-```shell
-$ busted .
-```
-
-#### Windows
-First install Lua and [Luarocks][2] using [Chocolatey][7]:
-
-```
-C:\> choco install lua
-```
-
-Then install the [Busted][3] testing framework for Lua:
-
-```
-C:\> luarocks install busted
-```
-
-Then run your tests:
-
-```
-C:\> busted .
-```
-
-#### Other resources
-
-  1. [Lua Style Guide][4]
-  2. [Learn Lua in 15 minutes][5]
-
-[1]: http://brew.sh/
-[2]: http://luarocks.org/
-[3]: http://olivinelabs.com/busted/
-[4]: https://github.com/Olivine-Labs/lua-style-guide
-[5]: http://tylerneylon.com/a/learn-lua/
-[6]: https://help.ubuntu.com/lts/serverguide/apt.html
-[7]: http://chocolatey.org/