trackler 2.2.1.74 → 2.2.1.75

data/tracks/python/exercises/saddle-points/saddle_points_test.py

@@ -38,9 +38,19 @@ class SaddlePointTest(unittest.TestCase):
 
     def test_irregular_matrix(self):
         inp = [[3, 2, 1], [0, 1], [2, 1, 0]]
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             saddle_points(inp)
 
+    # 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/say/README.md

@@ -62,6 +62,21 @@ Use _and_ (correctly) when spelling out the number in English:
 - 1002 becomes "one thousand and two".
 - 1323 becomes "one thousand three hundred and twenty-three".
 
+## 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/say/say_test.py

@@ -64,13 +64,23 @@ class SayTest(unittest.TestCase):
                                 "one hundred and twenty-three"))
 
     def test_number_to_large(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             say(1e12)
 
     def test_number_negative(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             say(-1)
 
+    # 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/scale-generator/README.md

@@ -55,6 +55,21 @@ Here is a table of pitches with the names of their interval distance from the to
 |        |         | Dim 3rd | Aug 2nd | Dim 4th |         | Aug 4th | Dim 5th | Aug 5th | Dim 7th | Aug 6th | Dim 8ve |        |
 |        |         |         |         |         |         | Dim 5th |         |         |         |         |         |        |
 
+## 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/scale-generator/example.py

@@ -13,8 +13,8 @@ class Scale(object):
         self.name = self.tonic + ' ' + scale_name
         self.pattern = pattern
         self.chromatic_scale = (self.FLAT_CHROMATIC_SCALE
-                                if tonic in self.FLAT_KEYS else
-                                self.CHROMATIC_SCALE)
+                                if tonic in self.FLAT_KEYS
+                                else self.CHROMATIC_SCALE)
         self.pitches = self._assign_pitches()
 
     def _assign_pitches(self):
@@ -27,7 +27,7 @@ class Scale(object):
             pitches.append(scale[last_index])
             last_index += self.ASCENDING_INTERVALS.index(interval) + 1
         if pitches[0] != scale[last_index % len(scale)]:
-            raise ValueError()
+            raise ValueError("Interval is broken")
         return pitches
 
     def _reorder_chromatic_scale(self):

data/tracks/python/exercises/scale-generator/scale_generator_test.py

@@ -116,9 +116,19 @@ class ScaleGeneratorTest(unittest.TestCase):
         self.assertEqual(expected, actual)
 
     def test_brokeninterval(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             Scale('G', 'enigmatic', 'mAMMMmM')
 
+    # 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/scrabble-score/README.md

@@ -39,6 +39,21 @@ And to total:
 - You can play a double or a triple letter.
 - You can play a double or a triple word.
 
+## 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/secret-handshake/README.md

@@ -28,6 +28,21 @@ Given the input 19, the function would return the array
 Notice that the addition of 16 (10000 in binary)
 has caused the array to be reversed.
 
+## 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.
@@ -39,7 +54,7 @@ please see the [help page](http://exercism.io/languages/python).
 
 ## Source
 
-Bert, in Mary Poppins [http://www.imdb.com/character/ch0011238/quotes](http://www.imdb.com/character/ch0011238/quotes)
+Bert, in Mary Poppins http://www.imdb.com/title/tt0058331/quotes/qt0437047
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -20,6 +20,21 @@ whatever you get.
 Note that these series are only required to occupy *adjacent positions*
 in the input; the digits need not be *numerically consecutive*.
 
+## 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/series/series_test.py

@@ -37,13 +37,23 @@ class SeriesTest(unittest.TestCase):
             [[0, 1, 2, 3, 4]], )
 
     def test_overly_long_slice(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             slices("012", 4)
 
     def test_overly_short_slice(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             slices("01234", 0)
 
+    # 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/sieve/README.md

@@ -27,6 +27,21 @@ Notice that this is a very specific algorithm, and the tests don't check
 that you've implemented the algorithm, only that you've come up with the
 correct list of primes.
 
+## 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/simple-cipher/.meta/hints.md

@@ -3,14 +3,14 @@
 Python, as of version 3.6, includes two different random modules.
 
 The module called `random` is pseudo-random, meaning it does not generate
-true randomness, but follows an algorithm that simulates randomness. 
-Since random numbers are generated through a known algorithm, they are not truly random. 
+true randomness, but follows an algorithm that simulates randomness.
+Since random numbers are generated through a known algorithm, they are not truly random.
 
-The `random` module is not correctly suited for cryptography and should not be used, 
-precisely because it is pseudo-random. 
+The `random` module is not correctly suited for cryptography and should not be used,
+precisely because it is pseudo-random.
 
 For this reason, in version 3.6, Python introduced the `secrets` module, which generates
-cryptographically strong random numbers that provide the greater security required for cryptography. 
+cryptographically strong random numbers that provide the greater security required for cryptography.
 
-Since this is only an exercise, `random` is fine to use, but note that **it would be 
+Since this is only an exercise, `random` is fine to use, but note that **it would be
 very insecure if actually used for cryptography.**

data/tracks/python/exercises/simple-cipher/README.md

@@ -65,7 +65,7 @@ If someone doesn't submit a key at all, generate a truly random key of
 at least 100 characters in length, accessible via Cipher#key (the #
 syntax means instance variable)
 
-If the key submitted has capital letters or numbers, throw a
+If the key submitted has capital letters or numbers, raise a
 ValueError with a message to that effect.
 
 ## Extensions
@@ -100,6 +100,22 @@ cryptographically strong random numbers that provide the greater security requir
 Since this is only an exercise, `random` is fine to use, but note that **it would be
 very insecure if actually used for cryptography.**
 
+
+## 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/simple-cipher/simple_cipher_test.py

@@ -68,11 +68,21 @@ class CipherTest(unittest.TestCase):
                         'All items in the key must be chars and lowercase!')
 
     def test_cipher_wrong_key(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             Cipher('a1cde')
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             Cipher('aBcde')
 
+    # 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/simple-linked-list/{hints.md → .meta/hints.md}

@@ -1,10 +1,10 @@
-## Hints
-
-To support `list()`, see [implementing an iterator for a class.](https://docs.python.org/3/tutorial/classes.html#iterators)
-
-Additionally, note that Python2's `next()` has been replaced by `__next__()` in Python3. For dual compatibility, `next()` can be implemented as:
-
-```Python
-def next(self):
-    return self.__next__()
-```
+## Hints
+
+To support `list()`, see [implementing an iterator for a class.](https://docs.python.org/3/tutorial/classes.html#iterators)
+
+Additionally, note that Python2's `next()` has been replaced by `__next__()` in Python3. For dual compatibility, `next()` can be implemented as:
+
+```Python
+def next(self):
+    return self.__next__()
+```

data/tracks/python/exercises/simple-linked-list/README.md

@@ -32,6 +32,22 @@ def next(self):
     return self.__next__()
 ```
 
+
+## 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/simple-linked-list/example.py

@@ -42,7 +42,7 @@ class LinkedList(object):
 
     def head(self):
         if self._head is None:
-            raise EmptyListException()
+            raise EmptyListException("The list is empty")
         return self._head
 
     def push(self, value):
@@ -53,7 +53,7 @@ class LinkedList(object):
 
     def pop(self):
         if self._head is None:
-            raise EmptyListException()
+            raise EmptyListException("The list is empty")
         self._len -= 1
         ret = self._head.value()
         self._head = self._head.next()

data/tracks/python/exercises/simple-linked-list/simple_linked_list_test.py

@@ -20,7 +20,7 @@ class LinkedListTest(unittest.TestCase):
 
     def test_error_on_empty_list_head(self):
         sut = LinkedList()
-        with self.assertRaises(EmptyListException):
+        with self.assertRaisesWithMessage(EmptyListException):
             sut.head()
 
     def test_singleton_list_has_head(self):
@@ -51,12 +51,12 @@ class LinkedListTest(unittest.TestCase):
     def test_pop_from_singleton_list_removes_head(self):
         sut = LinkedList([1])
         self.assertEqual(sut.pop(), 1)
-        with self.assertRaises(EmptyListException):
+        with self.assertRaisesWithMessage(EmptyListException):
             sut.head()
 
     def test_error_on_empty_list_pop(self):
         sut = LinkedList()
-        with self.assertRaises(EmptyListException):
+        with self.assertRaisesWithMessage(EmptyListException):
             sut.pop()
 
     def test_push_and_pop(self):
@@ -107,6 +107,16 @@ class LinkedListTest(unittest.TestCase):
         sut = LinkedList([1, 2, 3])
         self.assertEqual(list(sut.reversed()), [1, 2, 3])
 
+    # 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/space-age/README.md

@@ -17,6 +17,21 @@ be able to say that they're 31.69 Earth-years old.
 If you're wondering why Pluto didn't make the cut, go watch [this
 youtube video](http://www.youtube.com/watch?v=Z_2gbGXzFbs).
 
+## 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.