trackler 2.2.1.45 → 2.2.1.46

data/tracks/python/exercises/luhn/luhn_test.py

@@ -5,47 +5,47 @@ import unittest
 from luhn import Luhn
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class LuhnTests(unittest.TestCase):
     def test_single_digit_strings_can_not_be_valid(self):
-        self.assertFalse(Luhn("1").is_valid())
+        self.assertIs(Luhn("1").is_valid(), False)
 
     def test_a_single_zero_is_invalid(self):
-        self.assertFalse(Luhn("0").is_valid())
+        self.assertIs(Luhn("0").is_valid(), False)
 
     def test_a_simple_valid_SIN_that_remains_valid_if_reversed(self):
-        self.assertTrue(Luhn("059").is_valid())
+        self.assertIs(Luhn("059").is_valid(), True)
 
     def test_a_simple_valid_SIN_that_becomes_invalid_if_reversed(self):
-        self.assertTrue(Luhn("59").is_valid())
+        self.assertIs(Luhn("59").is_valid(), True)
 
     def test_a_valid_Canadian_SIN(self):
-        self.assertTrue(Luhn("055 444 285").is_valid())
+        self.assertIs(Luhn("055 444 285").is_valid(), True)
 
     def test_invalid_Canadian_SIN(self):
-        self.assertFalse(Luhn("055 444 286").is_valid())
+        self.assertIs(Luhn("055 444 286").is_valid(), False)
 
     def test_invalid_credit_card(self):
-        self.assertFalse(Luhn("8273 1232 7352 0569").is_valid())
+        self.assertIs(Luhn("8273 1232 7352 0569").is_valid(), False)
 
     def test_valid_strings_with_a_non_digit_included_become_invalid(self):
-        self.assertFalse(Luhn("055a 444 285").is_valid())
+        self.assertIs(Luhn("055a 444 285").is_valid(), False)
 
     def test_valid_strings_with_punctuation_included_become_invalid(self):
-        self.assertFalse(Luhn("055-444-285").is_valid())
+        self.assertIs(Luhn("055-444-285").is_valid(), False)
 
     def test_valid_strings_with_symbols_included_become_invalid(self):
-        self.assertFalse(Luhn("055£ 444$ 285").is_valid())
+        self.assertIs(Luhn("055£ 444$ 285").is_valid(), False)
 
     def test_single_zero_with_space_is_invalid(self):
-        self.assertFalse(Luhn("0").is_valid())
+        self.assertIs(Luhn("0").is_valid(), False)
 
     def test_more_than_a_single_zero_is_valid(self):
-        self.assertTrue(Luhn("0000 0").is_valid())
+        self.assertIs(Luhn("0000 0").is_valid(), True)
 
     def test_input_digit_9_is_correctly_converted_to_output_digit_9(self):
-        self.assertTrue(Luhn("091").is_valid())
+        self.assertIs(Luhn("091").is_valid(), True)
 
     def test_is_valid_can_be_called_repeatedly(self):
         # Additional track specific test case
@@ -53,8 +53,8 @@ class LuhnTests(unittest.TestCase):
         # in which the first call to is_valid() worked, but the
         # second call failed().
         number = Luhn("055 444 285")
-        self.assertTrue(number.is_valid())
-        self.assertTrue(number.is_valid())
+        self.assertIs(number.is_valid(), True)
+        self.assertIs(number.is_valid(), True)
 
 
 if __name__ == '__main__':

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

@@ -0,0 +1,30 @@
+# Markdown
+
+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
+associated HTML for that string. Even though this code is confusingly written
+and hard to follow, somehow it works and all the tests are passing! Your
+challenge is to re-write this code to make it easier to read and maintain
+while still making sure that all the tests keep passing.
+
+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!
+
+### 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).
+
+## Source
+
+Syntax [https://guides.github.com/features/mastering-markdown/](https://guides.github.com/features/mastering-markdown/)
+
+## 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/markdown/example.py

@@ -0,0 +1,80 @@
+import re
+
+
+def parse_markdown(markdown):
+    lines = markdown.split('\n')
+    html = ''
+    in_list = False
+    for line in lines:
+        res = parse_line(line, in_list)
+        html += res['line']
+        in_list = res['in_list']
+    if in_list:
+        html += '</ul>'
+    return html
+
+
+def wrap(line, tag):
+    return '<{tag}>{line}</{tag}>'.format(line=line, tag=tag)
+
+
+def check_headers(line):
+    pattern = '# (.*)'
+    for i in range(6):
+        if re.match(pattern, line):
+            return wrap(line[(i + 2):], 'h' + str(i + 1))
+        pattern = '#' + pattern
+    return line
+
+
+def check_bold(line):
+    bold_pattern = '(.*)__(.*)__(.*)'
+    bold_match = re.match(bold_pattern, line)
+    if bold_match:
+        return bold_match.group(1) + wrap(bold_match.group(2), 'strong')\
+            + bold_match.group(3)
+    else:
+        return None
+
+
+def check_italic(line):
+    italic_pattern = '(.*)_(.*)_(.*)'
+    italic_match = re.match(italic_pattern, line)
+    if italic_match:
+        return italic_match.group(1) + wrap(italic_match.group(2), 'em')\
+            + italic_match.group(3)
+    else:
+        return None
+
+
+def parse_line(line, in_list):
+    res = check_headers(line)
+
+    list_match = re.match(r'\* (.*)', res)
+
+    if (list_match):
+        if not in_list:
+            res = '<ul>' + wrap(list_match.group(1), 'li')
+            in_list = True
+        else:
+            res = wrap(list_match.group(1), 'li')
+    else:
+        if in_list:
+            res += '</ul>'
+            in_list = False
+
+    if not re.match('<h|<ul|<li', res):
+        res = wrap(res, 'p')
+
+    if not re.match('(<ul>)?<li>_(.*)', res):
+        res = re.sub('(.*)(<li>)(.*)(</li>)(.*)', r'\1\2<p>\3</p>\4\5', res)
+
+    while check_bold(res):
+        res = check_bold(res)
+    while check_italic(res):
+        res = check_italic(res)
+
+    return {
+        'line': res,
+        'in_list': in_list
+    }

data/tracks/python/exercises/markdown/markdown.py

@@ -0,0 +1,71 @@
+import re
+
+
+def parse_markdown(markdown):
+    lines = markdown.split('\n')
+    res = ''
+    in_list = False
+    for i in lines:
+        if re.match('###### (.*)', i) is not None:
+            i = '<h6>' + i[7:] + '</h6>'
+        elif re.match('## (.*)', i) is not None:
+            i = '<h2>' + i[3:] + '</h2>'
+        elif re.match('# (.*)', i) is not None:
+            i = '<h1>' + i[2:] + '</h1>'
+        m = re.match(r'\* (.*)', i)
+        if m:
+            if not in_list:
+                in_list = True
+                is_bold = False
+                is_italic = False
+                curr = m.group(1)
+                m1 = re.match('(.*)__(.*)__(.*)', curr)
+                if m1:
+                    curr = m1.group(1) + '<strong>' + \
+                        m1.group(2) + '</strong>' + m1.group(3)
+                    is_bold = True
+                m1 = re.match('(.*)_(.*)_(.*)', curr)
+                if m1:
+                    curr = m1.group(1) + '<em>' + m1.group(2) + \
+                        '</em>' + m1.group(3)
+                    is_italic = True
+                if is_italic or is_bold:
+                    i = '<ul><li>' + curr + '</li>'
+                else:
+                    i = '<ul><li><p>' + curr + '</p></li>'
+            else:
+                is_bold = False
+                is_italic = False
+                curr = m.group(1)
+                m1 = re.match('(.*)__(.*)__(.*)', curr)
+                if m1:
+                    curr = m1.group(1) + '<strong>' + \
+                        m1.group(2) + '</strong>' + m1.group(3)
+                    is_bold = True
+                m1 = re.match('(.*)_(.*)_(.*)', curr)
+                if m1:
+                    curr = m1.group(1) + '<em>' + m1.group(2) + \
+                        '</em>' + m1.group(3)
+                    is_italic = True
+                if is_italic or is_bold:
+                    i = '<li>' + curr + '</li>'
+                else:
+                    i = '<li><p>' + curr + '</p></li>'
+        else:
+            if in_list:
+                i = '</ul>+i'
+                in_list = False
+
+        m = re.match('<h|<ul|<p|<li', i)
+        if not m:
+            i = '<p>' + i + '</p>'
+        m = re.match('(.*)__(.*)__(.*)', i)
+        if m:
+            i = m.group(1) + '<strong>' + m.group(2) + '</strong>' + m.group(3)
+        m = re.match('(.*)_(.*)_(.*)', i)
+        if m:
+            i = m.group(1) + '<em>' + m.group(2) + '</em>' + m.group(3)
+        res += i
+    if in_list:
+        res += '</ul>'
+    return res

data/tracks/python/exercises/markdown/markdown_test.py

@@ -0,0 +1,51 @@
+import unittest
+from markdown import parse_markdown
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
+
+class TestMarkdown(unittest.TestCase):
+
+    def test_paragraph(self):
+        self.assertEqual(parse_markdown('This will be a paragraph'),
+                         '<p>This will be a paragraph</p>')
+
+    def test_italics(self):
+        self.assertEqual(parse_markdown('_This will be italic_'),
+                         '<p><em>This will be italic</em></p>')
+
+    def test_bold(self):
+        self.assertEqual(parse_markdown('__This will be bold__'),
+                         '<p><strong>This will be bold</strong></p>')
+
+    def test_mixed(self):
+        self.assertEqual(parse_markdown('This will _be_ __mixed__'),
+                         '<p>This will <em>be</em> <strong>mixed</strong></p>')
+
+    def test_h1(self):
+        self.assertEqual(parse_markdown('# This will be an h1'),
+                         '<h1>This will be an h1</h1>')
+
+    def test_h2(self):
+        self.assertEqual(parse_markdown('## This will be an h2'),
+                         '<h2>This will be an h2</h2>')
+
+    def test_h6(self):
+        self.assertEqual(parse_markdown(
+            '###### This will be an h6'), '<h6>This will be an h6</h6>')
+
+    def test_unordered_lists(self):
+        self.assertEqual(parse_markdown('* Item 1\n* Item 2'),
+                         '<ul><li><p>Item 1</p></li>'
+                         '<li><p>Item 2</p></li></ul>')
+
+    def test_little_bit_of_everything(self):
+        self.assertEqual(parse_markdown(
+            '# Header!\n* __Bold Item__\n* _Italic Item_'),
+            '<h1>Header!</h1><ul><li><strong>Bold Item</strong></li>'
+            '<li><em>Italic Item</em></li></ul>')
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -10,7 +10,7 @@ except ImportError:
     MeetupDayException = Exception
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class MeetupTest(unittest.TestCase):
     def test_monteenth_of_may_2013(self):

data/tracks/python/exercises/nth-prime/nth_prime_test.py

@@ -3,7 +3,7 @@ import unittest
 from nth_prime import nth_prime
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class NthPrimeTests(unittest.TestCase):
     def test_first_prime(self):

data/tracks/python/exercises/pascals-triangle/pascals_triangle_test.py

@@ -15,11 +15,11 @@ class PascalsTriangleTest(unittest.TestCase):
 
     def test_is_triangle_true(self):
         inp = ['1', '1 1', '1 2 1', '1 3 3 1', '1 4 6 4 1', '1 5 10 10 5 1']
-        self.assertTrue(is_triangle(inp))
+        self.assertIs(is_triangle(inp), True)
 
     def test_is_triangle_false(self):
         inp = ['1', '1 1', '1 2 1', '1 4 4 1']
-        self.assertFalse(is_triangle(inp))
+        self.assertIs(is_triangle(inp), False)
 
     def test_row1(self):
         ans = '1'

data/tracks/python/exercises/perfect-numbers/perfect_numbers_test.py

@@ -6,37 +6,37 @@ from perfect_numbers import is_perfect
 class PerfectNumbersTest(unittest.TestCase):
 
     def test_first_perfect_number(self):
-        self.assertTrue(is_perfect(6))
+        self.assertIs(is_perfect(6), True)
 
     def test_no_perfect_number(self):
-        self.assertFalse(is_perfect(8))
+        self.assertIs(is_perfect(8), False)
 
     def test_second_perfect_number(self):
-        self.assertTrue(is_perfect(28))
+        self.assertIs(is_perfect(28), True)
 
     def test_abundant(self):
-        self.assertFalse(is_perfect(20))
+        self.assertIs(is_perfect(20), False)
 
     def test_answer_to_the_ultimate_question_of_life(self):
-        self.assertFalse(is_perfect(42))
+        self.assertIs(is_perfect(42), False)
 
     def test_third_perfect_number(self):
-        self.assertTrue(is_perfect(496))
+        self.assertIs(is_perfect(496), True)
 
     def test_odd_abundant(self):
-        self.assertFalse(is_perfect(945))
+        self.assertIs(is_perfect(945), False)
 
     def test_fourth_perfect_number(self):
-        self.assertTrue(is_perfect(8128))
+        self.assertIs(is_perfect(8128), True)
 
     def test_fifth_perfect_number(self):
-        self.assertTrue(is_perfect(33550336))
+        self.assertIs(is_perfect(33550336), True)
 
     def test_sixth_perfect_number(self):
-        self.assertTrue(is_perfect(8589869056))
+        self.assertIs(is_perfect(8589869056), True)
 
     def test_seventh_perfect_number(self):
-        self.assertTrue(is_perfect(137438691328))
+        self.assertIs(is_perfect(137438691328), True)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/phone-number/phone_number_test.py

@@ -3,7 +3,7 @@ import unittest
 from phone_number import Phone
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.2.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class PhoneTest(unittest.TestCase):
     def test_cleans_number(self):

data/tracks/python/exercises/prime-factors/prime_factors_test.py

@@ -3,7 +3,7 @@ import unittest
 from prime_factors import prime_factors
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class PrimeFactorsTest(unittest.TestCase):
     def test_no_factors(self):

data/tracks/python/exercises/pythagorean-triplet/pythagorean_triplet_test.py

@@ -71,13 +71,13 @@ class PythagoreanTripletTest(unittest.TestCase):
         self.assertEqual(triplets_in_range(56, 95), ans)
 
     def test_is_triplet1(self):
-        self.assertTrue(is_triplet((29, 20, 21)))
+        self.assertIs(is_triplet((29, 20, 21)), True)
 
     def test_is_triplet2(self):
-        self.assertFalse(is_triplet((25, 25, 1225)))
+        self.assertIs(is_triplet((25, 25, 1225)), False)
 
     def test_is_triplet3(self):
-        self.assertTrue(is_triplet((924, 43, 925)))
+        self.assertIs(is_triplet((924, 43, 925)), True)
 
     def test_odd_number(self):
         self.assertRaises(ValueError, primitive_triplets, 5)

data/tracks/python/exercises/queen-attack/queen_attack_test.py

@@ -27,28 +27,28 @@ class QueenAttackTest(unittest.TestCase):
         self.assertEqual(board((0, 6), (1, 7)), ans)
 
     def test_attack_true1(self):
-        self.assertTrue(can_attack((2, 3), (5, 6)))
+        self.assertIs(can_attack((2, 3), (5, 6)), True)
 
     def test_attack_true2(self):
-        self.assertTrue(can_attack((2, 6), (5, 3)))
+        self.assertIs(can_attack((2, 6), (5, 3)), True)
 
     def test_attack_true3(self):
-        self.assertTrue(can_attack((2, 4), (2, 7)))
+        self.assertIs(can_attack((2, 4), (2, 7)), True)
 
     def test_attack_true4(self):
-        self.assertTrue(can_attack((5, 4), (2, 4)))
+        self.assertIs(can_attack((5, 4), (2, 4)), True)
 
     def test_attack_true5(self):
-        self.assertTrue(can_attack((1, 1), (6, 6)))
+        self.assertIs(can_attack((1, 1), (6, 6)), True)
 
     def test_attack_true6(self):
-        self.assertTrue(can_attack((0, 6), (1, 7)))
+        self.assertIs(can_attack((0, 6), (1, 7)), True)
 
     def test_attack_false1(self):
-        self.assertFalse(can_attack((4, 2), (0, 5)))
+        self.assertIs(can_attack((4, 2), (0, 5)), False)
 
     def test_attack_false2(self):
-        self.assertFalse(can_attack((2, 3), (4, 7)))
+        self.assertIs(can_attack((2, 3), (4, 7)), False)
 
     # If either board or can_attack are called with an invalid board position
     # they should raise a ValueError with a meaningful error message.