Check in a simple pure-python based Markdown previewer.

third_party/Python-Markdown/markdown/serializers.py

-# markdown is released under the BSD license
-# Copyright 2007, 2008 The Python Markdown Project (v. 1.7 and later)
-# Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
-# Copyright 2004 Manfred Stienstra (the original version)
-# 
-# All rights reserved.
-# 
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-# 
-# *   Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer.
-# *   Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-# *   Neither the name of the <organization> nor the
-#     names of its contributors may be used to endorse or promote products
-#     derived from this software without specific prior written permission.
-# 
-# THIS SOFTWARE IS PROVIDED BY THE PYTHON MARKDOWN PROJECT ''AS IS'' AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL ANY CONTRIBUTORS TO THE PYTHON MARKDOWN PROJECT
-# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-
-
 # markdown/searializers.py
 #
 # Add x/html serialization to Elementree
 # Taken from ElementTree 1.3 preview with slight modifications
 #
 # Copyright (c) 1999-2007 by Fredrik Lundh.  All rights reserved.
 #
 # fredrik@pythonware.com
 # http://www.pythonware.com
 #
@@ skipping 24 matching lines @@
 # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 # OF THIS SOFTWARE.
 # --------------------------------------------------------------------
 
 
 from __future__ import absolute_import
 from __future__ import unicode_literals
 from . import util
 ElementTree = util.etree.ElementTree
 QName = util.etree.QName
-if hasattr(util.etree, 'test_comment'):
+if hasattr(util.etree, 'test_comment'):  # pragma: no cover
     Comment = util.etree.test_comment
-else:
+else:  # pragma: no cover
     Comment = util.etree.Comment
 PI = util.etree.PI
 ProcessingInstruction = util.etree.ProcessingInstruction
 
 __all__ = ['to_html_string', 'to_xhtml_string']
 
 HTML_EMPTY = ("area", "base", "basefont", "br", "col", "frame", "hr",
               "img", "input", "isindex", "link", "meta" "param")
 
 try:
     HTML_EMPTY = set(HTML_EMPTY)
-except NameError:
+except NameError:  # pragma: no cover
     pass
 
 _namespace_map = {
     # "well-known" namespace prefixes
     "http://www.w3.org/XML/1998/namespace": "xml",
     "http://www.w3.org/1999/xhtml": "html",
     "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf",
     "http://schemas.xmlsoap.org/wsdl/": "wsdl",
     # xml schema
     "http://www.w3.org/2001/XMLSchema": "xs",
     "http://www.w3.org/2001/XMLSchema-instance": "xsi",
     # dublic core
     "http://purl.org/dc/elements/1.1/": "dc",
 }
 
 
-def _raise_serialization_error(text):
+def _raise_serialization_error(text):  # pragma: no cover
     raise TypeError(
         "cannot serialize %r (type %s)" % (text, type(text).__name__)
         )
 
+
 def _encode(text, encoding):
     try:
         return text.encode(encoding, "xmlcharrefreplace")
-    except (TypeError, AttributeError):
+    except (TypeError, AttributeError):  # pragma: no cover
         _raise_serialization_error(text)
 
+
 def _escape_cdata(text):
     # escape character data
     try:
         # it's worth avoiding do-nothing calls for strings that are
         # shorter than 500 character, or so.  assume that's, by far,
         # the most common case in most applications.
         if "&" in text:
             text = text.replace("&", "&amp;")
         if "<" in text:
             text = text.replace("<", "&lt;")
         if ">" in text:
             text = text.replace(">", "&gt;")
         return text
-    except (TypeError, AttributeError):
+    except (TypeError, AttributeError):  # pragma: no cover
         _raise_serialization_error(text)
 
 
 def _escape_attrib(text):
     # escape attribute value
     try:
         if "&" in text:
             text = text.replace("&", "&amp;")
         if "<" in text:
             text = text.replace("<", "&lt;")
         if ">" in text:
             text = text.replace(">", "&gt;")
         if "\"" in text:
             text = text.replace("\"", "&quot;")
         if "\n" in text:
             text = text.replace("\n", "&#10;")
         return text
-    except (TypeError, AttributeError):
+    except (TypeError, AttributeError):  # pragma: no cover
         _raise_serialization_error(text)
 
+
 def _escape_attrib_html(text):
     # escape attribute value
     try:
         if "&" in text:
             text = text.replace("&", "&amp;")
         if "<" in text:
             text = text.replace("<", "&lt;")
         if ">" in text:
             text = text.replace(">", "&gt;")
         if "\"" in text:
             text = text.replace("\"", "&quot;")
         return text
-    except (TypeError, AttributeError):
+    except (TypeError, AttributeError):  # pragma: no cover
         _raise_serialization_error(text)
 
 
 def _serialize_html(write, elem, qnames, namespaces, format):
     tag = elem.tag
     text = elem.text
     if tag is Comment:
         write("<!--%s-->" % _escape_cdata(text))
     elif tag is ProcessingInstruction:
         write("<?%s?>" % _escape_cdata(text))
     else:
         tag = qnames[tag]
         if tag is None:
             if text:
                 write(_escape_cdata(text))
             for e in elem:
                 _serialize_html(write, e, qnames, None, format)
         else:
             write("<" + tag)
             items = elem.items()
             if items or namespaces:
-                items.sort() # lexical order
+                items = sorted(items)  # lexical order
                 for k, v in items:
                     if isinstance(k, QName):
                         k = k.text
                     if isinstance(v, QName):
                         v = qnames[v.text]
                     else:
                         v = _escape_attrib_html(v)
                     if qnames[k] == v and format == 'html':
                         # handle boolean attributes
                         write(" %s" % v)
                     else:
                         write(" %s=\"%s\"" % (qnames[k], v))
                 if namespaces:
                     items = namespaces.items()
-                    items.sort(key=lambda x: x[1]) # sort on prefix
+                    items.sort(key=lambda x: x[1])  # sort on prefix
                     for v, k in items:
                         if k:
                             k = ":" + k
                         write(" xmlns%s=\"%s\"" % (k, _escape_attrib(v)))
-            if format == "xhtml" and tag in HTML_EMPTY:
+            if format == "xhtml" and tag.lower() in HTML_EMPTY:
                 write(" />")
             else:
                 write(">")
-                tag = tag.lower()
                 if text:
-                    if tag == "script" or tag == "style":
+                    if tag.lower() in ["script", "style"]:
                         write(text)
                     else:
                         write(_escape_cdata(text))
                 for e in elem:
                     _serialize_html(write, e, qnames, None, format)
-                if tag not in HTML_EMPTY:
+                if tag.lower() not in HTML_EMPTY:
                     write("</" + tag + ">")
     if elem.tail:
         write(_escape_cdata(elem.tail))
 
+
 def _write_html(root,
                 encoding=None,
                 default_namespace=None,
                 format="html"):
     assert root is not None
     data = []
     write = data.append
     qnames, namespaces = _namespaces(root, default_namespace)
     _serialize_html(write, root, qnames, namespaces, format)
     if encoding is None:
@@ skipping 24 matching lines @@
                 prefix = namespaces.get(uri)
                 if prefix is None:
                     prefix = _namespace_map.get(uri)
                     if prefix is None:
                         prefix = "ns%d" % len(namespaces)
                     if prefix != "xml":
                         namespaces[uri] = prefix
                 if prefix:
                     qnames[qname] = "%s:%s" % (prefix, tag)
                 else:
-                    qnames[qname] = tag # default element
+                    qnames[qname] = tag  # default element
             else:
                 if default_namespace:
                     raise ValueError(
                         "cannot use non-qualified names with "
                         "default_namespace option"
                         )
                 qnames[qname] = qname
-        except TypeError:
+        except TypeError:  # pragma: no cover
             _raise_serialization_error(qname)
 
     # populate qname and namespaces table
     try:
         iterate = elem.iter
     except AttributeError:
-        iterate = elem.getiterator # cET compatibility
+        iterate = elem.getiterator  # cET compatibility
     for elem in iterate():
         tag = elem.tag
         if isinstance(tag, QName) and tag.text not in qnames:
             add_qname(tag.text)
         elif isinstance(tag, util.string_type):
             if tag not in qnames:
                 add_qname(tag)
         elif tag is not None and tag is not Comment and tag is not PI:
             _raise_serialization_error(tag)
         for key, value in elem.items():
             if isinstance(key, QName):
                 key = key.text
             if key not in qnames:
                 add_qname(key)
             if isinstance(value, QName) and value.text not in qnames:
                 add_qname(value.text)
         text = elem.text
         if isinstance(text, QName) and text.text not in qnames:
             add_qname(text.text)
     return qnames, namespaces
 
+
 def to_html_string(element):
     return _write_html(ElementTree(element).getroot(), format="html")
 
+
 def to_xhtml_string(element):
     return _write_html(ElementTree(element).getroot(), format="xhtml")