trackler 2.0.8.42 → 2.0.8.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad0c8c481adab8fc6597c91e49a145230f5a0e3d
-  data.tar.gz: bf9269a54e783bf01145d450c8712d57eb0d8204
+  metadata.gz: a9834bb8d7cd54e4b2c8e1e26da6932cf1e95cc5
+  data.tar.gz: 21645918c226fde411b8ae99233e4fcd3abe2e97
 SHA512:
-  metadata.gz: dc3576e5ff9be012b404eafa0776795a2aaf6bd09903bf9cf4f42554b9da8cddb6974c92714b867c232cd8476da1fc504de6e90510d59ccca087bf9ab5329a94
-  data.tar.gz: 25537ab8bb99975a7bb6507c4e9153f722912f6d970c2b64481e75fcc9dd61e1456e7517be2b85226242c1b66cb220f3332b8f298626f4188c7728b82b81dcc1
+  metadata.gz: 929126636d31a8a2c0d54e607e5b64c2b131087594b836796e2a9f282dde25d522af1a0174bde3ee6939fc4679b0107dbad40e6982e517636124cd9743dff7f9
+  data.tar.gz: 484e966fda60ece17a4553d9b82e4a5974f2b763acd58369283b5a2f2f3197d931d6e34f4449e41e175c1bb34be8f63d17b574b7d0c65c60048d59e1e4b322c5

data/common/exercises/bracket-push/canonical-data.json

@@ -1,6 +1,6 @@
 {
   "exercise": "bracket-push",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "cases": [
     {
       "description": "paired square brackets",
@@ -26,6 +26,12 @@
       "input": "}{",
       "expected": false
     },
+    {
+      "description": "wrong closing bracket",
+      "property": "isPaired",
+      "input": "{]",
+      "expected": false
+    },
     {
       "description": "paired with whitespace",
       "property": "isPaired",

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.42"
+  VERSION = "2.0.8.43"
 end

data/tracks/c/exercises/react/src/example.c

@@ -20,18 +20,20 @@ struct cb {
 };
 
 struct reactor {
-   struct child *first;
-   struct child *last;
+   struct child *input;
 };
 
 struct cell {
-   struct reactor *reactor;
    int value;
    enum cell_kind kind;
+   struct child *child;
+
    struct cell *input1;
    struct cell *input2;
    compute1 compute1;
    compute2 compute2;
+
+   int last_cb_value;
    struct cb *cb;
    int callbacks_issued;
 };
@@ -41,42 +43,74 @@ struct reactor *create_reactor()
    return calloc(1, sizeof(struct reactor));
 }
 
-void destroy_reactor(struct reactor *r)
+static void destroy_cell(struct cell *c)
 {
-   struct child *child = r->first;
-   while (child) {
-      struct cb *cb = child->cell->cb;
-      while (cb) {
-         struct cb *next_cb = cb->next;
-         free(cb);
-         cb = next_cb;
-      }
-      free(child->cell);
+   struct cb *cb = c->cb;
+   while (cb) {
+      struct cb *next_cb = cb->next;
+      free(cb);
+      cb = next_cb;
+   }
 
+   struct child *child = c->child;
+   while (child) {
       struct child *next = child->next;
+      if (c == child->cell->input1) {
+         // Don't double-free for a compute2 cell.
+         destroy_cell(child->cell);
+      }
       free(child);
       child = next;
    }
+
+   free(c);
+}
+
+void destroy_reactor(struct reactor *r)
+{
+   struct child *input = r->input;
+   while (input) {
+      struct child *next = input->next;
+      destroy_cell(input->cell);
+      free(input);
+      input = next;
+   }
+
    free(r);
 }
 
-static void add_child(struct reactor *r, struct cell *cell)
+#define SUCCESS 1
+#define FAIL 0
+
+static int add_child(struct child **list, struct cell *cell)
 {
    struct child *child = calloc(1, sizeof(struct child));
-   child->cell = cell;
-   if (!r->first) {
-      r->first = child;
-   } else {
-      r->last->next = child;
+   if (!child) {
+      return FAIL;
    }
-   r->last = child;
+   child->cell = cell;
+   child->next = *list;
+   *list = child;
+   return SUCCESS;
+}
+
+static void remove_child(struct child **list)
+{
+   struct child *to_remove = *list;
+   *list = to_remove->next;
+   free(to_remove);
 }
 
 struct cell *create_input_cell(struct reactor *r, int initial_value)
 {
    struct cell *c = calloc(1, sizeof(struct cell));
-   add_child(r, c);
-   c->reactor = r;
+   if (!c) {
+      return NULL;
+   }
+   if (add_child(&r->input, c) != SUCCESS) {
+      free(c);
+      return NULL;
+   }
    c->kind = kind_input;
    c->value = initial_value;
    return c;
@@ -85,30 +119,51 @@ struct cell *create_input_cell(struct reactor *r, int initial_value)
 struct cell *create_compute1_cell(struct reactor *r, struct cell *input,
                                   compute1 compute)
 {
+   (void)r;
    struct cell *c = calloc(1, sizeof(struct cell));
-   add_child(r, c);
-   c->reactor = r;
+   if (!c) {
+      return NULL;
+   }
+   if (add_child(&input->child, c) != SUCCESS) {
+      free(c);
+      return NULL;
+   }
    c->kind = kind_compute1;
    c->input1 = input;
    c->compute1 = compute;
    c->value = compute(get_cell_value(input));
+   c->last_cb_value = c->value;
    return c;
 }
 
 struct cell *create_compute2_cell(struct reactor *r, struct cell *input1,
                                   struct cell *input2, compute2 compute)
 {
+   (void)r;
    struct cell *c = calloc(1, sizeof(struct cell));
-   add_child(r, c);
-   c->reactor = r;
+   if (!c) {
+      return NULL;
+   }
+   if (add_child(&input1->child, c) != SUCCESS) {
+      free(c);
+      return NULL;
+   }
+   if (add_child(&input2->child, c) != SUCCESS) {
+      remove_child(&input1->child);
+      free(c);
+      return NULL;
+   }
    c->kind = kind_compute2;
    c->input1 = input1;
    c->input2 = input2;
    c->compute2 = compute;
    c->value = compute(get_cell_value(input1), get_cell_value(input2));
+   c->last_cb_value = c->value;
    return c;
 }
 
+#define each_child(c) struct child *child = (c)->child; child; child = child->next
+
 int get_cell_value(struct cell *c)
 {
    return c->value;
@@ -131,29 +186,46 @@ static void propagate(struct cell *c)
 
    if (new_value != c->value) {
       c->value = new_value;
-      for (struct cb * cb = c->cb; cb; cb = cb->next) {
-         cb->f(cb->obj, new_value);
+      for (each_child(c)) {
+         propagate(child->cell);
       }
    }
+}
 
+static void fire_callbacks(struct cell *c)
+{
+   if (c->value == c->last_cb_value) {
+      return;
+   }
+   c->last_cb_value = c->value;
+   for (struct cb * cb = c->cb; cb; cb = cb->next) {
+      cb->f(cb->obj, c->value);
+   }
+   for (each_child(c)) {
+      fire_callbacks(child->cell);
+   }
 }
 
 void set_cell_value(struct cell *c, int new_value)
 {
    c->value = new_value;
-   struct reactor *r = c->reactor;
-
-   // We take the very naive route of updating all cells.
-   // Traversing the tree and only updating the cells dependent on the just-changed cell is possible,
-   // but requires much more memory management to make each cell aware of its dependents.
-   for (struct child * child = r->first; child; child = child->next) {
+   for (each_child(c)) {
       propagate(child->cell);
    }
+   for (each_child(c)) {
+      // Why can't we put propagate and fire_callbacks in same for loop?
+      // Because then a compute2 cell might fire its callbacks too early
+      // (before it's seen updates from both of its inputs)!
+      fire_callbacks(child->cell);
+   }
 }
 
 callback_id add_callback(struct cell *c, void *obj, callback f)
 {
    struct cb *cb = calloc(1, sizeof(struct cb));
+   if (!cb) {
+      return -1;
+   }
    cb->id = c->callbacks_issued++;
    cb->next = c->cb;
    cb->obj = obj;

data/tracks/csharp/exercises/zipper/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+This exercise deals with custom equality. For more information see [this page.](http://www.loganfranken.com/blog/687/overriding-equals-in-c-part-1/)

data/tracks/delphi/.github/stale.yml

@@ -0,0 +1 @@
+

data/tracks/go/exercises/bank-account/bank_account_test.go

@@ -1,6 +1,6 @@
 // API:
 //
-// Open(initalDeposit int64) *Account
+// Open(initialDeposit int64) *Account
 // (Account) Close() (payout int64, ok bool)
 // (Account) Balance() (balance int64, ok bool)
 // (Account) Deposit(amount int64) (newBalance int64, ok bool)

data/tracks/go/exercises/variable-length-quantity/example.go

@@ -1,6 +1,6 @@
 package variablelengthquantity
 
-const testVersion = 1
+const testVersion = 2
 
 // EncodeVarint returns the varint encoding of x.
 func EncodeVarint(x uint32) []byte {
@@ -50,9 +50,9 @@ func DecodeVarint(buf []byte) (x uint32, n int) {
 		x = x << 7
 		x |= uint32(b) & 0x7F
 		if (b & 0x80) == 0 {
-			return x, n
+			return x, n + 1
 		}
 	}
 
-	return x, n
+	return x, 0
 }

data/tracks/go/exercises/variable-length-quantity/variable_length_quantity_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 )
 
-const targetTestVersion = 1
+const targetTestVersion = 2
 
 var testCases = []struct {
 	input  []byte
@@ -13,16 +13,16 @@ var testCases = []struct {
 	size   int
 }{
 	0:  {[]byte{0x7F}, 127, 1},
-	1:  {[]byte{0x81, 0x00}, 128, 1},
-	2:  {[]byte{0xC0, 0x00}, 8192, 1},
-	3:  {[]byte{0xFF, 0x7F}, 16383, 1},
-	4:  {[]byte{0x81, 0x80, 0x00}, 16384, 2},
-	5:  {[]byte{0xFF, 0xFF, 0x7F}, 2097151, 2},
-	6:  {[]byte{0x81, 0x80, 0x80, 0x00}, 2097152, 3},
-	7:  {[]byte{0xC0, 0x80, 0x80, 0x00}, 134217728, 3},
-	8:  {[]byte{0xFF, 0xFF, 0xFF, 0x7F}, 268435455, 3},
-	9:  {[]byte{0x82, 0x00}, 256, 1},
-	10: {[]byte{0x81, 0x10}, 144, 1},
+	1:  {[]byte{0x81, 0x00}, 128, 2},
+	2:  {[]byte{0xC0, 0x00}, 8192, 2},
+	3:  {[]byte{0xFF, 0x7F}, 16383, 2},
+	4:  {[]byte{0x81, 0x80, 0x00}, 16384, 3},
+	5:  {[]byte{0xFF, 0xFF, 0x7F}, 2097151, 3},
+	6:  {[]byte{0x81, 0x80, 0x80, 0x00}, 2097152, 4},
+	7:  {[]byte{0xC0, 0x80, 0x80, 0x00}, 134217728, 4},
+	8:  {[]byte{0xFF, 0xFF, 0xFF, 0x7F}, 268435455, 4},
+	9:  {[]byte{0x82, 0x00}, 256, 2},
+	10: {[]byte{0x81, 0x10}, 144, 2},
 }
 
 func TestTestVersion(t *testing.T) {

data/tracks/haskell/config.json

@@ -28,6 +28,12 @@
       "topics": [
       ]
     },
+    {
+      "slug": "pangram",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
     {
       "slug": "run-length-encoding",
       "difficulty": 1,
@@ -60,6 +66,12 @@
         "Maybe"
       ]
     },
+    {
+      "slug": "acronym",
+      "difficulty": 2,
+      "topics": [
+      ]
+    },
     {
       "slug": "hamming",
       "difficulty": 2,
@@ -273,6 +285,13 @@
       "topics": [
       ]
     },
+    {
+      "slug": "bracket-push",
+      "difficulty": 5,
+      "topics": [
+          "Stack"
+      ]
+    },
     {
       "slug": "crypto-square",
       "difficulty": 5,
@@ -491,7 +510,8 @@
       "difficulty": 10,
       "topics": [
         "Define type",
-        "Either"
+        "Either",
+        "Stack"
       ]
     },
     {

data/tracks/haskell/exercises/acronym/examples/success-standard/package.yaml

@@ -0,0 +1,16 @@
+name: acronym
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Acronym
+  source-dirs: src
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - acronym
+      - hspec

data/tracks/haskell/exercises/acronym/examples/success-standard/src/Acronym.hs

@@ -0,0 +1,21 @@
+module Acronym (abbreviate) where
+
+import Data.Char (isAlpha, isUpper, toUpper)
+
+abbreviate :: String -> String
+abbreviate = concatMap initials . words . map replaceNonAlpha
+
+initials :: String -> String
+initials [] = []
+initials (x:xs) = toUpper x : rest
+  where rest = if not $ isAcronym xs
+               then filter isUpper xs
+               else []
+
+isAcronym :: String -> Bool
+isAcronym = all isUpper
+
+replaceNonAlpha :: Char -> Char
+replaceNonAlpha x
+  | isAlpha x = x
+  | otherwise = ' '

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

@@ -0,0 +1,19 @@
+name: acronym
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Acronym
+  source-dirs: src
+  dependencies:
+  # - foo       # List here the packages you
+  # - bar       # want to use in your solution.
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - acronym
+      - hspec

data/tracks/haskell/exercises/acronym/src/Acronym.hs

@@ -0,0 +1,4 @@
+module Acronym (abbreviate) where
+
+abbreviate :: String -> String
+abbreviate xs = error "You need to implement this function."

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

@@ -0,0 +1 @@
+resolver: lts-8.2

data/tracks/haskell/exercises/acronym/test/Tests.hs

@@ -0,0 +1,57 @@
+{-# LANGUAGE RecordWildCards #-}
+
+import Data.Foldable     (for_)
+import Test.Hspec        (Spec, describe, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+
+import Acronym (abbreviate)
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = describe "acronym" $
+          describe "abbreviate" $ for_ cases test
+  where
+    test Case {..} = it description $ abbreviate input `shouldBe` expected
+
+-- Adapted from
+-- Source: exercism/x-common/exercises/acronym/canonical-data.json
+-- Version: 1.0.0
+-- Date: 2017-03-31
+
+data Case = Case { description :: String
+                 , input       :: String
+                 , expected    :: String
+                 }
+
+cases :: [Case]
+cases = [ Case { description = "basic"
+               , input       = "Portable Network Graphics"
+               , expected    = "PNG"
+               }
+        , Case { description = "lowercase words"
+               , input       = "Ruby on Rails"
+               , expected    = "ROR"
+               }
+        , Case { description = "camelcase"
+               , input       = "HyperText Markup Language"
+               , expected    = "HTML"
+               }
+        , Case { description = "punctuation"
+               , input       = "First In, First Out"
+               , expected    = "FIFO"
+               }
+        , Case { description = "all caps words"
+               , input       = "PHP: Hypertext Preprocessor"
+               , expected    = "PHP"
+               }
+        , Case { description = "non-acronym all caps word"
+               , input       = "GNU Image Manipulation Program"
+               , expected    = "GIMP"
+               }
+        , Case { description = "hyphenated"
+               , input       = "Complementary metal-oxide semiconductor"
+               , expected    = "CMOS"
+               }
+        ]

data/tracks/haskell/exercises/bracket-push/examples/success-standard/package.yaml

@@ -0,0 +1,16 @@
+name: bracket-push
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Brackets
+  source-dirs: src
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - bracket-push
+      - hspec

data/tracks/haskell/exercises/bracket-push/examples/success-standard/src/Brackets.hs

@@ -0,0 +1,36 @@
+module Brackets (arePaired) where
+
+data BracketType = Opening | Closing
+data Stack a = Empty | Elem a (Stack a)
+
+push :: Char -> Stack Char -> Stack Char
+push = Elem
+
+pop :: Stack Char -> Stack Char
+pop Empty = Empty
+pop (Elem _ stack) = stack
+
+arePaired :: String -> Bool
+arePaired xs = checkBalance xs Empty
+
+checkBalance :: String -> Stack Char -> Bool
+checkBalance [] Empty = True
+checkBalance [] _ = False
+checkBalance (x:xs) stack =
+  case classify x of
+    Just Opening -> checkBalance xs $ push x stack
+    Just Closing -> (x `closes` stack) && checkBalance xs (pop stack)
+    _            -> checkBalance xs stack
+
+classify :: Char -> Maybe BracketType
+classify x
+  | x `elem` "([{" = Just Opening
+  | x `elem` ")]}" = Just Closing
+  | otherwise      = Nothing
+
+closes :: Char -> Stack Char -> Bool
+closes _ Empty = False
+closes x (Elem y _) =
+  x == ')' && y == '('
+  || x == ']' && y == '['
+  || x == '}' && y == '{'

data/tracks/haskell/exercises/bracket-push/package.yaml

@@ -0,0 +1,19 @@
+name: bracket-push
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Brackets
+  source-dirs: src
+  dependencies:
+  # - foo       # List here the packages you
+  # - bar       # want to use in your solution.
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - bracket-push
+      - hspec

data/tracks/haskell/exercises/bracket-push/src/Brackets.hs

@@ -0,0 +1,4 @@
+module Brackets (arePaired) where
+
+arePaired :: String -> Bool
+arePaired xs = error "You need to implement this function."

data/tracks/haskell/exercises/bracket-push/stack.yaml

@@ -0,0 +1 @@
+resolver: lts-8.2

data/tracks/haskell/exercises/bracket-push/test/Tests.hs

@@ -0,0 +1,85 @@
+{-# LANGUAGE RecordWildCards #-}
+
+import Data.Foldable     (for_)
+import Test.Hspec        (Spec, describe, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+
+import Brackets (arePaired)
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = describe "bracket-push" $
+          describe "isPaired" $ for_ cases test
+  where
+    test Case{..} = it description $ arePaired input `shouldBe` expected
+
+-- Adapted from
+-- Source: exercism/x-common/exercises/bracket-push/canonical-data.json
+-- Version: 1.1.0
+-- Date: 2017-04-07.
+
+data Case = Case { description :: String
+                 , input       :: String
+                 , expected    :: Bool
+                 }
+
+cases :: [Case]
+cases = [ Case { description = "paired square brackets"
+               , input       = "[]"
+               , expected    = True
+               }
+        , Case { description = "empty string"
+               , input       = ""
+               , expected    = True
+               }
+        , Case { description = "unpaired brackets"
+               , input       = "[["
+               , expected    = False
+               }
+        , Case { description = "wrong ordered brackets"
+               , input       = "}{"
+               , expected    = False
+               }
+        , Case { description = "wrong closing brackets"
+               , input       = "{]"
+               , expected    = False
+               }
+        , Case { description = "paired with whitespace"
+               , input       = "{ }"
+               , expected    = True
+               }
+        , Case { description = "simple nested brackets"
+               , input       = "{[]}"
+               , expected    = True
+               }
+        , Case { description = "several paired brackets"
+               , input       = "{}[]"
+               , expected    = True
+               }
+        , Case { description = "paired and nested brackets"
+               , input       = "([{}({}[])])"
+               , expected    = True
+               }
+        , Case { description = "unopened closing brackets"
+               , input       = "{[)][]}"
+               , expected    = False
+               }
+        , Case { description = "unpaired and nested brackets"
+               , input       = "([{])"
+               , expected    = False
+               }
+        , Case { description = "paired and wrong nested brackets"
+               , input       = "[({]})"
+               , expected    = False
+               }
+        , Case { description = "math expression"
+               , input       = "(((185 + 223.85) * 15) - 543)/2"
+               , expected    = True
+               }
+        , Case { description = "complex latex expression"
+               , input       = "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)"
+               , expected    = True
+               }
+        ]

data/tracks/haskell/exercises/pangram/examples/success-standard/package.yaml

@@ -0,0 +1,16 @@
+name: pangram
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Pangram
+  source-dirs: src
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - pangram
+      - hspec

data/tracks/haskell/exercises/pangram/examples/success-standard/src/Pangram.hs

@@ -0,0 +1,7 @@
+module Pangram (isPangram) where
+
+import Data.Char (toLower)
+
+isPangram :: String -> Bool
+isPangram xs = all (`elem` fixedText) ['a'..'z']
+  where fixedText = map toLower xs

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

@@ -0,0 +1,19 @@
+name: pangram
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Pangram
+  source-dirs: src
+  dependencies:
+  # - foo       # List here the packages you
+  # - bar       # want to use in your solution.
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - pangram
+      - hspec

data/tracks/haskell/exercises/pangram/src/Pangram.hs

@@ -0,0 +1,4 @@
+module Pangram (isPangram) where
+
+isPangram :: String -> Bool
+isPangram text = error "You need to implement this function."

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

@@ -0,0 +1 @@
+resolver: lts-8.2

data/tracks/haskell/exercises/pangram/test/Tests.hs

@@ -0,0 +1,65 @@
+{-# LANGUAGE RecordWildCards #-}
+
+import Data.Foldable     (for_)
+import Test.Hspec        (Spec, describe, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+
+import Pangram (isPangram)
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = describe "pangram" $
+          describe "isPangram" $ for_ cases test
+  where
+    test Case{..} = it description $ isPangram input `shouldBe` expected
+
+-- Adapted from
+-- Source: exercism/x-common/exercises/pangram/canonical-data.json
+-- Version: 1.0.0
+-- Date: 2017-03-28.
+
+data Case = Case { description :: String
+                 , input       :: String
+                 , expected    :: Bool
+                 }
+
+cases :: [Case]
+cases = [ Case { description = "sentence empty"
+               , input       = ""
+               , expected    = False
+               }
+        , Case { description = "pangram with only lower case"
+               , input       = "the quick brown fox jumps over the lazy dog"
+               , expected    = True
+               }
+        , Case { description = "missing character 'x'"
+               , input       = "a quick movement of the enemy will jeopardize five gunboats"
+               , expected    = False
+               }
+        , Case { description = "another missing character 'x'"
+               , input       = "the quick brown fish jumps over the lazy dog"
+               , expected    = False
+               }
+        , Case { description = "pangram with underscores"
+               , input       = "the_quick_brown_fox_jumps_over_the_lazy_dog"
+               , expected    = True
+               }
+        , Case { description = "pangram with numbers"
+               , input       = "the 1 quick brown fox jumps over the 2 lazy dogs"
+               , expected    = True
+               }
+        , Case { description = "missing letters replaced by numbers"
+               , input       = "7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog"
+               , expected    = False
+               }
+        , Case { description = "pangram with mixed case and punctuation"
+               , input       = "\"Five quacking Zephyrs jolt my wax bed.\""
+               , expected    = True
+               }
+        , Case { description = "upper and lower case versions of the same character should not be counted separately"
+               , input       = "the quick brown fox jumped over the lazy FOX"
+               , expected    = False
+               }
+        ]

data/tracks/java/exercises/flatten-array/src/test/java/FlattenerTest.java

@@ -7,6 +7,9 @@ import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
 import static org.junit.Assert.assertEquals;
 
+/*
+ * version: 1.1.0
+ */
 public final class FlattenerTest {
 
     private Flattener flattener;
@@ -16,6 +19,18 @@ public final class FlattenerTest {
         flattener = new Flattener();
     }
 
+    @Test
+    public void testFlatListIsPreserved() {
+        assertEquals(
+          asList(0, '1', "two"),
+            flattener.flatten(
+              asList(
+                0,
+                '1',
+                "two")));
+    }
+
+    @Ignore
     @Test
     public void testASingleLevelOfNestingWithNoNulls() {
         assertEquals(

data/tracks/java/exercises/pig-latin/src/example/java/{PigLatin.java → PigLatinTranslator.java}

@@ -2,7 +2,7 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class PigLatin {
+public class PigLatinTranslator {
 
     public static final String AY = "ay";
     public static final String THR = "thr";
@@ -15,7 +15,7 @@ public class PigLatin {
     public static final String YT = "yt";
     public static final String VOWELS_REGEX = "[aeiou]";
 
-    public static String translate(String sentence) {
+    public String translate(String sentence) {
         List<String> translatedWords = Arrays.asList(sentence.split(" "))
                 .stream()
                 .map(x -> translateWord(x))
@@ -24,7 +24,7 @@ public class PigLatin {
         return String.join(" ", translatedWords);
     }
 
-    private static String translateWord(String word) {
+    private String translateWord(String word) {
         if (wordStartsWithVowelLike(word)) {
             return word + AY;
         }
@@ -44,16 +44,16 @@ public class PigLatin {
         return word.substring(1) + word.toCharArray()[0] + AY;
     }
 
-    private static boolean wordStartsWithVowelLike(String word) {
+    private boolean wordStartsWithVowelLike(String word) {
         return word.startsWith(YT) || word.startsWith(XR) || word.substring(0, 1).matches(VOWELS_REGEX);
     }
 
-    private static boolean wordStartsWithPrefixes(String word, String... prefixes) {
-        return Arrays.asList(prefixes).stream()
-                .anyMatch(x -> word.startsWith(x));
+    private boolean wordStartsWithPrefixes(String word, String... prefixes) {
+        return Arrays.stream(prefixes)
+                .anyMatch(word::startsWith);
     }
 
-    private static boolean wordStartsWithConsonantAndQu(String word) {
+    private boolean wordStartsWithConsonantAndQu(String word) {
         return word.substring(1).startsWith(QU);
     }
 }

data/tracks/java/exercises/pig-latin/src/test/java/{PigLatinTest.java → PigLatinTranslatorTest.java}

@@ -1,5 +1,4 @@
 import org.junit.Test;
-import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
@@ -9,7 +8,7 @@ import java.util.Collection;
 import static org.junit.Assert.assertEquals;
 
 @RunWith(Parameterized.class)
-public class PigLatinTest {
+public class PigLatinTranslatorTest {
 
     private String englishPhrase;
     private String pigLatinTranslation;
@@ -59,14 +58,14 @@ public class PigLatinTest {
         });
     }
 
-    public PigLatinTest(String englishPhrase, String pigLatinTranslation) {
+    public PigLatinTranslatorTest(String englishPhrase, String pigLatinTranslation) {
         this.englishPhrase = englishPhrase;
         this.pigLatinTranslation = pigLatinTranslation;
     }
 
-
     @Test
     public void test() {
-        assertEquals(pigLatinTranslation, PigLatin.translate(englishPhrase));
+        assertEquals(pigLatinTranslation, new PigLatinTranslator().translate(englishPhrase));
     }
+
 }

data/tracks/java/exercises/prime-factors/src/example/java/{PrimeFactors.java → PrimeFactorsCalculator.java}

@@ -1,9 +1,9 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public class PrimeFactors {
+public class PrimeFactorsCalculator {
 
-    public static List<Long> getForNumber(long number) {
+    public List<Long> calculatePrimeFactorsOf(long number) {
         List<Long> primes = new ArrayList<>();
         long divisor = 2;
 

data/tracks/java/exercises/prime-factors/src/test/java/{PrimeFactorsTest.java → PrimeFactorsCalculatorTest.java}

@@ -1,17 +1,17 @@
 import org.junit.Test;
-import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 
 import static org.junit.Assert.assertEquals;
 
 @RunWith(Parameterized.class)
-public class PrimeFactorsTest {
+public class PrimeFactorsCalculatorTest {
 
     private long input;
     private List<Long> expectedOutput;
@@ -19,9 +19,9 @@ public class PrimeFactorsTest {
     @Parameters(name="Prime factors of {0} = {1}")
     public static Collection<Object[]> data() {
         return Arrays.asList(new Object[][]{
-                {1L, Arrays.asList()},
-                {2L, Arrays.asList(2L)},
-                {3L, Arrays.asList(3L)},
+                {1L, Collections.emptyList()},
+                {2L, Collections.singletonList(2L)},
+                {3L, Collections.singletonList(3L)},
                 {4L, Arrays.asList(2L, 2L)},
                 {6L, Arrays.asList(2L, 3L)},
                 {8L, Arrays.asList(2L, 2L, 2L)},
@@ -33,14 +33,14 @@ public class PrimeFactorsTest {
         });
     }
 
-    public PrimeFactorsTest(long input, List<Long> expectedOutput) {
+    public PrimeFactorsCalculatorTest(long input, List<Long> expectedOutput) {
         this.input = input;
         this.expectedOutput = expectedOutput;
     }
 
-
     @Test
     public void test() {
-        assertEquals(expectedOutput, PrimeFactors.getForNumber(input));
+        assertEquals(expectedOutput, new PrimeFactorsCalculator().calculatePrimeFactorsOf(input));
     }
+
 }

data/tracks/python/exercises/allergies/allergies_test.py

@@ -2,8 +2,14 @@ import unittest
 
 from allergies import Allergies
 
+# Python 2/3 compatibility
+if not hasattr(unittest.TestCase, 'assertCountEqual'):
+    unittest.TestCase.assertCountEqual = unittest.TestCase.assertItemsEqual
 
-class AllergiesTests(unittest.TestCase):
+
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
+class AllergiesTests():
     def test_no_allergies_means_not_allergic(self):
         allergies = Allergies(0)
         self.assertFalse(allergies.is_allergic_to('peanuts'))
@@ -13,7 +19,7 @@ class AllergiesTests(unittest.TestCase):
     def test_is_allergic_to_eggs(self):
         self.assertTrue(Allergies(1).is_allergic_to('eggs'))
 
-    def test_has_the_right_allergies(self):
+    def test_allergic_to_eggs_in_addition_to_other_stuff(self):
         allergies = Allergies(5)
         self.assertTrue(allergies.is_allergic_to('eggs'))
         self.assertTrue(allergies.is_allergic_to('shellfish'))
@@ -22,19 +28,43 @@ class AllergiesTests(unittest.TestCase):
     def test_no_allergies_at_all(self):
         self.assertEqual(Allergies(0).lst, [])
 
+    def test_allergic_to_just_eggs(self):
+        self.assertEqual(Allergies(1).lst, ['eggs'])
+
     def test_allergic_to_just_peanuts(self):
         self.assertEqual(Allergies(2).lst, ['peanuts'])
 
+    def test_allergic_to_just_strawberries(self):
+        self.assertEqual(Allergies(8).lst, ['strawberries'])
+
+    def test_allergic_to_eggs_and_peanuts(self):
+        self.assertCountEqual(Allergies(3).lst, ['eggs', 'peanuts'])
+
+    def test_allergic_to_more_than_eggs_but_not_peanuts(self):
+        self.assertCountEqual(Allergies(5).lst, ['eggs', 'shellfish'])
+
+    def test_allergic_to_lots_of_stuff(self):
+        self.assertCountEqual(
+            Allergies(248).lst,
+            ['strawberries', 'tomatoes', 'chocolate', 'pollen', 'cats'])
+
     def test_allergic_to_everything(self):
-        self.assertEqual(
-            sorted(Allergies(255).lst),
-            sorted(('eggs peanuts shellfish strawberries tomatoes '
-                    'chocolate pollen cats').split()))
+        self.assertCountEqual(
+            Allergies(255).lst, [
+                'eggs', 'peanuts', 'shellfish', 'strawberries', 'tomatoes',
+                'chocolate', 'pollen', 'cats'
+            ])
 
-    @unittest.skip('Extra Credit: Passes with a specific type of solution')
-    def test_ignore_non_allergen_score_parts(self):
+    def test_ignore_non_allergen_score_parts_only_eggs(self):
         self.assertEqual(Allergies(257).lst, ['eggs'])
 
+    def test_ignore_non_allergen_score_parts(self):
+        self.assertCountEqual(
+            Allergies(509).lst, [
+                'eggs', 'shellfish', 'strawberries', 'tomatoes', 'chocolate',
+                'pollen', 'cats'
+            ])
+
 
 if __name__ == '__main__':
     unittest.main()

data/tracks/python/exercises/pig-latin/pig_latin_test.py

@@ -3,6 +3,8 @@ import unittest
 from pig_latin import translate
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class PigLatinTests(unittest.TestCase):
     def test_word_beginning_with_a(self):
         self.assertEqual(translate("apple"), "appleay")
@@ -10,19 +12,40 @@ class PigLatinTests(unittest.TestCase):
     def test_word_beginning_with_e(self):
         self.assertEqual(translate("ear"), "earay")
 
+    def test_word_beginning_with_i(self):
+        self.assertEqual(translate("igloo"), "iglooay")
+
+    def test_word_beginning_with_o(self):
+        self.assertEqual(translate("object"), "objectay")
+
+    def test_word_beginning_with_u(self):
+        self.assertEqual(translate("under"), "underay")
+
+    def test_word_beginning_with_a_vowel_and_followed_by_a_qu(self):
+        self.assertEqual(translate("equal"), "equalay")
+
     def test_word_beginning_with_p(self):
         self.assertEqual(translate("pig"), "igpay")
 
     def test_word_beginning_with_k(self):
         self.assertEqual(translate("koala"), "oalakay")
 
+    def test_word_beginning_with_y(self):
+        self.assertEqual(translate("yellow"), "ellowyay")
+
+    def test_word_beginning_with_x(self):
+        self.assertEqual(translate("xenon"), "enonxay")
+
+    def test_word_beginning_with_q_without_a_following_u(self):
+        self.assertEqual(translate("qat"), "atqay")
+
     def test_word_beginning_with_ch(self):
         self.assertEqual(translate("chair"), "airchay")
 
     def test_word_beginning_with_qu(self):
         self.assertEqual(translate("queen"), "eenquay")
 
-    def test_word_beginning_with_squ(self):
+    def test_word_beginning_with_qu_and_a_preceding_consonant(self):
         self.assertEqual(translate("square"), "aresquay")
 
     def test_word_beginning_with_th(self):
@@ -34,21 +57,15 @@ class PigLatinTests(unittest.TestCase):
     def test_word_beginning_with_sch(self):
         self.assertEqual(translate("school"), "oolschay")
 
-    def test_translates_phrase(self):
-        self.assertEqual(translate("quick fast run"), "ickquay astfay unray")
-
-    def test_word_beginning_with_ye(self):
-        self.assertEqual(translate("yellow"), "ellowyay")
-
     def test_word_beginning_with_yt(self):
         self.assertEqual(translate("yttria"), "yttriaay")
 
-    def test_word_beginning_with_xe(self):
-        self.assertEqual(translate("xenon"), "enonxay")
-
     def test_word_beginning_with_xr(self):
         self.assertEqual(translate("xray"), "xrayay")
 
+    def test_a_whole_phrase(self):
+        self.assertEqual(translate("quick fast run"), "ickquay astfay unray")
+
 
 if __name__ == '__main__':
     unittest.main()

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.8.42
+  version: 2.0.8.43
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-06 00:00:00.000000000 Z
+date: 2017-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -1860,6 +1860,7 @@ files:
 - tracks/csharp/exercises/zebra-puzzle/ZebraPuzzle.csproj
 - tracks/csharp/exercises/zebra-puzzle/ZebraPuzzleTest.cs
 - tracks/csharp/exercises/zipper/Example.cs
+- tracks/csharp/exercises/zipper/HINTS.md
 - tracks/csharp/exercises/zipper/Zipper.cs
 - tracks/csharp/exercises/zipper/Zipper.csproj
 - tracks/csharp/exercises/zipper/ZipperTest.cs
@@ -1912,6 +1913,7 @@ files:
 - tracks/csharp/generators/generate.sh
 - tracks/csharp/img/icon.png
 - tracks/delphi/.git
+- tracks/delphi/.github/stale.yml
 - tracks/delphi/.gitignore
 - tracks/delphi/.travis.yml
 - tracks/delphi/LICENSE
@@ -3669,6 +3671,12 @@ files:
 - tracks/haskell/exercises/accumulate/src/Accumulate.hs
 - tracks/haskell/exercises/accumulate/stack.yaml
 - tracks/haskell/exercises/accumulate/test/Tests.hs
+- tracks/haskell/exercises/acronym/examples/success-standard/package.yaml
+- tracks/haskell/exercises/acronym/examples/success-standard/src/Acronym.hs
+- tracks/haskell/exercises/acronym/package.yaml
+- tracks/haskell/exercises/acronym/src/Acronym.hs
+- tracks/haskell/exercises/acronym/stack.yaml
+- tracks/haskell/exercises/acronym/test/Tests.hs
 - tracks/haskell/exercises/all-your-base/examples/success-standard/package.yaml
 - tracks/haskell/exercises/all-your-base/examples/success-standard/src/Base.hs
 - tracks/haskell/exercises/all-your-base/package.yaml
@@ -3744,6 +3752,12 @@ files:
 - tracks/haskell/exercises/bowling/src/Bowling.hs
 - tracks/haskell/exercises/bowling/stack.yaml
 - tracks/haskell/exercises/bowling/test/Tests.hs
+- tracks/haskell/exercises/bracket-push/examples/success-standard/package.yaml
+- tracks/haskell/exercises/bracket-push/examples/success-standard/src/Brackets.hs
+- tracks/haskell/exercises/bracket-push/package.yaml
+- tracks/haskell/exercises/bracket-push/src/Brackets.hs
+- tracks/haskell/exercises/bracket-push/stack.yaml
+- tracks/haskell/exercises/bracket-push/test/Tests.hs
 - tracks/haskell/exercises/change/examples/success-standard/package.yaml
 - tracks/haskell/exercises/change/examples/success-standard/src/Change.hs
 - tracks/haskell/exercises/change/package.yaml
@@ -3959,6 +3973,12 @@ files:
 - tracks/haskell/exercises/palindrome-products/src/Palindromes.hs
 - tracks/haskell/exercises/palindrome-products/stack.yaml
 - tracks/haskell/exercises/palindrome-products/test/Tests.hs
+- tracks/haskell/exercises/pangram/examples/success-standard/package.yaml
+- tracks/haskell/exercises/pangram/examples/success-standard/src/Pangram.hs
+- tracks/haskell/exercises/pangram/package.yaml
+- tracks/haskell/exercises/pangram/src/Pangram.hs
+- tracks/haskell/exercises/pangram/stack.yaml
+- tracks/haskell/exercises/pangram/test/Tests.hs
 - tracks/haskell/exercises/parallel-letter-frequency/HINTS.md
 - tracks/haskell/exercises/parallel-letter-frequency/examples/success-standard/package.yaml
 - tracks/haskell/exercises/parallel-letter-frequency/examples/success-standard/src/Frequency.hs
@@ -4448,13 +4468,13 @@ files:
 - tracks/java/exercises/phone-number/src/main/java/.keep
 - tracks/java/exercises/phone-number/src/test/java/PhoneNumberTest.java
 - tracks/java/exercises/pig-latin/build.gradle
-- tracks/java/exercises/pig-latin/src/example/java/PigLatin.java
+- tracks/java/exercises/pig-latin/src/example/java/PigLatinTranslator.java
 - tracks/java/exercises/pig-latin/src/main/java/.keep
-- tracks/java/exercises/pig-latin/src/test/java/PigLatinTest.java
+- tracks/java/exercises/pig-latin/src/test/java/PigLatinTranslatorTest.java
 - tracks/java/exercises/prime-factors/build.gradle
-- tracks/java/exercises/prime-factors/src/example/java/PrimeFactors.java
+- tracks/java/exercises/prime-factors/src/example/java/PrimeFactorsCalculator.java
 - tracks/java/exercises/prime-factors/src/main/java/.keep
-- tracks/java/exercises/prime-factors/src/test/java/PrimeFactorsTest.java
+- tracks/java/exercises/prime-factors/src/test/java/PrimeFactorsCalculatorTest.java
 - tracks/java/exercises/pythagorean-triplet/build.gradle
 - tracks/java/exercises/pythagorean-triplet/src/example/java/PythagoreanTriplet.java
 - tracks/java/exercises/pythagorean-triplet/src/main/java/PythagoreanTriplet.java
@@ -7036,6 +7056,7 @@ files:
 - tracks/ruby/.git
 - tracks/ruby/.github/ISSUE_TEMPLATE.md
 - tracks/ruby/.github/PULL_REQUEST_TEMPLATE.md
+- tracks/ruby/.github/stale.yml
 - tracks/ruby/.gitignore
 - tracks/ruby/.rubocop.yml
 - tracks/ruby/.travis.yml