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!

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).

Syntax [https://guides.github.com/features/mastering-markdown/](https://guides.github.com/features/mastering-markdown/)

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

}

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

import unittest

from markdown import parse_markdown

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()