trackler 2.2.1.74 → 2.2.1.75

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

@@ -1,5 +1,7 @@
 # Markdown
 
+Refactor a Markdown parser.
+
 The markdown exercise is a refactoring exercise. There is code that parses a
 given string with [Markdown
 syntax](https://guides.github.com/features/mastering-markdown/) and returns the
@@ -12,6 +14,21 @@ It would be helpful if you made notes of what you did in your refactoring in
 comments so reviewers can see that, but it isn't strictly necessary. The most
 important thing is to make the code better!
 
+## 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.
@@ -21,5 +38,6 @@ For example, if you're submitting `bob.py` for the Bob exercise, the submit comm
 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.

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

@@ -40,6 +40,21 @@ And its columns:
 - 8, 3, 6
 - 7, 2, 7
 
+## 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/meetup/README.md

@@ -2,25 +2,44 @@
 
 Calculate the date of meetups.
 
-Typically meetups happen on the same day of the week.  In this exercise, you will take
-a description of a meetup date, and return the actual meetup date.
+Typically meetups happen on the same day of the week.  In this exercise, you
+will take a description of a meetup date, and return the actual meetup date.
 
 Examples of general descriptions are:
 
-- the first Monday of January 2017
-- the third Tuesday of January 2017
-- the Wednesteenth of January 2017
-- the last Thursday of January 2017
+- The first Monday of January 2017
+- The third Tuesday of January 2017
+- The wednesteenth of January 2017
+- The last Thursday of January 2017
 
-Note that "Monteenth", "Tuesteenth", etc are all made up words. There
-was a meetup whose members realized that there are exactly 7 numbered days in a month that
-end in '-teenth'. Therefore, one is guaranteed that each day of the week
+The descriptors you are expected to parse are:
+first, second, third, fourth, fifth, last, monteenth, tuesteenth, wednesteenth,
+thursteenth, friteenth, saturteenth, sunteenth
+
+Note that "monteenth", "tuesteenth", etc are all made up words. There was a
+meetup whose members realized that there are exactly 7 numbered days in a month
+that end in '-teenth'. Therefore, one is guaranteed that each day of the week
 (Monday, Tuesday, ...) will have exactly one date that is named with '-teenth'
 in every month.
 
-Given examples of a meetup dates, each containing a month, day, year, and descriptor
-(first, second, teenth, etc), calculate the date of the actual meetup.
-For example, if given "First Monday of January 2017", the correct meetup date is 2017/1/2
+Given examples of a meetup dates, each containing a month, day, year, and
+descriptor calculate the date of the actual meetup.  For example, if given
+"The first Monday of January 2017", the correct meetup date is 2017/1/2.
+
+## 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
 

data/tracks/python/exercises/meetup/meetup_test.py

@@ -399,9 +399,19 @@ class MeetupTest(unittest.TestCase):
             meetup_day(2015, 3, 'Monday', '5th'), date(2015, 3, 30))
 
     def test_nonexistent_fifth_monday_of_february_2015(self):
-        with self.assertRaises(MeetupDayException):
+        with self.assertRaisesWithMessage(MeetupDayException):
             meetup_day(2015, 2, 'Monday', '5th')
 
+    # 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/minesweeper/README.md

@@ -26,6 +26,21 @@ into this:
     | 111 |
     +-----+
 
+## 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/minesweeper/minesweeper_test.py

@@ -139,14 +139,24 @@ class MinesweeperTest(unittest.TestCase):
         inp = [" ",
                "*  ",
                "  "]
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             board(inp)
 
     def test_invalid_char(self):
         inp = ["X  * "]
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             board(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/nth-prime/README.md

@@ -8,6 +8,21 @@ the 6th prime is 13.
 If your language provides methods in the standard library to deal with prime
 numbers, pretend they don't exist and implement them yourself.
 
+## 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/nth-prime/nth_prime_test.py

@@ -19,7 +19,7 @@ class NthPrimeTests(unittest.TestCase):
         self.assertEqual(nth_prime(10001), 104743)
 
     def test_there_is_no_zeroth_prime(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             nth_prime(0)
 
     # additional track specific test
@@ -28,6 +28,16 @@ class NthPrimeTests(unittest.TestCase):
                           37, 41, 43, 47, 53, 59, 61, 67, 71],
                          [nth_prime(n) for n in range(1, 21)])
 
+    # 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/nucleotide-count/README.md

@@ -2,8 +2,8 @@
 
 Given a single stranded DNA string, compute how many times each nucleotide occurs in the string.
 
-The genetic language of every living thing on the planet is DNA. 
-DNA is a large molecule that is built from an extremely long sequence of individual elements called nucleotides. 
+The genetic language of every living thing on the planet is DNA.
+DNA is a large molecule that is built from an extremely long sequence of individual elements called nucleotides.
 4 types exist in DNA and these differ only slightly and can be represented as the following symbols: 'A' for adenine, 'C' for cytosine, 'G' for guanine, and 'T' thymine.
 
 Here is an analogy:
@@ -12,6 +12,21 @@ Here is an analogy:
 - legos are to lego houses as
 - words are to sentences as...
 
+## 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/nucleotide-count/nucleotide_count_test.py

@@ -28,7 +28,7 @@ class DNATest(unittest.TestCase):
         self.assertEqual(count('GGGGGTAACCCGG', 'T'), 1)
 
     def test_validates_nucleotides(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             count("GACT", 'X')
 
     def test_counts_all_nucleotides(self):
@@ -37,6 +37,16 @@ class DNATest(unittest.TestCase):
         expected = {'A': 20, 'T': 21, 'G': 17, 'C': 12}
         self.assertEqual(nucleotide_counts(dna), expected)
 
+    # 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/ocr-numbers/README.md

@@ -1,4 +1,4 @@
-# Ocr Numbers
+# OCR Numbers
 
 Given a 3 x 4 grid of pipes, underscores, and spaces, determine which number is
 represented, or whether it is garbled.
@@ -78,6 +78,21 @@ Update your program to handle multiple numbers, one per line. When converting se
 
 Is converted to "123,456,789"
 
+## 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/ocr-numbers/ocr_numbers_test.py

@@ -33,13 +33,13 @@ class OcrTest(unittest.TestCase):
                                   "   "]), '?')
 
     def test_line_number_not_multiple_of_four(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             convert([" _ ",
                      "| |",
                      "   "])
 
     def test_col_number_not_multiple_of_three(self):
-        with self.assertRaises(ValueError):
+        with self.assertRaisesWithMessage(ValueError):
             convert(["    ",
                      "   |",
                      "   |",
@@ -137,6 +137,16 @@ class OcrTest(unittest.TestCase):
         ]
         self.assertEqual(convert(input_grid), "123,456,789")
 
+    # 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/octal/README.md

@@ -46,6 +46,21 @@ So:
  = 155
 ```
 
+## 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/octal/octal_test.py

@@ -29,17 +29,30 @@ class OctalTest(unittest.TestCase):
         self.assertEqual(parse_octal("1234567"), 342391)
 
     def test_8_is_seen_as_invalid(self):
-        self.assertRaises(ValueError, parse_octal, "8")
+        with self.assertRaisesWithMessage(ValueError):
+            parse_octal("8")
 
     def test_invalid_octal_is_recognized(self):
-        self.assertRaises(ValueError, parse_octal, "carrot")
+        with self.assertRaisesWithMessage(ValueError):
+            parse_octal("carrot")
 
     def test_6789_is_seen_as_invalid(self):
-        self.assertRaises(ValueError, parse_octal, "6789")
+        with self.assertRaisesWithMessage(ValueError):
+            parse_octal("6789")
 
     def test_valid_octal_formatted_string_011_is_decimal_9(self):
         self.assertEqual(parse_octal("011"), 9)
 
+    # 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/palindrome-products/README.md

@@ -9,7 +9,7 @@ Given a range of numbers, find the largest and smallest palindromes which
 are products of numbers within that range.
 
 Your solution should return the largest and smallest palindromes, along with the
-factors of each within the range. If the largest or smallest palindrome has more 
+factors of each within the range. If the largest or smallest palindrome has more
 than one pair of factors within the range, then return all the pairs.
 
 ## Example 1
@@ -32,6 +32,21 @@ Given the range `[10, 99]` (both inclusive)...
 The smallest palindrome product is `121`. Its factors are `(11, 11)`.
 The largest palindrome product is `9009`. Its factors are `(91, 99)`.
 
+## 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/pangram/README.md

@@ -8,6 +8,21 @@ The best known English pangram is:
 The alphabet used consists of ASCII letters `a` to `z`, inclusive, and is case
 insensitive. Input will not contain non-ASCII symbols.
 
+## 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.