trackler 2.2.1.74 → 2.2.1.75

data/tracks/python/exercises/error-handling/example.py

@@ -1,5 +1,5 @@
 def handle_error_by_throwing_exception():
-    raise Exception()
+    raise Exception("Meaningful message describing the source of the error")
 
 
 def handle_error_by_returning_none(input_data):

data/tracks/python/exercises/etl/README.md

@@ -1,4 +1,4 @@
-# Etl
+# ETL
 
 We are going to do the `Transform` step of an Extract-Transform-Load.
 
@@ -46,6 +46,21 @@ variety of languages, each with its own unique scoring table. For
 example, an "E" is scored at 2 in the Māori-language version of the
 game while being scored at 4 in the Hawaiian-language version.
 
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+
 ## Submitting Exercises
 
 Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.

data/tracks/python/exercises/flatten-array/README.md

@@ -10,6 +10,21 @@ input: [1,[2,3,null,4],[null],5]
 
 output: [1,2,3,4,5]
 
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+
 ## Submitting Exercises
 
 Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.

data/tracks/python/exercises/food-chain/README.md

@@ -63,6 +63,21 @@ I know an old lady who swallowed a horse.
 She's dead, of course!
 ```
 
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+
 ## Submitting Exercises
 
 Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.

data/tracks/python/exercises/forth/README.md

@@ -25,6 +25,21 @@ enough.)
 
 Words are case-insensitive.
 
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+
 ## Submitting Exercises
 
 Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.

data/tracks/python/exercises/forth/example.py

@@ -20,7 +20,7 @@ def evaluate(input_data):
         values.pop(0)
         key = values.pop(0)
         if is_integer(key):
-            raise ValueError()
+            raise ValueError("Integers cannot be redefined")
         defines[key] = values
     stack = []
     input_data = input_data[-1].split()
@@ -38,10 +38,10 @@ def evaluate(input_data):
             elif word == '*':
                 stack.append(stack.pop() * stack.pop())
             elif word == '/':
-                divider = stack.pop()
-                if divider == 0:
-                    raise ZeroDivisionError()
-                stack.append(int(stack.pop() / divider))
+                divisor = stack.pop()
+                if divisor == 0:
+                    raise ZeroDivisionError("Attempted to divide by zero")
+                stack.append(int(stack.pop() / divisor))
             elif word == 'dup':
                 stack.append(stack[-1])
             elif word == 'drop':
@@ -52,9 +52,7 @@ def evaluate(input_data):
             elif word == 'over':
                 stack.append(stack[-2])
             else:
-                raise ValueError()
-        except ZeroDivisionError:
-            raise
+                raise ValueError("{} has not been defined".format(word))
         except IndexError:
-            raise StackUnderflowError()
+            raise StackUnderflowError("Insufficient number of items in stack")
     return stack

data/tracks/python/exercises/forth/forth_test.py

@@ -31,14 +31,24 @@ class ForthAdditionTest(unittest.TestCase):
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["+"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
     def test_errors_if_there_is_only_one_value_on_the_stack(self):
         input_data = ["1 +"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+        except AttributeError:
+            pass
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
 
 class ForthSubtractionTest(unittest.TestCase):
     def test_can_subtract_two_numbers(self):
@@ -48,14 +58,24 @@ class ForthSubtractionTest(unittest.TestCase):
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["-"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
     def test_errors_if_there_is_only_one_value_on_the_stack(self):
         input_data = ["1 -"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+        except AttributeError:
+            pass
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
 
 class ForthMultiplicationTest(unittest.TestCase):
     def test_can_multiply_two_numbers(self):
@@ -65,14 +85,24 @@ class ForthMultiplicationTest(unittest.TestCase):
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["*"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
     def test_errors_if_there_is_only_one_value_on_the_stack(self):
         input_data = ["1 *"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+        except AttributeError:
+            pass
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
 
 class ForthDivisionTest(unittest.TestCase):
     def test_can_divide_two_numbers(self):
@@ -87,19 +117,29 @@ class ForthDivisionTest(unittest.TestCase):
 
     def test_errors_if_dividing_by_zero(self):
         input_data = ["4 0 /"]
-        with self.assertRaises(ZeroDivisionError):
+        with self.assertRaisesWithMessage(ZeroDivisionError):
             evaluate(input_data)
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["/"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
     def test_errors_if_there_is_only_one_value_on_the_stack(self):
         input_data = ["1 /"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+        except AttributeError:
+            pass
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
 
 class ForthCombinedArithmeticTest(unittest.TestCase):
     def test_addition_and_subtraction(self):
@@ -126,9 +166,19 @@ class ForthDupTest(unittest.TestCase):
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["dup"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+        except AttributeError:
+            pass
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
 
 class ForthDropTest(unittest.TestCase):
     def test_removes_the_top_value_on_the_stack_if_it_is_the_only_one(self):
@@ -148,9 +198,19 @@ class ForthDropTest(unittest.TestCase):
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["drop"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+        except AttributeError:
+            pass
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
 
 class ForthSwapTest(unittest.TestCase):
     def test_swaps_only_two_values_on_stack(self):
@@ -170,14 +230,24 @@ class ForthSwapTest(unittest.TestCase):
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["swap"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
     def test_errors_if_there_is_only_one_value_on_the_stack(self):
         input_data = ["1 swap"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+        except AttributeError:
+            pass
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
 
 class ForthOverTest(unittest.TestCase):
     def test_copies_the_second_element_if_there_are_only_two(self):
@@ -197,14 +267,24 @@ class ForthOverTest(unittest.TestCase):
 
     def test_errors_if_there_is_nothing_on_the_stack(self):
         input_data = ["over"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
     def test_errors_if_there_is_only_one_value_on_the_stack(self):
         input_data = ["1 over"]
-        with self.assertRaises(StackUnderflowError):
+        with self.assertRaisesWithMessage(StackUnderflowError):
             evaluate(input_data)
 
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+        except AttributeError:
+            pass
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
 
 class ForthUserDefinedWordsTest(unittest.TestCase):
     def test_can_consist_of_built_in_words(self):
@@ -258,14 +338,24 @@ class ForthUserDefinedWordsTest(unittest.TestCase):
 
     def test_cannot_redefine_numbers(self):
         input_data = [": 1 2 ;"]
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             evaluate(input_data)
 
     def test_errors_if_executing_a_non_existent_word(self):
         input_data = ["foo"]
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             evaluate(input_data)
 
+    # Utility functions
+    def setUp(self):
+        try:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+        except AttributeError:
+            pass
+
+    def assertRaisesWithMessage(self, exception):
+        return self.assertRaisesRegex(exception, r".+")
+
 
 if __name__ == '__main__':
     unittest.main()

data/tracks/python/exercises/gigasecond/README.md

@@ -4,6 +4,21 @@ Calculate the moment when someone has lived for 10^9 seconds.
 
 A gigasecond is 10^9 (1,000,000,000) seconds.
 
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+
 ## Submitting Exercises
 
 Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.

data/tracks/python/exercises/go-counting/README.md

@@ -16,7 +16,7 @@ only horizontal and vertical neighbours count. In the following diagram
 the stones which matter are marked "O" and the stones that don't are
 marked "I" (ignored).  Empty spaces represent empty intersections.
 
-```
+```text
 +----+
 |IOOI|
 |O  O|
@@ -33,12 +33,30 @@ For more information see
 [wikipedia](https://en.wikipedia.org/wiki/Go_%28game%29) or [Sensei's
 Library](http://senseis.xmp.net/).
 
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+
 ## Submitting Exercises
 
 Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
 
 For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
 
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+
 ## Submitting Incomplete Solutions
-It's possible to submit an incomplete solution so you can see how others have completed the
-exercise.
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/python/exercises/grade-school/README.md

@@ -34,6 +34,21 @@ are some additional things you could try:
 Then please share your thoughts in a comment on the submission. Did this
 experiment make the code better? Worse? Did you learn anything from it?
 
+## Exception messages
+
+Sometimes it is necessary to raise an exception. When you do this, you should include a meaningful error message to
+indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. Not
+every exercise will require you to raise an exception, but for those that do, the tests will only pass if you include
+a message.
+
+To raise a message with an exception, just write it as an argument to the exception type. For example, instead of
+`raise Exception`, you shold write:
+
+```python
+raise Exception("Meaningful message indicating the source of the error")
+```
+
+
 ## Submitting Exercises
 
 Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.