Merge branch 'develop'

fixes #44

.github/workflows/python-app.yml

@@ -0,0 +1,33 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Python application
+
+on:
+  push:
+    branches: [ develop ]
+  pull_request:
+    branches: [ develop ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.8
+      uses: actions/setup-python@v2
+      with:
+        python-version: 3.8
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8==3.8.4 pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Lint with flake8
+      run: |
+        python setup.py lint
+    - name: Test with pytest
+      run: |
+        python setup.py test

.github/workflows/python-publish.yml

@@ -0,0 +1,31 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.8'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
+        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+      run: |
+        python setup.py sdist bdist_wheel
+        twine upload dist/*

.gitignore

@@ -7,3 +7,4 @@
 /dist
 /MANIFEST
 /venv
+build/

README.rst

@@ -1,3 +1,21 @@
+|build| |version| |license| |downloads|
+
+.. |build| image:: https://img.shields.io/github/workflow/status/matthewwithanm/python-markdownify/Python%20application/develop
+    :alt: GitHub Workflow Status
+    :target: https://github.com/matthewwithanm/python-markdownify/actions?query=workflow%3A%22Python+application%22
+
+.. |version| image:: https://img.shields.io/pypi/v/markdownify
+    :alt: Pypi version
+    :target: https://pypi.org/project/markdownify/
+
+.. |license| image:: https://img.shields.io/pypi/l/markdownify
+    :alt: License
+    :target: https://github.com/matthewwithanm/python-markdownify/blob/develop/LICENSE
+
+.. |downloads| image:: https://pepy.tech/badge/markdownify
+    :alt: Pypi Downloads
+    :target: https://pepy.tech/project/markdownify
+
 Installation
 ============
 
@@ -44,7 +62,11 @@ convert
 
 autolinks
   A boolean indicating whether the "automatic link" style should be used when
-  a ``a`` tag's contents match its href. Defaults to ``True``
+  a ``a`` tag's contents match its href. Defaults to ``True``.
+
+default_title
+  A boolean to enable setting the title of a link to its href, if no title is
+  given. Defaults to ``False``.
 
 heading_style
   Defines how headings should be converted. Accepted values are ``ATX``,
@@ -57,6 +79,23 @@ bullets
   lists are nested. Otherwise, the bullet will alternate based on nesting
   level. Defaults to ``'*+-'``.
 
+strong_em_symbol
+  In markdown, both ``*`` and ``_`` are used to encode **strong** or
+  *emphasized* texts. Either of these symbols can be chosen by the options
+  ``ASTERISK`` (default) or ``UNDERSCORE`` respectively.
+
+sub_symbol, sup_symbol
+  Define the chars that surround ``<sub>`` and ``<sup>`` text. Defaults to an
+  empty string, because this is non-standard behavior. Could be something like
+  ``~`` and ``^`` to result in ``~sub~`` and ``^sup^``.
+
+newline_style
+  Defines the style of marking linebreaks (``<br>``) in markdown. The default
+  value ``SPACES`` of this option will adopt the usual two spaces and a newline,
+  while ``BACKSLASH`` will convert a linebreak to ``\\n`` (a backslash an a
+  newline). While the latter convention is non-standard, it is commonly
+  preferred and supported by a lot of interpreters.
+
 Options may be specified as kwargs to the ``markdownify`` function, or as a
 nested ``Options`` class in ``MarkdownConverter`` subclasses.
 

markdownify/__init__.py

@@ -1,13 +1,13 @@
-from bs4 import BeautifulSoup, NavigableString
+from bs4 import BeautifulSoup, NavigableString, Comment, Doctype
 import re
 import six
 
 
 convert_heading_re = re.compile(r'convert_h(\d+)')
 line_beginning_re = re.compile(r'^', re.MULTILINE)
-whitespace_re = re.compile(r'[\r\n\s\t ]+')
-FRAGMENT_ID = '__MARKDOWNIFY_WRAPPER__'
-wrapped = '<div id="%s">%%s</div>' % FRAGMENT_ID
+whitespace_re = re.compile(r'[\t ]+')
+all_whitespace_re = re.compile(r'[\s]+')
+html_heading_re = re.compile(r'h[1-6]')
 
 
 # Heading styles
@@ -16,6 +16,14 @@ ATX_CLOSED = 'atx_closed'
 UNDERLINED = 'underlined'
 SETEXT = UNDERLINED
 
+# Newline style
+SPACES = 'spaces'
+BACKSLASH = 'backslash'
+
+# Strong and emphasis style
+ASTERISK = '*'
+UNDERSCORE = '_'
+
 
 def escape(text):
     if not text:
@@ -36,17 +44,38 @@ def chomp(text):
     return (prefix, suffix, text)
 
 
+def abstract_inline_conversion(markup_fn):
+    """
+    This abstracts all simple inline tags like b, em, del, ...
+    Returns a function that wraps the chomped text in a pair of the string
+    that is returned by markup_fn. markup_fn is necessary to allow for
+    references to self.strong_em_symbol etc.
+    """
+    def implementation(self, el, text, convert_as_inline):
+        markup = markup_fn(self)
+        prefix, suffix, text = chomp(text)
+        if not text:
+            return ''
+        return '%s%s%s%s%s' % (prefix, markup, text, markup, suffix)
+    return implementation
+
+
 def _todict(obj):
     return dict((k, getattr(obj, k)) for k in dir(obj) if not k.startswith('_'))
 
 
 class MarkdownConverter(object):
     class DefaultOptions:
-        strip = None
-        convert = None
         autolinks = True
-        heading_style = UNDERLINED
         bullets = '*+-'  # An iterable of bullet types.
+        convert = None
+        default_title = False
+        heading_style = UNDERLINED
+        newline_style = SPACES
+        strip = None
+        strong_em_symbol = ASTERISK
+        sub_symbol = ''
+        sup_symbol = ''
 
     class Options(DefaultOptions):
         pass
@@ -62,32 +91,73 @@ class MarkdownConverter(object):
                              ' convert, but not both.')
 
     def convert(self, html):
-        # We want to take advantage of the html5 parsing, but we don't actually
-        # want a full document. Therefore, we'll mark our fragment with an id,
-        # create the document, and extract the element with the id.
-        html = wrapped % html
         soup = BeautifulSoup(html, 'html.parser')
-        return self.process_tag(soup.find(id=FRAGMENT_ID), children_only=True)
+        return self.process_tag(soup, convert_as_inline=False, children_only=True)
 
-    def process_tag(self, node, children_only=False):
+    def process_tag(self, node, convert_as_inline, children_only=False):
         text = ''
+        # markdown headings can't include block elements (elements w/newlines)
+        isHeading = html_heading_re.match(node.name) is not None
+        convert_children_as_inline = convert_as_inline
+
+        if not children_only and isHeading:
+            convert_children_as_inline = True
+
+        # Remove whitespace-only textnodes in purely nested nodes
+        def is_nested_node(el):
+            return el and el.name in ['ol', 'ul', 'li',
+                                      'table', 'thead', 'tbody', 'tfoot',
+                                      'tr', 'td', 'th']
+
+        if is_nested_node(node):
+            for el in node.children:
+                # Only extract (remove) whitespace-only text node if any of the
+                # conditions is true:
+                # - el is the first element in its parent
+                # - el is the last element in its parent
+                # - el is adjacent to an nested node
+                can_extract = (not el.previous_sibling
+                               or not el.next_sibling
+                               or is_nested_node(el.previous_sibling)
+                               or is_nested_node(el.next_sibling))
+                if (isinstance(el, NavigableString)
+                        and six.text_type(el).strip() == ''
+                        and can_extract):
+                    el.extract()
 
         # Convert the children first
         for el in node.children:
-            if isinstance(el, NavigableString):
-                text += self.process_text(six.text_type(el))
+            if isinstance(el, Comment) or isinstance(el, Doctype):
+                continue
+            elif isinstance(el, NavigableString):
+                text += self.process_text(el)
             else:
-                text += self.process_tag(el)
+                text += self.process_tag(el, convert_children_as_inline)
 
         if not children_only:
             convert_fn = getattr(self, 'convert_%s' % node.name, None)
             if convert_fn and self.should_convert_tag(node.name):
-                text = convert_fn(node, text)
+                text = convert_fn(node, text, convert_as_inline)
 
         return text
 
-    def process_text(self, text):
-        return escape(whitespace_re.sub(' ', text or ''))
+    def process_text(self, el):
+        text = six.text_type(el)
+
+        # dont remove any whitespace when handling pre or code in pre
+        if (el.parent.name == 'pre'
+                or (el.parent.name == 'code' and el.parent.parent.name == 'pre')):
+            return escape(text or '')
+
+        cleaned_text = escape(whitespace_re.sub(' ', text or ''))
+
+        # remove trailing whitespaces if any of the following condition is true:
+        # - current text node is the last node in li
+        # - current text node is followed by an embedded list
+        if el.parent.name == 'li' and (not el.next_sibling or el.next_sibling.name in ['ul', 'ol']):
+            return cleaned_text.rstrip()
+
+        return cleaned_text
 
     def __getattr__(self, attr):
         # Handle headings
@@ -95,8 +165,8 @@ class MarkdownConverter(object):
         if m:
             n = int(m.group(1))
 
-            def convert_tag(el, text):
-                return self.convert_hn(n, el, text)
+            def convert_tag(el, text, convert_as_inline):
+                return self.convert_hn(n, el, text, convert_as_inline)
 
             convert_tag.__name__ = 'convert_h%s' % n
             setattr(self, convert_tag.__name__, convert_tag)
@@ -122,35 +192,61 @@ class MarkdownConverter(object):
         text = (text or '').rstrip()
         return '%s\n%s\n\n' % (text, pad_char * len(text)) if text else ''
 
-    def convert_a(self, el, text):
+    def convert_a(self, el, text, convert_as_inline):
         prefix, suffix, text = chomp(text)
         if not text:
             return ''
+        if convert_as_inline:
+            return text
         href = el.get('href')
         title = el.get('title')
-        if self.options['autolinks'] and text == href and not title:
+        # For the replacement see #29: text nodes underscores are escaped
+        if (self.options['autolinks']
+                and text.replace(r'\_', '_') == href
+                and not title
+                and not self.options['default_title']):
             # Shortcut syntax
             return '<%s>' % href
+        if self.options['default_title'] and not title:
+            title = href
         title_part = ' "%s"' % title.replace('"', r'\"') if title else ''
         return '%s[%s](%s%s)%s' % (prefix, text, href, title_part, suffix) if href else text
 
-    def convert_b(self, el, text):
-        return self.convert_strong(el, text)
+    convert_b = abstract_inline_conversion(lambda self: 2 * self.options['strong_em_symbol'])
 
-    def convert_blockquote(self, el, text):
-        return '\n' + line_beginning_re.sub('> ', text) if text else ''
+    def convert_blockquote(self, el, text, convert_as_inline):
 
-    def convert_br(self, el, text):
-        return '  \n'
+        if convert_as_inline:
+            return text
 
-    def convert_em(self, el, text):
-        prefix, suffix, text = chomp(text)
-        if not text:
-            return ''
-        return '%s*%s*%s' % (prefix, text, suffix)
+        return '\n' + (line_beginning_re.sub('> ', text) + '\n\n') if text else ''
 
-    def convert_hn(self, n, el, text):
-        style = self.options['heading_style']
+    def convert_br(self, el, text, convert_as_inline):
+        if convert_as_inline:
+            return ""
+
+        if self.options['newline_style'].lower() == BACKSLASH:
+            return '\\\n'
+        else:
+            return '  \n'
+
+    def convert_code(self, el, text, convert_as_inline):
+        if el.parent.name == 'pre':
+            return text
+        converter = abstract_inline_conversion(lambda self: '`')
+        return converter(self, el, text, convert_as_inline)
+
+    convert_del = abstract_inline_conversion(lambda self: '~~')
+
+    convert_em = abstract_inline_conversion(lambda self: self.options['strong_em_symbol'])
+
+    convert_kbd = convert_code
+
+    def convert_hn(self, n, el, text, convert_as_inline):
+        if convert_as_inline:
+            return text
+
+        style = self.options['heading_style'].lower()
         text = text.rstrip()
         if style == UNDERLINED and n <= 2:
             line = '=' if n == 1 else '-'
@@ -160,11 +256,30 @@ class MarkdownConverter(object):
             return '%s %s %s\n\n' % (hashes, text, hashes)
         return '%s %s\n\n' % (hashes, text)
 
-    def convert_i(self, el, text):
-        return self.convert_em(el, text)
+    def convert_hr(self, el, text, convert_as_inline):
+        return '\n\n---\n\n'
+
+    convert_i = convert_em
+
+    def convert_img(self, el, text, convert_as_inline):
+        alt = el.attrs.get('alt', None) or ''
+        src = el.attrs.get('src', None) or ''
+        title = el.attrs.get('title', None) or ''
+        title_part = ' "%s"' % title.replace('"', r'\"') if title else ''
+        if convert_as_inline:
+            return alt
+
+        return '![%s](%s%s)' % (alt, src, title_part)
+
+    def convert_list(self, el, text, convert_as_inline):
+
+        # Converting a list to inline is undefined.
+        # Ignoring convert_to_inline for list.
 
-    def convert_list(self, el, text):
         nested = False
+        before_paragraph = False
+        if el.next_sibling and el.next_sibling.name not in ['ul', 'ol']:
+            before_paragraph = True
         while el:
             if el.name == 'li':
                 nested = True
@@ -173,15 +288,19 @@ class MarkdownConverter(object):
         if nested:
             # remove trailing newline if nested
             return '\n' + self.indent(text, 1).rstrip()
-        return '\n' + text + '\n'
+        return text + ('\n' if before_paragraph else '')
 
     convert_ul = convert_list
     convert_ol = convert_list
 
-    def convert_li(self, el, text):
+    def convert_li(self, el, text, convert_as_inline):
         parent = el.parent
         if parent is not None and parent.name == 'ol':
-            bullet = '%s.' % (parent.index(el) + 1)
+            if parent.get("start"):
+                start = int(parent.get("start"))
+            else:
+                start = 1
+            bullet = '%s.' % (start + parent.index(el))
         else:
             depth = -1
             while el:
@@ -192,21 +311,49 @@ class MarkdownConverter(object):
             bullet = bullets[depth % len(bullets)]
         return '%s %s\n' % (bullet, text or '')
 
-    def convert_p(self, el, text):
+    def convert_p(self, el, text, convert_as_inline):
+        if convert_as_inline:
+            return text
         return '%s\n\n' % text if text else ''
 
-    def convert_strong(self, el, text):
-        prefix, suffix, text = chomp(text)
+    def convert_pre(self, el, text, convert_as_inline):
         if not text:
             return ''
-        return '%s**%s**%s' % (prefix, text, suffix)
+        return '\n```\n%s\n```\n' % text
 
-    def convert_img(self, el, text):
-        alt = el.attrs.get('alt', None) or ''
-        src = el.attrs.get('src', None) or ''
-        title = el.attrs.get('title', None) or ''
-        title_part = ' "%s"' % title.replace('"', r'\"') if title else ''
-        return '![%s](%s%s)' % (alt, src, title_part)
+    convert_s = convert_del
+
+    convert_strong = convert_b
+
+    convert_samp = convert_code
+
+    convert_sub = abstract_inline_conversion(lambda self: self.options['sub_symbol'])
+
+    convert_sup = abstract_inline_conversion(lambda self: self.options['sup_symbol'])
+
+    def convert_table(self, el, text, convert_as_inline):
+        return '\n\n' + text + '\n'
+
+    def convert_td(self, el, text, convert_as_inline):
+        return ' ' + text + ' |'
+
+    def convert_th(self, el, text, convert_as_inline):
+        return ' ' + text + ' |'
+
+    def convert_tr(self, el, text, convert_as_inline):
+        cells = el.find_all(['td', 'th'])
+        is_headrow = all([cell.name == 'th' for cell in cells])
+        overline = ''
+        underline = ''
+        if is_headrow and not el.previous_sibling:
+            # first row and is headline: print headline underline
+            underline += '| ' + ' | '.join(['---'] * len(cells)) + ' |' + '\n'
+        elif not el.previous_sibling and not el.parent.name != 'table':
+            # first row, not headline, and the parent is sth. like tbody:
+            # print empty headline above this row
+            overline += '| ' + ' | '.join([''] * len(cells)) + ' |' + '\n'
+            overline += '| ' + ' | '.join(['---'] * len(cells)) + ' |' + '\n'
+        return overline + '|' + text + '\n' + underline
 
 
 def markdownify(html, **options):

setup.cfg

@@ -1,2 +1,2 @@
 [flake8]
-ignore = E501
+ignore = E501 W503

setup.py

@@ -10,7 +10,7 @@ read = lambda filepath: codecs.open(filepath, 'r', 'utf-8').read()
 pkgmeta = {
     '__title__': 'markdownify',
     '__author__': 'Matthew Tretter',
-    '__version__': '0.5.0',
+    '__version__': '0.9.0',
 }
 
 
@@ -50,7 +50,7 @@ class LintCommand(Command):
                 yield "%s.py" % filename
 
     def run(self):
-        from flake8.engine import get_style_guide
+        from flake8.api.legacy import get_style_guide
         flake8_style = get_style_guide(config_file='setup.cfg')
         paths = self.distribution_files()
         report = flake8_style.check_files(paths)
@@ -70,13 +70,13 @@ setup(
     zip_safe=False,
     include_package_data=True,
     setup_requires=[
-        'flake8',
+        'flake8>=3.8,<4',
     ],
     tests_require=[
-        'pytest',
+        'pytest>=6.2,<7',
     ],
     install_requires=[
-        'beautifulsoup4', 'six'
+        'beautifulsoup4>=4.9,<5', 'six>=1.15,<2'
     ],
     classifiers=[
         'Environment :: Web Environment',
@@ -87,6 +87,9 @@ setup(
         'Programming Language :: Python :: 2.5',
         'Programming Language :: Python :: 2.6',
         'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
         'Topic :: Utilities'
     ],
     cmdclass={

tests/test_advanced.py

@@ -1,6 +1,39 @@
 from markdownify import markdownify as md
 
 
+def test_chomp():
+    assert md(' <b></b> ') == '  '
+    assert md(' <b> </b> ') == '  '
+    assert md(' <b>  </b> ') == '  '
+    assert md(' <b>   </b> ') == '  '
+    assert md(' <b>s </b> ') == ' **s**  '
+    assert md(' <b> s</b> ') == '  **s** '
+    assert md(' <b> s </b> ') == '  **s**  '
+    assert md(' <b>  s  </b> ') == '  **s**  '
+
+
 def test_nested():
     text = md('<p>This is an <a href="http://example.com/">example link</a>.</p>')
     assert text == 'This is an [example link](http://example.com/).\n\n'
+
+
+def test_ignore_comments():
+    text = md("<!-- This is a comment -->")
+    assert text == ""
+
+
+def test_ignore_comments_with_other_tags():
+    text = md("<!-- This is a comment --><a href='http://example.com/'>example link</a>")
+    assert text == "[example link](http://example.com/)"
+
+
+def test_code_with_tricky_content():
+    assert md('<code>></code>') == "`>`"
+    assert md('<code>/home/</code><b>username</b>') == "`/home/`**username**"
+    assert md('First line <code>blah blah<br />blah blah</code> second line') \
+        == "First line `blah blah  \nblah blah` second line"
+
+
+def test_special_tags():
+    assert md('<!DOCTYPE html>') == ''
+    assert md('<![CDATA[foobar]]>') == 'foobar'

tests/test_basic.py

@@ -10,4 +10,4 @@ def test_soup():
 
 
 def test_whitespace():
-    assert md(' a  b \n\n c ') == ' a b c '
+    assert md(' a  b \t\t c ') == ' a b c '

tests/test_conversions.py

@@ -1,40 +1,20 @@
-from markdownify import markdownify as md, ATX, ATX_CLOSED
-import re
+from markdownify import markdownify as md, ATX, ATX_CLOSED, BACKSLASH, UNDERSCORE
 
 
-nested_uls = re.sub(r'\s+', '', """
-    <ul>
-        <li>1
-            <ul>
-                <li>a
-                    <ul>
-                        <li>I</li>
-                        <li>II</li>
-                        <li>III</li>
-                    </ul>
-                </li>
-                <li>b</li>
-                <li>c</li>
-            </ul>
-        </li>
-        <li>2</li>
-        <li>3</li>
-    </ul>""")
-
-
-def test_chomp():
-    assert md(' <b></b> ') == '  '
-    assert md(' <b> </b> ') == '  '
-    assert md(' <b>  </b> ') == '  '
-    assert md(' <b>   </b> ') == '  '
-    assert md(' <b>s </b> ') == ' **s**  '
-    assert md(' <b> s</b> ') == '  **s** '
-    assert md(' <b> s </b> ') == '  **s**  '
-    assert md(' <b>  s  </b> ') == '  **s**  '
+def inline_tests(tag, markup):
+    # test template for different inline tags
+    assert md(f'<{tag}>Hello</{tag}>') == f'{markup}Hello{markup}'
+    assert md(f'foo <{tag}>Hello</{tag}> bar') == f'foo {markup}Hello{markup} bar'
+    assert md(f'foo<{tag}> Hello</{tag}> bar') == f'foo {markup}Hello{markup} bar'
+    assert md(f'foo <{tag}>Hello </{tag}>bar') == f'foo {markup}Hello{markup} bar'
+    assert md(f'foo <{tag}></{tag}> bar') in ['foo  bar', 'foo bar']  # Either is OK
 
 
 def test_a():
-    assert md('<a href="http://google.com">Google</a>') == '[Google](http://google.com)'
+    assert md('<a href="https://google.com">Google</a>') == '[Google](https://google.com)'
+    assert md('<a href="https://google.com">https://google.com</a>') == '<https://google.com>'
+    assert md('<a href="https://community.kde.org/Get_Involved">https://community.kde.org/Get_Involved</a>') == '<https://community.kde.org/Get_Involved>'
+    assert md('<a href="https://community.kde.org/Get_Involved">https://community.kde.org/Get_Involved</a>', autolinks=False) == '[https://community.kde.org/Get\\_Involved](https://community.kde.org/Get_Involved)'
 
 
 def test_a_spaces():
@@ -47,6 +27,7 @@ def test_a_spaces():
 def test_a_with_title():
     text = md('<a href="http://google.com" title="The &quot;Goog&quot;">Google</a>')
     assert text == r'[Google](http://google.com "The \"Goog\"")'
+    assert md('<a href="https://google.com">https://google.com</a>', default_title=True) == '[https://google.com](https://google.com "https://google.com")'
 
 
 def test_a_shortcut():
@@ -55,8 +36,7 @@ def test_a_shortcut():
 
 
 def test_a_no_autolinks():
-    text = md('<a href="http://google.com">http://google.com</a>', autolinks=False)
-    assert text == '[http://google.com](http://google.com)'
+    assert md('<a href="https://google.com">https://google.com</a>', autolinks=False) == '[https://google.com](https://google.com)'
 
 
 def test_b():
@@ -71,27 +51,37 @@ def test_b_spaces():
 
 
 def test_blockquote():
-    assert md('<blockquote>Hello</blockquote>').strip() == '> Hello'
+    assert md('<blockquote>Hello</blockquote>') == '\n> Hello\n\n'
 
 
-def test_nested_blockquote():
-    text = md('<blockquote>And she was like <blockquote>Hello</blockquote></blockquote>').strip()
-    assert text == '> And she was like \n> > Hello'
+def test_blockquote_with_paragraph():
+    assert md('<blockquote>Hello</blockquote><p>handsome</p>') == '\n> Hello\n\nhandsome\n\n'
+
+
+def test_blockquote_nested():
+    text = md('<blockquote>And she was like <blockquote>Hello</blockquote></blockquote>')
+    assert text == '\n> And she was like \n> > Hello\n> \n> \n\n'
 
 
 def test_br():
     assert md('a<br />b<br />c') == 'a  \nb  \nc'
+    assert md('a<br />b<br />c', newline_style=BACKSLASH) == 'a\\\nb\\\nc'
+
+
+def test_code():
+    inline_tests('code', '`')
+
+
+def test_del():
+    inline_tests('del', '~~')
+
+
+def test_div():
+    assert md('Hello</div> World') == 'Hello World'
 
 
 def test_em():
-    assert md('<em>Hello</em>') == '*Hello*'
-
-
-def test_em_spaces():
-    assert md('foo <em>Hello</em> bar') == 'foo *Hello* bar'
-    assert md('foo<em> Hello</em> bar') == 'foo *Hello* bar'
-    assert md('foo <em>Hello </em>bar') == 'foo *Hello* bar'
-    assert md('foo <em></em> bar') == 'foo  bar'
+    inline_tests('em', '*')
 
 
 def test_h1():
@@ -104,55 +94,120 @@ def test_h2():
 
 def test_hn():
     assert md('<h3>Hello</h3>') == '### Hello\n\n'
+    assert md('<h4>Hello</h4>') == '#### Hello\n\n'
+    assert md('<h5>Hello</h5>') == '##### Hello\n\n'
     assert md('<h6>Hello</h6>') == '###### Hello\n\n'
 
 
-def test_atx_headings():
+def test_hn_chained():
+    assert md('<h1>First</h1>\n<h2>Second</h2>\n<h3>Third</h3>', heading_style=ATX) == '# First\n\n\n## Second\n\n\n### Third\n\n'
+    assert md('X<h1>First</h1>', heading_style=ATX) == 'X# First\n\n'
+
+
+def test_hn_nested_tag_heading_style():
+    assert md('<h1>A <p>P</p> C </h1>', heading_style=ATX_CLOSED) == '# A P C #\n\n'
+    assert md('<h1>A <p>P</p> C </h1>', heading_style=ATX) == '# A P C\n\n'
+
+
+def test_hn_nested_simple_tag():
+    tag_to_markdown = [
+        ("strong", "**strong**"),
+        ("b", "**b**"),
+        ("em", "*em*"),
+        ("i", "*i*"),
+        ("p", "p"),
+        ("a", "a"),
+        ("div", "div"),
+        ("blockquote", "blockquote"),
+    ]
+
+    for tag, markdown in tag_to_markdown:
+        assert md('<h3>A <' + tag + '>' + tag + '</' + tag + '> B</h3>') == '### A ' + markdown + ' B\n\n'
+
+    assert md('<h3>A <br>B</h3>', heading_style=ATX) == '### A B\n\n'
+
+    # Nested lists not supported
+    # assert md('<h3>A <ul><li>li1</i><li>l2</li></ul></h3>', heading_style=ATX) == '### A li1 li2 B\n\n'
+
+
+def test_hn_nested_img():
+    assert md('<img src="/path/to/img.jpg" alt="Alt text" title="Optional title" />') == '![Alt text](/path/to/img.jpg "Optional title")'
+    assert md('<img src="/path/to/img.jpg" alt="Alt text" />') == '![Alt text](/path/to/img.jpg)'
+    image_attributes_to_markdown = [
+        ("", ""),
+        ("alt='Alt Text'", "Alt Text"),
+        ("alt='Alt Text' title='Optional title'", "Alt Text"),
+    ]
+    for image_attributes, markdown in image_attributes_to_markdown:
+        assert md('<h3>A <img src="/path/to/img.jpg " ' + image_attributes + '/> B</h3>') == '### A ' + markdown + ' B\n\n'
+
+
+def test_hn_atx_headings():
     assert md('<h1>Hello</h1>', heading_style=ATX) == '# Hello\n\n'
     assert md('<h2>Hello</h2>', heading_style=ATX) == '## Hello\n\n'
 
 
-def test_atx_closed_headings():
+def test_hn_atx_closed_headings():
     assert md('<h1>Hello</h1>', heading_style=ATX_CLOSED) == '# Hello #\n\n'
     assert md('<h2>Hello</h2>', heading_style=ATX_CLOSED) == '## Hello ##\n\n'
 
 
+def test_head():
+    assert md('<head>head</head>') == 'head'
+
+
+def test_hr():
+    assert md('Hello<hr>World') == 'Hello\n\n---\n\nWorld'
+    assert md('Hello<hr />World') == 'Hello\n\n---\n\nWorld'
+    assert md('<p>Hello</p>\n<hr>\n<p>World</p>') == 'Hello\n\n\n\n\n---\n\n\nWorld\n\n'
+
+
 def test_i():
     assert md('<i>Hello</i>') == '*Hello*'
 
 
-def test_ol():
-    assert md('<ol><li>a</li><li>b</li></ol>') == '\n1. a\n2. b\n\n'
+def test_img():
+    assert md('<img src="/path/to/img.jpg" alt="Alt text" title="Optional title" />') == '![Alt text](/path/to/img.jpg "Optional title")'
+    assert md('<img src="/path/to/img.jpg" alt="Alt text" />') == '![Alt text](/path/to/img.jpg)'
+
+
+def test_kbd():
+    inline_tests('kbd', '`')
 
 
 def test_p():
     assert md('<p>hello</p>') == 'hello\n\n'
 
 
+def test_pre():
+    assert md('<pre>test\n    foo\nbar</pre>') == '\n```\ntest\n    foo\nbar\n```\n'
+    assert md('<pre><code>test\n    foo\nbar</code></pre>') == '\n```\ntest\n    foo\nbar\n```\n'
+
+
+def test_s():
+    inline_tests('s', '~~')
+
+
+def test_samp():
+    inline_tests('samp', '`')
+
+
 def test_strong():
     assert md('<strong>Hello</strong>') == '**Hello**'
 
 
-def test_ul():
-    assert md('<ul><li>a</li><li>b</li></ul>') == '\n* a\n* b\n\n'
+def test_strong_em_symbol():
+    assert md('<strong>Hello</strong>', strong_em_symbol=UNDERSCORE) == '__Hello__'
+    assert md('<b>Hello</b>', strong_em_symbol=UNDERSCORE) == '__Hello__'
+    assert md('<em>Hello</em>', strong_em_symbol=UNDERSCORE) == '_Hello_'
+    assert md('<i>Hello</i>', strong_em_symbol=UNDERSCORE) == '_Hello_'
 
 
-def test_inline_ul():
-    assert md('<p>foo</p><ul><li>a</li><li>b</li></ul><p>bar</p>') == 'foo\n\n\n* a\n* b\n\nbar\n\n'
+def test_sub():
+    assert md('<sub>foo</sub>') == 'foo'
+    assert md('<sub>foo</sub>', sub_symbol='~') == '~foo~'
 
 
-def test_nested_uls():
-    """
-    Nested ULs should alternate bullet characters.
-
-    """
-    assert md(nested_uls) == '\n* 1\n\t+ a\n\t\t- I\n\t\t- II\n\t\t- III\n\t+ b\n\t+ c\n* 2\n* 3\n\n'
-
-
-def test_bullets():
-    assert md(nested_uls, bullets='-') == '\n- 1\n\t- a\n\t\t- I\n\t\t- II\n\t\t- III\n\t- b\n\t- c\n- 2\n- 3\n\n'
-
-
-def test_img():
-    assert md('<img src="/path/to/img.jpg" alt="Alt text" title="Optional title" />') == '![Alt text](/path/to/img.jpg "Optional title")'
-    assert md('<img src="/path/to/img.jpg" alt="Alt text" />') == '![Alt text](/path/to/img.jpg)'
+def test_sup():
+    assert md('<sup>foo</sup>') == 'foo'
+    assert md('<sup>foo</sup>', sup_symbol='^') == '^foo^'

tests/test_escaping.py

@@ -2,7 +2,7 @@ from markdownify import markdownify as md
 
 
 def test_underscore():
-    assert md('_hey_dude_') == '\_hey\_dude\_'
+    assert md('_hey_dude_') == r'\_hey\_dude\_'
 
 
 def test_xml_entities():

tests/test_lists.py

@@ -0,0 +1,73 @@
+from markdownify import markdownify as md
+
+
+nested_uls = """
+    <ul>
+        <li>1
+            <ul>
+                <li>a
+                    <ul>
+                        <li>I</li>
+                        <li>II</li>
+                        <li>III</li>
+                    </ul>
+                </li>
+                <li>b</li>
+                <li>c</li>
+            </ul>
+        </li>
+        <li>2</li>
+        <li>3</li>
+    </ul>"""
+
+nested_ols = """
+    <ol>
+        <li>1
+            <ol>
+                <li>a
+                    <ol>
+                        <li>I</li>
+                        <li>II</li>
+                        <li>III</li>
+                    </ol>
+                </li>
+                <li>b</li>
+                <li>c</li>
+            </ol>
+        </li>
+        <li>2</li>
+        <li>3</li>
+    </ul>"""
+
+
+def test_ol():
+    assert md('<ol><li>a</li><li>b</li></ol>') == '1. a\n2. b\n'
+    assert md('<ol start="3"><li>a</li><li>b</li></ol>') == '3. a\n4. b\n'
+
+
+def test_nested_ols():
+    assert md(nested_ols) == '\n1. 1\n\t1. a\n\t\t1. I\n\t\t2. II\n\t\t3. III\n\t2. b\n\t3. c\n2. 2\n3. 3\n'
+
+
+def test_ul():
+    assert md('<ul><li>a</li><li>b</li></ul>') == '* a\n* b\n'
+
+
+def test_inline_ul():
+    assert md('<p>foo</p><ul><li>a</li><li>b</li></ul><p>bar</p>') == 'foo\n\n* a\n* b\n\nbar\n\n'
+
+
+def test_nested_uls():
+    """
+    Nested ULs should alternate bullet characters.
+
+    """
+    assert md(nested_uls) == '\n* 1\n\t+ a\n\t\t- I\n\t\t- II\n\t\t- III\n\t+ b\n\t+ c\n* 2\n* 3\n'
+
+
+def test_bullets():
+    assert md(nested_uls, bullets='-') == '\n- 1\n\t- a\n\t\t- I\n\t\t- II\n\t\t- III\n\t- b\n\t- c\n- 2\n- 3\n'
+
+
+def test_li_text():
+    assert md('<ul><li>foo <a href="#">bar</a></li><li>foo bar  </li><li>foo <b>bar</b>   <i>space</i>.</ul>') == '* foo [bar](#)\n* foo bar\n* foo **bar** *space*.\n'

tests/test_tables.py

@@ -0,0 +1,130 @@
+from markdownify import markdownify as md
+
+
+table = """<table>
+    <tr>
+        <th>Firstname</th>
+        <th>Lastname</th>
+        <th>Age</th>
+    </tr>
+    <tr>
+        <td>Jill</td>
+        <td>Smith</td>
+        <td>50</td>
+    </tr>
+    <tr>
+        <td>Eve</td>
+        <td>Jackson</td>
+        <td>94</td>
+    </tr>
+</table>"""
+
+
+table_with_html_content = """<table>
+    <tr>
+        <th>Firstname</th>
+        <th>Lastname</th>
+        <th>Age</th>
+    </tr>
+    <tr>
+        <td><b>Jill</b></td>
+        <td><i>Smith</i></td>
+        <td><a href="#">50</a></td>
+    </tr>
+    <tr>
+        <td>Eve</td>
+        <td>Jackson</td>
+        <td>94</td>
+    </tr>
+</table>"""
+
+
+table_with_header_column = """<table>
+    <tr>
+        <th>Firstname</th>
+        <th>Lastname</th>
+        <th>Age</th>
+    </tr>
+    <tr>
+        <th>Jill</th>
+        <td>Smith</td>
+        <td>50</td>
+    </tr>
+    <tr>
+        <th>Eve</th>
+        <td>Jackson</td>
+        <td>94</td>
+    </tr>
+</table>"""
+
+
+table_head_body = """<table>
+    <thead>
+        <tr>
+            <th>Firstname</th>
+            <th>Lastname</th>
+            <th>Age</th>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <td>Jill</td>
+            <td>Smith</td>
+            <td>50</td>
+        </tr>
+        <tr>
+            <td>Eve</td>
+            <td>Jackson</td>
+            <td>94</td>
+        </tr>
+    </tbody>
+</table>"""
+
+table_missing_text = """<table>
+    <thead>
+        <tr>
+            <th></th>
+            <th>Lastname</th>
+            <th>Age</th>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <td>Jill</td>
+            <td></td>
+            <td>50</td>
+        </tr>
+        <tr>
+            <td>Eve</td>
+            <td>Jackson</td>
+            <td>94</td>
+        </tr>
+    </tbody>
+</table>"""
+
+table_missing_head = """<table>
+    <tr>
+        <td>Firstname</td>
+        <td>Lastname</td>
+        <td>Age</td>
+    </tr>
+    <tr>
+        <td>Jill</td>
+        <td>Smith</td>
+        <td>50</td>
+    </tr>
+    <tr>
+        <td>Eve</td>
+        <td>Jackson</td>
+        <td>94</td>
+    </tr>
+</table>"""
+
+
+def test_table():
+    assert md(table) == '\n\n| Firstname | Lastname | Age |\n| --- | --- | --- |\n| Jill | Smith | 50 |\n| Eve | Jackson | 94 |\n\n'
+    assert md(table_with_html_content) == '\n\n| Firstname | Lastname | Age |\n| --- | --- | --- |\n| **Jill** | *Smith* | [50](#) |\n| Eve | Jackson | 94 |\n\n'
+    assert md(table_with_header_column) == '\n\n| Firstname | Lastname | Age |\n| --- | --- | --- |\n| Jill | Smith | 50 |\n| Eve | Jackson | 94 |\n\n'
+    assert md(table_head_body) == '\n\n| Firstname | Lastname | Age |\n| --- | --- | --- |\n| Jill | Smith | 50 |\n| Eve | Jackson | 94 |\n\n'
+    assert md(table_missing_text) == '\n\n|  | Lastname | Age |\n| --- | --- | --- |\n| Jill |  | 50 |\n| Eve | Jackson | 94 |\n\n'
+    assert md(table_missing_head) == '\n\n|  |  |  |\n| --- | --- | --- |\n| Firstname | Lastname | Age |\n| Jill | Smith | 50 |\n| Eve | Jackson | 94 |\n\n'