trackler 2.2.1.115 → 2.2.1.116

data/tracks/dart/exercises/word-count/pubspec.yaml

@@ -1,3 +1,3 @@
 name: 'word_count'
 dev_dependencies:
-  test: '<0.13.0'
+  test: '<0.13.0'

data/tracks/dart/exercises/word-count/test/word_count_test.dart

@@ -12,53 +12,63 @@ void main() {
 
 void simpleTests() {
   test("count one word", () {
-    Map<String, int> test = myWordCounter.countWords("word");
-    expect(test, equals({"word": 1}));
+    final Map<String, int> result = myWordCounter.countWords("word");
+    expect(result, equals({"word": 1}));
   }, skip: false);
+
   test("count one of each word", () {
-    Map<String, int> test = myWordCounter.countWords("one of each");
-    expect(test, equals({"one": 1, "of": 1, "each": 1}));
+    final Map<String, int> result = myWordCounter.countWords("one of each");
+    expect(result, equals({"one": 1, "of": 1, "each": 1}));
   }, skip: true);
+
   test("multiple occurrences of a word", () {
-    Map<String, int> test = myWordCounter.countWords("one fish two fish red fish blue fish");
-    expect(test, equals({"one": 1, "fish": 4, "two": 1, "red": 1, "blue": 1}));
+    final Map<String, int> result = myWordCounter.countWords("one fish two fish red fish blue fish");
+    expect(result, equals({"one": 1, "fish": 4, "two": 1, "red": 1, "blue": 1}));
   }, skip: true);
 }
 
 void ignoreSpecialCharacters() {
   test("handles cramped lists", () {
-    Map<String, int> test = myWordCounter.countWords("one,two,three");
-    expect(test, equals({"one": 1, "two": 1, "three": 1}));
+    final Map<String, int> result = myWordCounter.countWords("one,two,three");
+    expect(result, equals({"one": 1, "two": 1, "three": 1}));
   }, skip: true);
+
   test("handles expanded lists", () {
-    Map<String, int> test = myWordCounter.countWords("one,\ntwo,\nthree");
-    expect(test, equals({"one": 1, "two": 1, "three": 1}));
+    final Map<String, int> result = myWordCounter.countWords("one,\ntwo,\nthree");
+    expect(result, equals({"one": 1, "two": 1, "three": 1}));
   }, skip: true);
+
   test("ignore punctuation", () {
-    Map<String, int> test = myWordCounter.countWords('car: carpet as java: javascript!!&@\$%^&');
-    expect(test, equals({"car": 1, "carpet": 1, "as": 1, "java": 1, "javascript": 1}));
+    final Map<String, int> result = myWordCounter.countWords("car: carpet as java: javascript!!&@\$%^&");
+    expect(result, equals({"car": 1, "carpet": 1, "as": 1, "java": 1, "javascript": 1}));
   }, skip: true);
 
   test("with quotations", () {
-    Map<String, int> test = myWordCounter.countWords("Joe can't tell between 'large' and large.");
-    expect(test, equals({"joe": 1, "can't": 1, "tell": 1, "between": 1, "large": 2, "and": 1}));
+    final Map<String, int> result = myWordCounter.countWords("Joe can't tell between 'large' and large.");
+    expect(result, equals({"joe": 1, "can't": 1, "tell": 1, "between": 1, "large": 2, "and": 1}));
   }, skip: true);
 }
 
 void notJustWords() {
   test("include numbers", () {
-    Map<String, int> test = myWordCounter.countWords("testing, 1, 2 testing");
-    expect(test, equals({"testing": 2, "1": 1, "2": 1}));
+    final Map<String, int> result = myWordCounter.countWords("testing, 1, 2 testing");
+    expect(result, equals({"testing": 2, "1": 1, "2": 1}));
   }, skip: true);
 }
 
 void edgeCases() {
   test("normalize case", () {
-    Map<String, int> test = myWordCounter.countWords("go Go GO Stop stop");
-    expect(test, equals({"go": 3, "stop": 2}));
+    final Map<String, int> result = myWordCounter.countWords("go Go GO Stop stop");
+    expect(result, equals({"go": 3, "stop": 2}));
   }, skip: true);
+
   test("with apostrophes", () {
-    Map<String, int> test = myWordCounter.countWords("First: don't laugh. Then: don't cry.");
-    expect(test, equals({"first": 1, "don't": 2, "laugh": 1, "then": 1, "cry": 1}));
+    final Map<String, int> result = myWordCounter.countWords("First: don't laugh. Then: don't cry.");
+    expect(result, equals({"first": 1, "don't": 2, "laugh": 1, "then": 1, "cry": 1}));
+  }, skip: true);
+
+  test("multiple spaces not detected as a word", () {
+    final Map<String, int> result = myWordCounter.countWords(" multiple   whitespaces");
+    expect(result, equals({"multiple": 1, "whitespaces": 1}));
   }, skip: true);
 }

data/tracks/dart/lib/src/utils.dart

@@ -0,0 +1,58 @@
+import 'dart:async';
+import 'dart:io';
+import 'package:io/io.dart';
+
+class CommonUtils {
+  ProcessManager _manager;
+
+  CommonUtils() {
+    this._manager = new ProcessManager();
+  }
+
+  /// Fetches the configlet file if it doesn't exist already, and returns the
+  /// exit code.
+  int fetchConfiglet() {
+    File configletFile = new File('bin/configlet');
+
+    if (!configletFile.existsSync()) {
+      print('Fetching configlet...');
+      return _exit(Process.runSync('bin/fetch-configlet', []).exitCode);
+    }
+
+    return 0;
+  }
+
+  /// Returns a [Future] with the exit code resulting from running the
+  /// [executable] with [arguments].
+  Future<int> runCmd(String executable, [List<String> arguments = const []]) async {
+    Process spawn = await _manager.spawn(executable, arguments);
+    return _exit(await spawn.exitCode);
+  }
+
+  /// Returns a [Future] with the exit code resulting from running the
+  /// [executable] with [arguments].
+  ///
+  /// If [executable] isn't executable, returns a [Future] with exit code 1 and
+  /// shows an error message.
+  Future<int> runCmdIfExecutable(String executable, [List<String> arguments = const []]) async {
+    final result = isExecutable(executable);
+
+    if (result is bool && !result || result is Future && !await result) {
+      print('Unable to run "$executable". Make sure that it\'s executable and that you have permissions to run it.');
+      return new Future.value(1);
+    }
+
+    return runCmd(executable, arguments);
+  }
+
+  /// Terminates the global `stdin` listener.
+  Future<Null> terminate() async {
+    await ProcessManager.terminateStdIn();
+  }
+}
+
+/// Returns [exitCode] and shows an error message if it is different from 0.
+int _exit(int exitCode) {
+  if (exitCode != 0) print('Failed. Error code: $exitCode.');
+  return exitCode;
+}

data/tracks/dart/pubspec.yaml

@@ -7,5 +7,6 @@ authors:
 dev_dependencies:
   args: '^1.0.0'
   dart_style: '^1.0.8'
+  io: '0.3.0'
   test: '>=0.12.24+8 <0.13.0'
   yaml: '>=2.1.12 <2.2.0'

data/tracks/python/.github/stale.yml

@@ -9,6 +9,7 @@ exemptLabels:
   - epic
   - enhancement
   - beginner friendly
+  - awaiting review
 # Label to use when marking an issue as stale
 staleLabel: abandoned
 # Comment to post when marking an issue as stale. Set to `false` to disable

data/tracks/scala/config.json

@@ -85,7 +85,7 @@
     {
       "uuid": "825e94e5-6fc8-4dce-befe-74e1516fae14",
       "slug": "flatten-array",
-      "core": true,
+      "core": false,
       "unlocked_by": "accumulate",
       "difficulty": 2,
       "topics": [
@@ -97,7 +97,7 @@
     {
       "uuid": "65a76aba-a485-222d-84ba-e9a445b25be6",
       "slug": "collatz-conjecture",
-      "core": true,
+      "core": false,
       "unlocked_by": "leap",
       "difficulty": 2,
       "topics": [

data/tracks/scala/exercises/space-age/src/test/scala/SpaceAgeTest.scala

@@ -1,6 +1,6 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.0.0 */
+/** @version 1.1.0 */
 class SpaceAgeTest extends FunSuite with Matchers {
 
   test("age on Earth") {
@@ -41,4 +41,4 @@ class SpaceAgeTest extends FunSuite with Matchers {
     pending
     SpaceAge.onNeptune(8.210123456E9) should be (1.58)
   }
-}
+}

data/tracks/scala/exercises/spiral-matrix/src/test/scala/SpiralMatrixTest.scala

@@ -1,52 +1,47 @@
-
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.0.0 */
+/** @version 1.1.0 */
 class SpiralMatrixTest extends FunSuite with Matchers {
 
   test("empty spiral") {
-    SpiralMatrix.spiralMatrix(0) should be (
-      List()
-    )
+    SpiralMatrix.spiralMatrix(0) should be(List())
   }
 
   test("trivial spiral") {
     pending
-    SpiralMatrix.spiralMatrix(1) should be (List(
-      List(1)))
+    SpiralMatrix.spiralMatrix(1) should be(List(List(1)))
   }
 
   test("spiral of size 2") {
     pending
-    SpiralMatrix.spiralMatrix(2) should be (List(
-      List(1, 2),
-      List(4, 3)))
+    SpiralMatrix.spiralMatrix(2) should be(List(List(1, 2),
+                                                List(4, 3)))
   }
 
   test("spiral of size 3") {
     pending
-    SpiralMatrix.spiralMatrix(3) should be (List(
-      List(1, 2, 3),
-      List(8, 9, 4),
-      List(7, 6, 5)))
+    SpiralMatrix.spiralMatrix(3) should be(
+      List(List(1, 2, 3), 
+           List(8, 9, 4), 
+           List(7, 6, 5)))
   }
 
   test("spiral of size 4") {
     pending
-    SpiralMatrix.spiralMatrix(4) should be (List(
-      List( 1,  2,  3, 4),
-      List(12, 13, 14, 5),
-      List(11, 16, 15, 6),
-      List(10,  9,  8, 7)))
+    SpiralMatrix.spiralMatrix(4) should be(
+      List(List(1, 2, 3, 4),
+           List(12, 13, 14, 5),
+           List(11, 16, 15, 6),
+           List(10, 9, 8, 7)))
   }
 
   test("spiral of size 5") {
     pending
-    SpiralMatrix.spiralMatrix(5) should be (List(
-      List( 1,  2,  3,  4, 5),
-      List(16, 17, 18, 19, 6),
-      List(15, 24, 25, 20, 7),
-      List(14, 23, 22, 21, 8),
-      List(13, 12, 11, 10, 9)))
+    SpiralMatrix.spiralMatrix(5) should be(
+      List(List(1, 2, 3, 4, 5),
+           List(16, 17, 18, 19, 6),
+           List(15, 24, 25, 20, 7),
+           List(14, 23, 22, 21, 8),
+           List(13, 12, 11, 10, 9)))
   }
 }

data/tracks/scala/exercises/sublist/src/test/scala/SublistTest.scala

@@ -1,89 +1,97 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.0.0 */
+/** @version 1.1.0 */
 class SublistTest extends FunSuite with Matchers {
 
   test("empty lists") {
-    Sublist.sublist(List(), List()) should be (Sublist.Equal)
+    Sublist.sublist(List(), List()) should be(Sublist.Equal)
   }
 
   test("empty list within non empty list") {
     pending
-    Sublist.sublist(List(), List(1, 2, 3)) should be (Sublist.Sublist)
+    Sublist.sublist(List(), List(1, 2, 3)) should be(Sublist.Sublist)
   }
 
   test("non empty list contains empty list") {
     pending
-    Sublist.sublist(List(1, 2, 3), List()) should be (Sublist.Superlist)
+    Sublist.sublist(List(1, 2, 3), List()) should be(Sublist.Superlist)
   }
 
   test("list equals itself") {
     pending
-    Sublist.sublist(List(1, 2, 3), List(1, 2, 3)) should be (Sublist.Equal)
+    Sublist.sublist(List(1, 2, 3), List(1, 2, 3)) should be(Sublist.Equal)
   }
 
   test("different lists") {
     pending
-    Sublist.sublist(List(1, 2, 3), List(2, 3, 4)) should be (Sublist.Unequal)
+    Sublist.sublist(List(1, 2, 3), List(2, 3, 4)) should be(Sublist.Unequal)
   }
 
   test("false start") {
     pending
-    Sublist.sublist(List(1, 2, 5), List(0, 1, 2, 3, 1, 2, 5, 6)) should be (Sublist.Sublist)
+    Sublist.sublist(List(1, 2, 5), List(0, 1, 2, 3, 1, 2, 5, 6)) should be(
+      Sublist.Sublist)
   }
 
   test("consecutive") {
     pending
-    Sublist.sublist(List(1, 1, 2), List(0, 1, 1, 1, 2, 1, 2)) should be (Sublist.Sublist)
+    Sublist.sublist(List(1, 1, 2), List(0, 1, 1, 1, 2, 1, 2)) should be(
+      Sublist.Sublist)
   }
 
   test("sublist at start") {
     pending
-    Sublist.sublist(List(0, 1, 2), List(0, 1, 2, 3, 4, 5)) should be (Sublist.Sublist)
+    Sublist.sublist(List(0, 1, 2), List(0, 1, 2, 3, 4, 5)) should be(
+      Sublist.Sublist)
   }
 
   test("sublist in middle") {
     pending
-    Sublist.sublist(List(2, 3, 4), List(0, 1, 2, 3, 4, 5)) should be (Sublist.Sublist)
+    Sublist.sublist(List(2, 3, 4), List(0, 1, 2, 3, 4, 5)) should be(
+      Sublist.Sublist)
   }
 
   test("sublist at end") {
     pending
-    Sublist.sublist(List(3, 4, 5), List(0, 1, 2, 3, 4, 5)) should be (Sublist.Sublist)
+    Sublist.sublist(List(3, 4, 5), List(0, 1, 2, 3, 4, 5)) should be(
+      Sublist.Sublist)
   }
 
   test("at start of superlist") {
     pending
-    Sublist.sublist(List(0, 1, 2, 3, 4, 5), List(0, 1, 2)) should be (Sublist.Superlist)
+    Sublist.sublist(List(0, 1, 2, 3, 4, 5), List(0, 1, 2)) should be(
+      Sublist.Superlist)
   }
 
   test("in middle of superlist") {
     pending
-    Sublist.sublist(List(0, 1, 2, 3, 4, 5), List(2, 3)) should be (Sublist.Superlist)
+    Sublist.sublist(List(0, 1, 2, 3, 4, 5), List(2, 3)) should be(
+      Sublist.Superlist)
   }
 
   test("at end of superlist") {
     pending
-    Sublist.sublist(List(0, 1, 2, 3, 4, 5), List(3, 4, 5)) should be (Sublist.Superlist)
+    Sublist.sublist(List(0, 1, 2, 3, 4, 5), List(3, 4, 5)) should be(
+      Sublist.Superlist)
   }
 
   test("first list missing element from second list") {
     pending
-    Sublist.sublist(List(1, 3), List(1, 2, 3)) should be (Sublist.Unequal)
+    Sublist.sublist(List(1, 3), List(1, 2, 3)) should be(Sublist.Unequal)
   }
 
   test("second list missing element from first list") {
     pending
-    Sublist.sublist(List(1, 2, 3), List(1, 3)) should be (Sublist.Unequal)
+    Sublist.sublist(List(1, 2, 3), List(1, 3)) should be(Sublist.Unequal)
   }
 
   test("order matters to a list") {
     pending
-    Sublist.sublist(List(1, 2, 3), List(3, 2, 1)) should be (Sublist.Unequal)
+    Sublist.sublist(List(1, 2, 3), List(3, 2, 1)) should be(Sublist.Unequal)
   }
 
   test("same digits but different numbers") {
     pending
-    Sublist.sublist(List(1, 0, 1), List(10, 1)) should be (Sublist.Unequal)
+    Sublist.sublist(List(1, 0, 1), List(10, 1)) should be(Sublist.Unequal)
   }
-}
+}

data/tracks/scala/exercises/sum-of-multiples/src/test/scala/SumOfMultiplesTest.scala

@@ -1,69 +1,69 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.1.0 */
+/** @version 1.2.0 */
 class SumOfMultiplesTest extends FunSuite with Matchers {
 
   test("multiples of 3 or 5 up to 1") {
-    SumOfMultiples.sum(Set(3, 5), 1) should be (0)
+    SumOfMultiples.sum(Set(3, 5), 1) should be(0)
   }
 
   test("multiples of 3 or 5 up to 4") {
     pending
-    SumOfMultiples.sum(Set(3, 5), 4) should be (3)
+    SumOfMultiples.sum(Set(3, 5), 4) should be(3)
   }
 
   test("multiples of 3 up to 7") {
     pending
-    SumOfMultiples.sum(Set(3), 7) should be (9)
+    SumOfMultiples.sum(Set(3), 7) should be(9)
   }
 
   test("multiples of 3 or 5 up to 10") {
     pending
-    SumOfMultiples.sum(Set(3, 5), 10) should be (23)
+    SumOfMultiples.sum(Set(3, 5), 10) should be(23)
   }
 
   test("multiples of 3 or 5 up to 100") {
     pending
-    SumOfMultiples.sum(Set(3, 5), 100) should be (2318)
+    SumOfMultiples.sum(Set(3, 5), 100) should be(2318)
   }
 
   test("multiples of 3 or 5 up to 1000") {
     pending
-    SumOfMultiples.sum(Set(3, 5), 1000) should be (233168)
+    SumOfMultiples.sum(Set(3, 5), 1000) should be(233168)
   }
 
   test("multiples of 7, 13 or 17 up to 20") {
     pending
-    SumOfMultiples.sum(Set(7, 13, 17), 20) should be (51)
+    SumOfMultiples.sum(Set(7, 13, 17), 20) should be(51)
   }
 
   test("multiples of 4 or 6 up to 15") {
     pending
-    SumOfMultiples.sum(Set(4, 6), 15) should be (30)
+    SumOfMultiples.sum(Set(4, 6), 15) should be(30)
   }
 
   test("multiples of 5, 6 or 8 up to 150") {
     pending
-    SumOfMultiples.sum(Set(5, 6, 8), 150) should be (4419)
+    SumOfMultiples.sum(Set(5, 6, 8), 150) should be(4419)
   }
 
   test("multiples of 5 or 25 up to 51") {
     pending
-    SumOfMultiples.sum(Set(5, 25), 51) should be (275)
+    SumOfMultiples.sum(Set(5, 25), 51) should be(275)
   }
 
   test("multiples of 43 or 47 up to 10000") {
     pending
-    SumOfMultiples.sum(Set(43, 47), 10000) should be (2203160)
+    SumOfMultiples.sum(Set(43, 47), 10000) should be(2203160)
   }
 
   test("multiples of 1 up to 100") {
     pending
-    SumOfMultiples.sum(Set(1), 100) should be (4950)
+    SumOfMultiples.sum(Set(1), 100) should be(4950)
   }
 
   test("multiples of an empty list up to 10000") {
     pending
-    SumOfMultiples.sum(Set(), 10000) should be (0)
+    SumOfMultiples.sum(Set(), 10000) should be(0)
   }
-}
+}