Merge branch 'develop'

.github/workflows/python-app.yml

@@ -23,10 +23,11 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install --upgrade setuptools setuptools_scm wheel build tox
-    - name: Lint and test
+        pip install flake8==3.8.4 pytest
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Lint with flake8
       run: |
-        tox
-    - name: Build
+        python setup.py lint
+    - name: Test with pytest
       run: |
-        python -m build -nwsx .
+        python setup.py test

.github/workflows/python-publish.yml

@@ -21,11 +21,11 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install --upgrade setuptools setuptools_scm wheel build twine
+        pip install setuptools wheel twine
     - name: Build and publish
       env:
         TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
         TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
       run: |
-        python -m build -nwsx .
+        python setup.py sdist bdist_wheel
         twine upload dist/*

.gitignore

@@ -9,4 +9,3 @@
 /venv
 build/
 .vscode/settings.json
-.tox/

MANIFEST.in

@@ -1,2 +1 @@
 include README.rst
-prune tests

README.rst

@@ -1,8 +1,8 @@
 |build| |version| |license| |downloads|
 
-.. |build| image:: https://img.shields.io/github/actions/workflow/status/matthewwithanm/python-markdownify/python-app.yml?branch=develop
+.. |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/workflows/python-app.yml?query=workflow%3A%22Python+application%22
+    :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
@@ -32,14 +32,14 @@ Convert some HTML to Markdown:
     from markdownify import markdownify as md
     md('<b>Yay</b> <a href="http://github.com">GitHub</a>')  # > '**Yay** [GitHub](http://github.com)'
 
-Specify tags to exclude:
+Specify tags to exclude (blacklist):
 
 .. code:: python
 
     from markdownify import markdownify as md
     md('<b>Yay</b> <a href="http://github.com">GitHub</a>', strip=['a'])  # > '**Yay** GitHub'
 
-\...or specify the tags you want to include:
+\...or specify the tags you want to include (whitelist):
 
 .. code:: python
 
@@ -53,11 +53,11 @@ Options
 Markdownify supports the following options:
 
 strip
-  A list of tags to strip. This option can't be used with the
+  A list of tags to strip (blacklist). This option can't be used with the
   ``convert`` option.
 
 convert
-  A list of tags to convert. This option can't be used with the
+  A list of tags to convert (whitelist). This option can't be used with the
   ``strip`` option.
 
 autolinks
@@ -87,16 +87,12 @@ strong_em_symbol
 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^``.  If the value starts
-  with ``<`` and ends with ``>``, it is treated as an HTML tag and a ``/`` is
-  inserted after the ``<`` in the string used after the text; this allows
-  specifying ``<sub>`` to use raw HTML in the output for subscripts, for
-  example.
+  ``~`` 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 and a
+  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.
 
@@ -106,71 +102,16 @@ code_language
   should be annotated with `````python`` or similar.
   Defaults to ``''`` (empty string) and can be any string.
 
-code_language_callback
-  When the HTML code contains ``pre`` tags that in some way provide the code
-  language, for example as class, this callback can be used to extract the
-  language from the tag and prefix it to the converted ``pre`` tag.
-  The callback gets one single argument, an BeautifylSoup object, and returns
-  a string containing the code language, or ``None``.
-  An example to use the class name as code language could be::
-
-    def callback(el):
-        return el['class'][0] if el.has_attr('class') else None
-
-  Defaults to ``None``.
-
-escape_asterisks
-  If set to ``False``, do not escape ``*`` to ``\*`` in text.
-  Defaults to ``True``.
-
-escape_underscores
-  If set to ``False``, do not escape ``_`` to ``\_`` in text.
-  Defaults to ``True``.
-
-escape_misc
-  If set to ``False``, do not escape miscellaneous punctuation characters
-  that sometimes have Markdown significance in text.
-  Defaults to ``True``.
-
-keep_inline_images_in
-  Images are converted to their alt-text when the images are located inside
-  headlines or table cells. If some inline images should be converted to
-  markdown images instead, this option can be set to a list of parent tags
-  that should be allowed to contain inline images, for example ``['td']``.
-  Defaults to an empty list.
-
-wrap, wrap_width
-  If ``wrap`` is set to ``True``, all text paragraphs are wrapped at
-  ``wrap_width`` characters. Defaults to ``False`` and ``80``.
-  Use with ``newline_style=BACKSLASH`` to keep line breaks in paragraphs.
-
 Options may be specified as kwargs to the ``markdownify`` function, or as a
 nested ``Options`` class in ``MarkdownConverter`` subclasses.
 
 
-Converting BeautifulSoup objects
-================================
-
-.. code:: python
-
-    from markdownify import MarkdownConverter
-
-    # Create shorthand method for conversion
-    def md(soup, **options):
-        return MarkdownConverter(**options).convert_soup(soup)
-
-
 Creating Custom Converters
 ==========================
 
 If you have a special usecase that calls for a special conversion, you can
 always inherit from ``MarkdownConverter`` and override the method you want to
-change.
-The function that handles a HTML tag named ``abc`` is called
-``convert_abc(self, el, text, convert_as_inline)`` and returns a string
-containing the converted HTML tag.
-The ``MarkdownConverter`` object will handle the conversion based on the
-function names:
+change:
 
 .. code:: python
 
@@ -187,32 +128,14 @@ function names:
     def md(html, **options):
         return ImageBlockConverter(**options).convert(html)
 
-.. code:: python
-
-    from markdownify import MarkdownConverter
-
-    class IgnoreParagraphsConverter(MarkdownConverter):
-        """
-        Create a custom MarkdownConverter that ignores paragraphs
-        """
-        def convert_p(self, el, text, convert_as_inline):
-            return ''
-
-    # Create shorthand method for conversion
-    def md(html, **options):
-        return IgnoreParagraphsConverter(**options).convert(html)
-
-
-Command Line Interface
-======================
-
-Use ``markdownify example.html > example.md`` or pipe input from stdin
-(``cat example.html | markdownify > example.md``).
-Call ``markdownify -h`` to see all available options.
-They are the same as listed above and take the same arguments.
-
 
 Development
 ===========
 
-To run tests and the linter run ``pip install tox`` once, then ``tox``.
+To run tests:
+
+``python setup.py test``
+
+To lint:
+
+``python setup.py lint``

markdownify/__init__.py

@@ -1,5 +1,4 @@
 from bs4 import BeautifulSoup, NavigableString, Comment, Doctype
-from textwrap import fill
 import re
 import six
 
@@ -26,6 +25,12 @@ ASTERISK = '*'
 UNDERSCORE = '_'
 
 
+def escape(text):
+    if not text:
+        return ''
+    return text.replace('_', r'\_')
+
+
 def chomp(text):
     """
     If the text in an inline tag like b, a, or em contains a leading or trailing
@@ -43,22 +48,15 @@ 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, with '/' inserted in the string used after
-    the text if it looks like an HTML tag. markup_fn is necessary to allow for
+    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_prefix = markup_fn(self)
-        if markup_prefix.startswith('<') and markup_prefix.endswith('>'):
-            markup_suffix = '</' + markup_prefix[1:]
-        else:
-            markup_suffix = markup_prefix
-        if el.find_parent(['pre', 'code', 'kbd', 'samp']):
-            return text
+        markup = markup_fn(self)
         prefix, suffix, text = chomp(text)
         if not text:
             return ''
-        return '%s%s%s%s%s' % (prefix, markup_prefix, text, markup_suffix, suffix)
+        return '%s%s%s%s%s' % (prefix, markup, text, markup, suffix)
     return implementation
 
 
@@ -70,22 +68,15 @@ class MarkdownConverter(object):
     class DefaultOptions:
         autolinks = True
         bullets = '*+-'  # An iterable of bullet types.
-        code_language = ''
-        code_language_callback = None
         convert = None
         default_title = False
-        escape_asterisks = True
-        escape_underscores = True
-        escape_misc = True
         heading_style = UNDERLINED
-        keep_inline_images_in = []
         newline_style = SPACES
         strip = None
         strong_em_symbol = ASTERISK
         sub_symbol = ''
         sup_symbol = ''
-        wrap = False
-        wrap_width = 80
+        code_language = ''
 
     class Options(DefaultOptions):
         pass
@@ -102,9 +93,6 @@ class MarkdownConverter(object):
 
     def convert(self, html):
         soup = BeautifulSoup(html, 'html.parser')
-        return self.convert_soup(soup)
-
-    def convert_soup(self, soup):
         return self.process_tag(soup, convert_as_inline=False, children_only=True)
 
     def process_tag(self, node, convert_as_inline, children_only=False):
@@ -160,13 +148,14 @@ class MarkdownConverter(object):
     def process_text(self, el):
         text = six.text_type(el) or ''
 
-        # normalize whitespace if we're not inside a preformatted element
-        if not el.find_parent('pre'):
+        # dont remove any whitespace when handling pre or code in pre
+        if not (el.parent.name == 'pre'
+                or (el.parent.name == 'code'
+                    and el.parent.parent.name == 'pre')):
             text = whitespace_re.sub(' ', text)
 
-        # escape special characters if we're not inside a preformatted or code element
-        if not el.find_parent(['pre', 'code', 'kbd', 'samp']):
-            text = self.escape(text)
+        if el.parent.name != 'code':
+            text = escape(text)
 
         # remove trailing whitespaces if any of the following condition is true:
         # - current text node is the last node in li
@@ -204,18 +193,6 @@ class MarkdownConverter(object):
         else:
             return True
 
-    def escape(self, text):
-        if not text:
-            return ''
-        if self.options['escape_misc']:
-            text = re.sub(r'([\\&<`[>~#=+|-])', r'\\\1', text)
-            text = re.sub(r'([0-9])([.)])', r'\1\\\2', text)
-        if self.options['escape_asterisks']:
-            text = text.replace('*', r'\*')
-        if self.options['escape_underscores']:
-            text = text.replace('_', r'\_')
-        return text
-
     def indent(self, text, level):
         return line_beginning_re.sub('\t' * level, text) if text else ''
 
@@ -248,7 +225,7 @@ class MarkdownConverter(object):
         if convert_as_inline:
             return text
 
-        return '\n' + (line_beginning_re.sub('> ', text.strip()) + '\n\n') if text else ''
+        return '\n' + (line_beginning_re.sub('> ', text) + '\n\n') if text else ''
 
     def convert_br(self, el, text, convert_as_inline):
         if convert_as_inline:
@@ -276,7 +253,7 @@ class MarkdownConverter(object):
             return text
 
         style = self.options['heading_style'].lower()
-        text = text.strip()
+        text = text.rstrip()
         if style == UNDERLINED and n <= 2:
             line = '=' if n == 1 else '-'
             return self.underline(text, line)
@@ -295,8 +272,7 @@ class MarkdownConverter(object):
         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
-                and el.parent.name not in self.options['keep_inline_images_in']):
+        if convert_as_inline:
             return alt
 
         return '![%s](%s%s)' % (alt, src, title_part)
@@ -326,7 +302,7 @@ class MarkdownConverter(object):
     def convert_li(self, el, text, convert_as_inline):
         parent = el.parent
         if parent is not None and parent.name == 'ol':
-            if parent.get("start") and str(parent.get("start")).isnumeric():
+            if parent.get("start"):
                 start = int(parent.get("start"))
             else:
                 start = 1
@@ -344,28 +320,12 @@ class MarkdownConverter(object):
     def convert_p(self, el, text, convert_as_inline):
         if convert_as_inline:
             return text
-        if self.options['wrap']:
-            text = fill(text,
-                        width=self.options['wrap_width'],
-                        break_long_words=False,
-                        break_on_hyphens=False)
         return '%s\n\n' % text if text else ''
 
     def convert_pre(self, el, text, convert_as_inline):
         if not text:
             return ''
-        code_language = self.options['code_language']
-
-        if self.options['code_language_callback']:
-            code_language = self.options['code_language_callback'](el) or code_language
-
-        return '\n```%s\n%s\n```\n' % (code_language, text)
-
-    def convert_script(self, el, text, convert_as_inline):
-        return ''
-
-    def convert_style(self, el, text, convert_as_inline):
-        return ''
+        return '\n```%s\n%s\n```\n' % (self.options['code_language'], text)
 
     convert_s = convert_del
 
@@ -380,49 +340,22 @@ class MarkdownConverter(object):
     def convert_table(self, el, text, convert_as_inline):
         return '\n\n' + text + '\n'
 
-    def convert_caption(self, el, text, convert_as_inline):
-        return text + '\n'
-
-    def convert_figcaption(self, el, text, convert_as_inline):
-        return '\n\n' + text + '\n\n'
-
     def convert_td(self, el, text, convert_as_inline):
-        colspan = 1
-        if 'colspan' in el.attrs and el['colspan'].isdigit():
-            colspan = int(el['colspan'])
-        return ' ' + text.strip().replace("\n", " ") + ' |' * colspan
+        return ' ' + text + ' |'
 
     def convert_th(self, el, text, convert_as_inline):
-        colspan = 1
-        if 'colspan' in el.attrs and el['colspan'].isdigit():
-            colspan = int(el['colspan'])
-        return ' ' + text.strip().replace("\n", " ") + ' |' * colspan
+        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])
-            or (not el.previous_sibling and not el.parent.name == 'tbody')
-            or (not el.previous_sibling and el.parent.name == 'tbody' and len(el.parent.parent.find_all(['thead'])) < 1)
-        )
+        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
-            full_colspan = 0
-            for cell in cells:
-                if 'colspan' in cell.attrs and cell['colspan'].isdigit():
-                    full_colspan += int(cell["colspan"])
-                else:
-                    full_colspan += 1
-            underline += '| ' + ' | '.join(['---'] * full_colspan) + ' |' + '\n'
-        elif (not el.previous_sibling
-              and (el.parent.name == 'table'
-                   or (el.parent.name == 'tbody'
-                       and not el.parent.previous_sibling))):
-            # first row, not headline, and:
-            # - the parent is table or
-            # - the parent is tbody at the beginning of a table.
+            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'

markdownify/main.py

@@ -1,73 +0,0 @@
-#!/usr/bin/env python
-
-import argparse
-import sys
-
-from markdownify import markdownify, ATX, ATX_CLOSED, UNDERLINED, \
-    SPACES, BACKSLASH, ASTERISK, UNDERSCORE
-
-
-def main(argv=sys.argv[1:]):
-    parser = argparse.ArgumentParser(
-        prog='markdownify',
-        description='Converts html to markdown.',
-    )
-
-    parser.add_argument('html', nargs='?', type=argparse.FileType('r'),
-                        default=sys.stdin,
-                        help="The html file to convert. Defaults to STDIN if not "
-                        "provided.")
-    parser.add_argument('-s', '--strip', nargs='*',
-                        help="A list of tags to strip. This option can't be used with "
-                        "the --convert option.")
-    parser.add_argument('-c', '--convert', nargs='*',
-                        help="A list of tags to convert. This option can't be used with "
-                        "the --strip option.")
-    parser.add_argument('-a', '--autolinks', action='store_true',
-                        help="A boolean indicating whether the 'automatic link' style "
-                        "should be used when a 'a' tag's contents match its href.")
-    parser.add_argument('--default-title', action='store_false',
-                        help="A boolean to enable setting the title of a link to its "
-                        "href, if no title is given.")
-    parser.add_argument('--heading-style', default=UNDERLINED,
-                        choices=(ATX, ATX_CLOSED, UNDERLINED),
-                        help="Defines how headings should be converted.")
-    parser.add_argument('-b', '--bullets', default='*+-',
-                        help="A string of bullet styles to use; the bullet will "
-                        "alternate based on nesting level.")
-    parser.add_argument('--strong-em-symbol', default=ASTERISK,
-                        choices=(ASTERISK, UNDERSCORE),
-                        help="Use * or _ to convert strong and italics text"),
-    parser.add_argument('--sub-symbol', default='',
-                        help="Define the chars that surround '<sub>'.")
-    parser.add_argument('--sup-symbol', default='',
-                        help="Define the chars that surround '<sup>'.")
-    parser.add_argument('--newline-style', default=SPACES,
-                        choices=(SPACES, BACKSLASH),
-                        help="Defines the style of <br> conversions: two spaces "
-                        "or backslash at the and of the line thet should break.")
-    parser.add_argument('--code-language', default='',
-                        help="Defines the language that should be assumed for all "
-                        "'<pre>' sections.")
-    parser.add_argument('--no-escape-asterisks', dest='escape_asterisks',
-                        action='store_false',
-                        help="Do not escape '*' to '\\*' in text.")
-    parser.add_argument('--no-escape-underscores', dest='escape_underscores',
-                        action='store_false',
-                        help="Do not escape '_' to '\\_' in text.")
-    parser.add_argument('-i', '--keep-inline-images-in', nargs='*',
-                        help="Images are converted to their alt-text when the images are "
-                        "located inside headlines or table cells. If some inline images "
-                        "should be converted to markdown images instead, this option can "
-                        "be set to a list of parent tags that should be allowed to "
-                        "contain inline images.")
-    parser.add_argument('-w', '--wrap', action='store_true',
-                        help="Wrap all text paragraphs at --wrap-width characters.")
-    parser.add_argument('--wrap-width', type=int, default=80)
-
-    args = parser.parse_args(argv)
-    print(markdownify(**vars(args)))
-
-
-if __name__ == '__main__':
-    main()

pyproject.toml

@@ -1,45 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.2", "setuptools_scm[toml]>=3.4.3"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "markdownify"
-version = "0.13.0"
-authors = [{name = "Matthew Tretter", email = "m@tthewwithanm.com"}]
-description = "Convert HTML to markdown."
-readme = "README.rst"
-classifiers = [
-    "Environment :: Web Environment",
-    "Framework :: Django",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Operating System :: OS Independent",
-    "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",
-]
-dependencies = [
-    "beautifulsoup4>=4.9,<5",
-    "six>=1.15,<2"
-]
-
-[project.urls]
-Homepage = "http://github.com/matthewwithanm/python-markdownify"
-Download = "http://github.com/matthewwithanm/python-markdownify/tarball/master"
-
-[project.scripts]
-markdownify = "markdownify.main:main"
-
-[tool.setuptools]
-zip-safe = false
-include-package-data = true
-
-[tool.setuptools.packages.find]
-include = ["markdownify", "markdownify.*"]
-namespaces = false
-
-[tool.setuptools_scm]

setup.cfg

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

setup.py

@@ -0,0 +1,99 @@
+#/usr/bin/env python
+import codecs
+import os
+from setuptools import setup, find_packages
+from setuptools.command.test import test as TestCommand, Command
+
+
+read = lambda filepath: codecs.open(filepath, 'r', 'utf-8').read()
+
+pkgmeta = {
+    '__title__': 'markdownify',
+    '__author__': 'Matthew Tretter',
+    '__version__': '0.10.1',
+}
+
+
+class PyTest(TestCommand):
+    def finalize_options(self):
+        TestCommand.finalize_options(self)
+        self.test_args = ['tests', '-s']
+        self.test_suite = True
+
+    def run_tests(self):
+        import pytest
+        errno = pytest.main(self.test_args)
+        raise SystemExit(errno)
+
+
+class LintCommand(Command):
+    """
+    A copy of flake8's Flake8Command
+
+    """
+    description = "Run flake8 on modules registered in setuptools"
+    user_options = []
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def distribution_files(self):
+        if self.distribution.packages:
+            for package in self.distribution.packages:
+                yield package.replace(".", os.path.sep)
+
+        if self.distribution.py_modules:
+            for filename in self.distribution.py_modules:
+                yield "%s.py" % filename
+
+    def run(self):
+        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)
+        raise SystemExit(report.total_errors > 0)
+
+
+setup(
+    name='markdownify',
+    description='Convert HTML to markdown.',
+    long_description=read(os.path.join(os.path.dirname(__file__), 'README.rst')),
+    version=pkgmeta['__version__'],
+    author=pkgmeta['__author__'],
+    author_email='m@tthewwithanm.com',
+    url='http://github.com/matthewwithanm/python-markdownify',
+    download_url='http://github.com/matthewwithanm/python-markdownify/tarball/master',
+    packages=find_packages(),
+    zip_safe=False,
+    include_package_data=True,
+    setup_requires=[
+        'flake8>=3.8,<5',
+    ],
+    tests_require=[
+        'pytest>=6.2,<7',
+    ],
+    install_requires=[
+        'beautifulsoup4>=4.9,<5', 'six>=1.15,<2'
+    ],
+    classifiers=[
+        'Environment :: Web Environment',
+        'Framework :: Django',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+        '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={
+        'test': PyTest,
+        'lint': LintCommand,
+    },
+)

shell.nix

@@ -1,10 +0,0 @@
-{ pkgs ? import <nixpkgs> {} }:
-pkgs.mkShell {
-  name = "python-shell";
-  buildInputs = with pkgs; [
-    python38
-    python38Packages.tox
-    python38Packages.setuptools
-    python38Packages.virtualenv
-  ];
-}

tests/test_conversions.py

@@ -52,12 +52,6 @@ def test_b_spaces():
 
 def test_blockquote():
     assert md('<blockquote>Hello</blockquote>') == '\n> Hello\n\n'
-    assert md('<blockquote>\nHello\n</blockquote>') == '\n> Hello\n\n'
-
-
-def test_blockquote_with_nested_paragraph():
-    assert md('<blockquote><p>Hello</p></blockquote>') == '\n> Hello\n\n'
-    assert md('<blockquote><p>Hello</p><p>Hello again</p></blockquote>') == '\n> Hello\n> \n> Hello again\n\n'
 
 
 def test_blockquote_with_paragraph():
@@ -66,7 +60,7 @@ def test_blockquote_with_paragraph():
 
 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'
+    assert text == '\n> And she was like \n> > Hello\n> \n> \n\n'
 
 
 def test_br():
@@ -74,29 +68,9 @@ def test_br():
     assert md('a<br />b<br />c', newline_style=BACKSLASH) == 'a\\\nb\\\nc'
 
 
-def test_caption():
-    assert md('TEXT<figure><figcaption>Caption</figcaption><span>SPAN</span></figure>') == 'TEXT\n\nCaption\n\nSPAN'
-    assert md('<figure><span>SPAN</span><figcaption>Caption</figcaption></figure>TEXT') == 'SPAN\n\nCaption\n\nTEXT'
-
-
 def test_code():
     inline_tests('code', '`')
-    assert md('<code>*this_should_not_escape*</code>') == '`*this_should_not_escape*`'
-    assert md('<kbd>*this_should_not_escape*</kbd>') == '`*this_should_not_escape*`'
-    assert md('<samp>*this_should_not_escape*</samp>') == '`*this_should_not_escape*`'
-    assert md('<code><span>*this_should_not_escape*</span></code>') == '`*this_should_not_escape*`'
-    assert md('<code>this  should\t\tnormalize</code>') == '`this should normalize`'
-    assert md('<code><span>this  should\t\tnormalize</span></code>') == '`this should normalize`'
-    assert md('<code>foo<b>bar</b>baz</code>') == '`foobarbaz`'
-    assert md('<kbd>foo<i>bar</i>baz</kbd>') == '`foobarbaz`'
-    assert md('<samp>foo<del> bar </del>baz</samp>') == '`foo bar baz`'
-    assert md('<samp>foo <del>bar</del> baz</samp>') == '`foo bar baz`'
-    assert md('<code>foo<em> bar </em>baz</code>') == '`foo bar baz`'
-    assert md('<code>foo<code> bar </code>baz</code>') == '`foo bar baz`'
-    assert md('<code>foo<strong> bar </strong>baz</code>') == '`foo bar baz`'
-    assert md('<code>foo<s> bar </s>baz</code>') == '`foo bar baz`'
-    assert md('<code>foo<sup>bar</sup>baz</code>', sup_symbol='^') == '`foobarbaz`'
-    assert md('<code>foo<sub>bar</sub>baz</code>', sub_symbol='^') == '`foobarbaz`'
+    assert md('<code>this_should_not_escape</code>') == '`this_should_not_escape`'
 
 
 def test_del():
@@ -111,14 +85,6 @@ def test_em():
     inline_tests('em', '*')
 
 
-def test_header_with_space():
-    assert md('<h3>\n\nHello</h3>') == '### Hello\n\n'
-    assert md('<h4>\n\nHello</h4>') == '#### Hello\n\n'
-    assert md('<h5>\n\nHello</h5>') == '##### Hello\n\n'
-    assert md('<h5>\n\nHello\n\n</h5>') == '##### Hello\n\n'
-    assert md('<h5>\n\nHello   \n\n</h5>') == '##### Hello\n\n'
-
-
 def test_h1():
     assert md('<h1>Hello</h1>') == 'Hello\n=====\n\n'
 
@@ -167,13 +133,12 @@ def test_hn_nested_simple_tag():
 
 def test_hn_nested_img():
     image_attributes_to_markdown = [
-        ("", "", ""),
-        ("alt='Alt Text'", "Alt Text", ""),
-        ("alt='Alt Text' title='Optional title'", "Alt Text", " \"Optional title\""),
+        ("", ""),
+        ("alt='Alt Text'", "Alt Text"),
+        ("alt='Alt Text' title='Optional title'", "Alt Text"),
     ]
-    for image_attributes, markdown, title in image_attributes_to_markdown:
-        assert md('<h3>A <img src="/path/to/img.jpg" ' + image_attributes + '/> B</h3>') == '### A ' + markdown + ' B\n\n'
-        assert md('<h3>A <img src="/path/to/img.jpg" ' + image_attributes + '/> B</h3>', keep_inline_images_in=['h3']) == '### A ![' + markdown + '](/path/to/img.jpg' + title + ') B\n\n'
+    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():
@@ -211,39 +176,11 @@ def test_kbd():
 
 def test_p():
     assert md('<p>hello</p>') == 'hello\n\n'
-    assert md('<p>123456789 123456789</p>') == '123456789 123456789\n\n'
-    assert md('<p>123456789 123456789</p>', wrap=True, wrap_width=10) == '123456789\n123456789\n\n'
-    assert md('<p><a href="https://example.com">Some long link</a></p>', wrap=True, wrap_width=10) == '[Some long\nlink](https://example.com)\n\n'
-    assert md('<p>12345<br />67890</p>', wrap=True, wrap_width=10, newline_style=BACKSLASH) == '12345\\\n67890\n\n'
-    assert md('<p>12345678901<br />12345</p>', wrap=True, wrap_width=10, newline_style=BACKSLASH) == '12345678901\\\n12345\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'
-    assert md('<pre>*this_should_not_escape*</pre>') == '\n```\n*this_should_not_escape*\n```\n'
-    assert md('<pre><span>*this_should_not_escape*</span></pre>') == '\n```\n*this_should_not_escape*\n```\n'
-    assert md('<pre>\t\tthis  should\t\tnot  normalize</pre>') == '\n```\n\t\tthis  should\t\tnot  normalize\n```\n'
-    assert md('<pre><span>\t\tthis  should\t\tnot  normalize</span></pre>') == '\n```\n\t\tthis  should\t\tnot  normalize\n```\n'
-    assert md('<pre>foo<b>\nbar\n</b>baz</pre>') == '\n```\nfoo\nbar\nbaz\n```\n'
-    assert md('<pre>foo<i>\nbar\n</i>baz</pre>') == '\n```\nfoo\nbar\nbaz\n```\n'
-    assert md('<pre>foo\n<i>bar</i>\nbaz</pre>') == '\n```\nfoo\nbar\nbaz\n```\n'
-    assert md('<pre>foo<i>\n</i>baz</pre>') == '\n```\nfoo\nbaz\n```\n'
-    assert md('<pre>foo<del>\nbar\n</del>baz</pre>') == '\n```\nfoo\nbar\nbaz\n```\n'
-    assert md('<pre>foo<em>\nbar\n</em>baz</pre>') == '\n```\nfoo\nbar\nbaz\n```\n'
-    assert md('<pre>foo<code>\nbar\n</code>baz</pre>') == '\n```\nfoo\nbar\nbaz\n```\n'
-    assert md('<pre>foo<strong>\nbar\n</strong>baz</pre>') == '\n```\nfoo\nbar\nbaz\n```\n'
-    assert md('<pre>foo<s>\nbar\n</s>baz</pre>') == '\n```\nfoo\nbar\nbaz\n```\n'
-    assert md('<pre>foo<sup>\nbar\n</sup>baz</pre>', sup_symbol='^') == '\n```\nfoo\nbar\nbaz\n```\n'
-    assert md('<pre>foo<sub>\nbar\n</sub>baz</pre>', sub_symbol='^') == '\n```\nfoo\nbar\nbaz\n```\n'
-
-
-def test_script():
-    assert md('foo <script>var foo=42;</script> bar') == 'foo  bar'
-
-
-def test_style():
-    assert md('foo <style>h1 { font-size: larger }</style> bar') == 'foo  bar'
 
 
 def test_s():
@@ -268,24 +205,13 @@ def test_strong_em_symbol():
 def test_sub():
     assert md('<sub>foo</sub>') == 'foo'
     assert md('<sub>foo</sub>', sub_symbol='~') == '~foo~'
-    assert md('<sub>foo</sub>', sub_symbol='<sub>') == '<sub>foo</sub>'
 
 
 def test_sup():
     assert md('<sup>foo</sup>') == 'foo'
     assert md('<sup>foo</sup>', sup_symbol='^') == '^foo^'
-    assert md('<sup>foo</sup>', sup_symbol='<sup>') == '<sup>foo</sup>'
 
 
 def test_lang():
     assert md('<pre>test\n    foo\nbar</pre>', code_language='python') == '\n```python\ntest\n    foo\nbar\n```\n'
     assert md('<pre><code>test\n    foo\nbar</code></pre>', code_language='javascript') == '\n```javascript\ntest\n    foo\nbar\n```\n'
-
-
-def test_lang_callback():
-    def callback(el):
-        return el['class'][0] if el.has_attr('class') else None
-
-    assert md('<pre class="python">test\n    foo\nbar</pre>', code_language_callback=callback) == '\n```python\ntest\n    foo\nbar\n```\n'
-    assert md('<pre class="javascript"><code>test\n    foo\nbar</code></pre>', code_language_callback=callback) == '\n```javascript\ntest\n    foo\nbar\n```\n'
-    assert md('<pre class="javascript"><code class="javascript">test\n    foo\nbar</code></pre>', code_language_callback=callback) == '\n```javascript\ntest\n    foo\nbar\n```\n'

tests/test_custom_converter.py

@@ -1,5 +1,4 @@
 from markdownify import MarkdownConverter
-from bs4 import BeautifulSoup
 
 
 class ImageBlockConverter(MarkdownConverter):
@@ -17,9 +16,3 @@ 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")\n\n'
     assert md('<img src="/path/to/img.jpg" alt="Alt text" />') == '![Alt text](/path/to/img.jpg)\n\n'
-
-
-def test_soup():
-    html = '<b>test</b>'
-    soup = BeautifulSoup(html, 'html.parser')
-    assert MarkdownConverter().convert_soup(soup) == '**test**'

tests/test_escaping.py

@@ -1,18 +1,12 @@
 from markdownify import markdownify as md
 
 
-def test_asterisks():
-    assert md('*hey*dude*') == r'\*hey\*dude\*'
-    assert md('*hey*dude*', escape_asterisks=False) == r'*hey*dude*'
-
-
 def test_underscore():
     assert md('_hey_dude_') == r'\_hey\_dude\_'
-    assert md('_hey_dude_', escape_underscores=False) == r'_hey_dude_'
 
 
 def test_xml_entities():
-    assert md('&') == r'\&'
+    assert md('&') == '&'
 
 
 def test_named_entities():
@@ -25,23 +19,4 @@ def test_hexadecimal_entities():
 
 
 def test_single_escaping_entities():
-    assert md('&') == r'\&'
-
-
-def text_misc():
-    assert md('\\*') == r'\\\*'
-    assert md('<foo>') == r'\<foo\>'
-    assert md('# foo') == r'\# foo'
-    assert md('> foo') == r'\> foo'
-    assert md('~~foo~~') == r'\~\~foo\~\~'
-    assert md('foo\n===\n') == 'foo\n\\=\\=\\=\n'
-    assert md('---\n') == '\\-\\-\\-\n'
-    assert md('+ x\n+ y\n') == '\\+ x\n\\+ y\n'
-    assert md('`x`') == r'\`x\`'
-    assert md('[text](link)') == r'\[text](link)'
-    assert md('1. x') == r'1\. x'
-    assert md('not a number. x') == r'not a number. x'
-    assert md('1) x') == r'1\) x'
-    assert md('not a number) x') == r'not a number) x'
-    assert md('|not table|') == r'\|not table\|'
-    assert md(r'\ <foo> &amp;amp; | ` `', escape_misc=False) == r'\ <foo> &amp; | ` `'
+    assert md('&amp;amp;') == '&amp;'

tests/test_lists.py

@@ -43,9 +43,6 @@ nested_ols = """
 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'
-    assert md('<ol start="-1"><li>a</li><li>b</li></ol>') == '1. a\n2. b\n'
-    assert md('<ol start="foo"><li>a</li><li>b</li></ol>') == '1. a\n2. b\n'
-    assert md('<ol start="1.5"><li>a</li><li>b</li></ol>') == '1. a\n2. b\n'
 
 
 def test_nested_ols():

tests/test_tables.py

@@ -57,26 +57,6 @@ table_with_paragraphs = """<table>
     </tr>
 </table>"""
 
-table_with_linebreaks = """<table>
-    <tr>
-        <th>Firstname</th>
-        <th>Lastname</th>
-        <th>Age</th>
-    </tr>
-    <tr>
-        <td>Jill</td>
-        <td>Smith
-        Jackson</td>
-        <td>50</td>
-    </tr>
-    <tr>
-        <td>Eve</td>
-        <td>Jackson
-        Smith</td>
-        <td>94</td>
-    </tr>
-</table>"""
-
 
 table_with_header_column = """<table>
     <tr>
@@ -119,28 +99,6 @@ table_head_body = """<table>
     </tbody>
 </table>"""
 
-table_head_body_missing_head = """<table>
-    <thead>
-        <tr>
-            <td>Firstname</td>
-            <td>Lastname</td>
-            <td>Age</td>
-        </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>
@@ -181,74 +139,12 @@ table_missing_head = """<table>
     </tr>
 </table>"""
 
-table_body = """<table>
-    <tbody>
-        <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>
-    </tbody>
-</table>"""
-
-table_with_caption = """TEXT<table><caption>Caption</caption>
-    <tbody><tr><td>Firstname</td>
-            <td>Lastname</td>
-            <td>Age</td>
-        </tr>
-    </tbody>
-</table>"""
-
-table_with_colspan = """<table>
-    <tr>
-        <th colspan="2">Name</th>
-        <th>Age</th>
-    </tr>
-    <tr>
-        <td colspan="1">Jill</td>
-        <td>Smith</td>
-        <td>50</td>
-    </tr>
-    <tr>
-        <td>Eve</td>
-        <td>Jackson</td>
-        <td>94</td>
-    </tr>
-</table>"""
-
-table_with_undefined_colspan = """<table>
-    <tr>
-        <th colspan="undefined">Name</th>
-        <th>Age</th>
-    </tr>
-    <tr>
-        <td colspan="-1">Jill</td>
-        <td>Smith</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_paragraphs) == '\n\n| Firstname | Lastname | Age |\n| --- | --- | --- |\n| Jill | Smith | 50 |\n| Eve | Jackson | 94 |\n\n'
-    assert md(table_with_linebreaks) == '\n\n| Firstname | Lastname | Age |\n| --- | --- | --- |\n| Jill | Smith  Jackson | 50 |\n| Eve | Jackson  Smith | 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_head_body_missing_head) == '\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| Firstname | Lastname | Age |\n| --- | --- | --- |\n| Jill | Smith | 50 |\n| Eve | Jackson | 94 |\n\n'
-    assert md(table_body) == '\n\n| Firstname | Lastname | Age |\n| --- | --- | --- |\n| Jill | Smith | 50 |\n| Eve | Jackson | 94 |\n\n'
-    assert md(table_with_caption) == 'TEXT\n\nCaption\n| Firstname | Lastname | Age |\n| --- | --- | --- |\n\n'
-    assert md(table_with_colspan) == '\n\n| Name | | Age |\n| --- | --- | --- |\n| Jill | Smith | 50 |\n| Eve | Jackson | 94 |\n\n'
-    assert md(table_with_undefined_colspan) == '\n\n| Name | Age |\n| --- | --- |\n| Jill | Smith |\n\n'
+    assert md(table_missing_head) == '\n\n|  |  |  |\n| --- | --- | --- |\n| Firstname | Lastname | Age |\n| Jill | Smith | 50 |\n| Eve | Jackson | 94 |\n\n'

tox.ini

@@ -1,15 +0,0 @@
-[tox]
-envlist = py38
-
-[testenv]
-passenv = PYTHONPATH
-deps =
-	pytest==8
-	flake8
-	restructuredtext_lint
-	Pygments
-commands =
-	pytest
-	flake8 --ignore=E501,W503 markdownify tests
-	restructuredtext-lint README.rst
-