Cleaned up some shitespace - all colons (:) are consistantly spaced and other minor things

1 files changed, 300 insertions, 300 deletions

diff --git a/markdown.py b/markdown.py
index 42a50f9..99f76b8 100644
--- a/markdown.py
+++ b/markdown.py
@@ -48,7 +48,7 @@ console_hndlr.setLevel(MESSAGE_THRESHOLD)
 logger.addHandler(console_hndlr)
 
 
-def message(level, text) :
+def message(level, text):
     ''' A wrapper method for logging debug messages. '''
     logger.log(level, text)
 
@@ -74,9 +74,9 @@ RTL_BIDI_RANGES = ( (u'\u0590', u'\u07FF'),
 # 0780-07BF - Thaana
 # 07C0-07FF - Nko
 
-BOMS = { 'utf-8' : (codecs.BOM_UTF8, ),
-         'utf-16' : (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE),
-         #'utf-32' : (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE)
+BOMS = { 'utf-8': (codecs.BOM_UTF8, ),
+         'utf-16': (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE),
+         #'utf-32': (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE)
          }
 
 def removeBOM(text, encoding):
@@ -106,7 +106,7 @@ BLOCK_LEVEL_ELEMENTS = ['p', 'div', 'blockquote', 'pre', 'table',
                         'form', 'fieldset', 'iframe', 'math', 'ins',
                         'del', 'hr', 'hr/', 'style']
 
-def is_block_level (tag) :
+def is_block_level (tag):
     return ( (tag in BLOCK_LEVEL_ELEMENTS) or
              (tag[0] == 'h' and tag[1] in "0123456789") )
 
@@ -134,47 +134,47 @@ ENTITY_NORMALIZATION_EXPRESSIONS_SOFT = [ (re.compile("&(?!\#)"), "&"),
                                      (re.compile("\""), """)]
 
 
-def getBidiType(text) :
+def getBidiType(text):
 
-    if not text : return None
+    if not text: return None
 
     ch = text[0]
 
     if not isinstance(ch, unicode) or not ch.isalpha():
         return None
 
-    else :
+    else:
 
-        for min, max in RTL_BIDI_RANGES :
-            if ( ch >= min and ch <= max ) :
+        for min, max in RTL_BIDI_RANGES:
+            if ( ch >= min and ch <= max ):
                 return "rtl"
-        else :
+        else:
             return "ltr"
 
 
-class Document :
+class Document:
 
-    def __init__ (self) :
+    def __init__ (self):
         self.bidi = "ltr"
 
-    def appendChild(self, child) :
+    def appendChild(self, child):
         self.documentElement = child
         child.isDocumentElement = True
         child.parent = self
         self.entities = {}
 
-    def setBidi(self, bidi) :
-        if bidi :
+    def setBidi(self, bidi):
+        if bidi:
             self.bidi = bidi
 
-    def createElement(self, tag, textNode=None) :
+    def createElement(self, tag, textNode=None):
         el = Element(tag)
         el.doc = self
-        if textNode :
+        if textNode:
             el.appendChild(self.createTextNode(textNode))
         return el
 
-    def createTextNode(self, text) :
+    def createTextNode(self, text):
         node = TextNode(text)
         node.doc = self
         return node
@@ -184,51 +184,51 @@ class Document :
             self.entities[entity] = EntityReference(entity)
         return self.entities[entity]
 
-    def createCDATA(self, text) :
+    def createCDATA(self, text):
         node = CDATA(text)
         node.doc = self
         return node
 
-    def toxml (self) :
+    def toxml (self):
         return self.documentElement.toxml()
 
-    def normalizeEntities(self, text, avoidDoubleNormalizing=False) :
+    def normalizeEntities(self, text, avoidDoubleNormalizing=False):
 
-        if avoidDoubleNormalizing :
+        if avoidDoubleNormalizing:
             regexps = ENTITY_NORMALIZATION_EXPRESSIONS_SOFT
-        else :
+        else:
             regexps = ENTITY_NORMALIZATION_EXPRESSIONS
 
-        for regexp, substitution in regexps :
+        for regexp, substitution in regexps:
             text = regexp.sub(substitution, text)
         return text
 
-    def find(self, test) :
+    def find(self, test):
         return self.documentElement.find(test)
 
-    def unlink(self) :
+    def unlink(self):
         self.documentElement.unlink()
         self.documentElement = None
 
 
-class CDATA :
+class CDATA:
 
     type = "cdata"
 
-    def __init__ (self, text) :
+    def __init__ (self, text):
         self.text = text
 
-    def handleAttributes(self) :
+    def handleAttributes(self):
         pass
 
-    def toxml (self) :
+    def toxml (self):
         return "<![CDATA[" + self.text + "]]>"
 
-class Element :
+class Element:
 
     type = "element"
 
-    def __init__ (self, tag) :
+    def __init__ (self, tag):
 
         self.nodeName = tag
         self.attributes = []
@@ -237,9 +237,9 @@ class Element :
         self.bidi = None
         self.isDocumentElement = False
 
-    def setBidi(self, bidi) :
+    def setBidi(self, bidi):
 
-        if bidi :
+        if bidi:
 
             orig_bidi = self.bidi
 
@@ -249,56 +249,56 @@ class Element :
                 self.parent.setBidi(bidi)
 
 
-    def unlink(self) :
-        for child in self.childNodes :
-            if child.type == "element" :
+    def unlink(self):
+        for child in self.childNodes:
+            if child.type == "element":
                 child.unlink()
         self.childNodes = None
 
-    def setAttribute(self, attr, value) :
-        if not attr in self.attributes :
+    def setAttribute(self, attr, value):
+        if not attr in self.attributes:
             self.attributes.append(attr)
 
         self.attribute_values[attr] = value
 
-    def insertChild(self, position, child) :
+    def insertChild(self, position, child):
         self.childNodes.insert(position, child)
         child.parent = self
 
-    def removeChild(self, child) :
+    def removeChild(self, child):
         self.childNodes.remove(child)
 
-    def replaceChild(self, oldChild, newChild) :
+    def replaceChild(self, oldChild, newChild):
         position = self.childNodes.index(oldChild)
         self.removeChild(oldChild)
         self.insertChild(position, newChild)
 
-    def appendChild(self, child) :
+    def appendChild(self, child):
         self.childNodes.append(child)
         child.parent = self
 
-    def handleAttributes(self) :
+    def handleAttributes(self):
         pass
 
-    def find(self, test, depth=0) :
+    def find(self, test, depth=0):
         """ Returns a list of descendants that pass the test function """
         matched_nodes = []
-        for child in self.childNodes :
-            if test(child) :
+        for child in self.childNodes:
+            if test(child):
                 matched_nodes.append(child)
-            if child.type == "element" :
+            if child.type == "element":
                 matched_nodes += child.find(test, depth+1)
         return matched_nodes
 
     def toxml(self):
-        if ENABLE_ATTRIBUTES :
+        if ENABLE_ATTRIBUTES:
             for child in self.childNodes:
                 child.handleAttributes()
 
         buffer = ""
-        if self.nodeName in ['h1', 'h2', 'h3', 'h4'] :
+        if self.nodeName in ['h1', 'h2', 'h3', 'h4']:
             buffer += "\n"
-        elif self.nodeName in ['li'] :
+        elif self.nodeName in ['li']:
             buffer += "\n "
 
         # Process children FIRST, then do the attributes
@@ -307,14 +307,14 @@ class Element :
 
         if self.childNodes or self.nodeName in ['blockquote']:
             childBuffer += ">"
-            for child in self.childNodes :
+            for child in self.childNodes:
                 childBuffer += child.toxml()
-            if self.nodeName == 'p' :
+            if self.nodeName == 'p':
                 childBuffer += "\n"
-            elif self.nodeName == 'li' :
+            elif self.nodeName == 'li':
                 childBuffer += "\n "
             childBuffer += "</%s>" % self.nodeName
-        else :
+        else:
             childBuffer += "/>"
 
 
@@ -322,18 +322,18 @@ class Element :
         buffer += "<" + self.nodeName
 
         if self.nodeName in ['p', 'li', 'ul', 'ol',
-                             'h1', 'h2', 'h3', 'h4', 'h5', 'h6'] :
+                             'h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
 
             if not self.attribute_values.has_key("dir"):
-                if self.bidi :
+                if self.bidi:
                     bidi = self.bidi
-                else :
+                else:
                     bidi = self.doc.bidi
                     
-                if bidi=="rtl" :
+                if bidi=="rtl":
                     self.setAttribute("dir", "rtl")
         
-        for attr in self.attributes :
+        for attr in self.attributes:
             value = self.attribute_values[attr]
             value = self.doc.normalizeEntities(value,
                                                avoidDoubleNormalizing=True)
@@ -351,29 +351,29 @@ class Element :
         return buffer
 
 
-class TextNode :
+class TextNode:
 
     type = "text"
     attrRegExp = re.compile(r'\{@([^\}]*)=([^\}]*)}') # {@id=123}
 
-    def __init__ (self, text) :
+    def __init__ (self, text):
         self.value = text        
 
-    def attributeCallback(self, match) :
+    def attributeCallback(self, match):
 
         self.parent.setAttribute(match.group(1), match.group(2))
 
-    def handleAttributes(self) :
+    def handleAttributes(self):
         self.value = self.attrRegExp.sub(self.attributeCallback, self.value)
 
-    def toxml(self) :
+    def toxml(self):
 
         text = self.value
 
         self.parent.setBidi(getBidiType(text))
         
         if not text.startswith(HTML_PLACEHOLDER_PREFIX):
-            if self.parent.nodeName == "p" :
+            if self.parent.nodeName == "p":
                 text = text.replace("\n", "\n   ")
             elif (self.parent.nodeName == "li"
                   and self.parent.childNodes[0]==self):
@@ -412,7 +412,7 @@ must extend markdown.Preprocessor.
 """
 
 
-class Preprocessor :
+class Preprocessor:
     pass
 
 
@@ -423,27 +423,27 @@ class HeaderPreprocessor (Preprocessor):
        the nead for lookahead later.
     """
 
-    def run (self, lines) :
+    def run (self, lines):
 
         i = -1
-        while i+1 < len(lines) :
+        while i+1 < len(lines):
             i = i+1
-            if not lines[i].strip() :
+            if not lines[i].strip():
                 continue
 
-            if lines[i].startswith("#") :
+            if lines[i].startswith("#"):
                 lines.insert(i+1, "\n")
 
             if (i+1 <= len(lines)
                   and lines[i+1]
-                  and lines[i+1][0] in ['-', '=']) :
+                  and lines[i+1][0] in ['-', '=']):
 
                 underline = lines[i+1].strip()
 
-                if underline == "="*len(underline) :
+                if underline == "="*len(underline):
                     lines[i] = "# " + lines[i].strip()
                     lines[i+1] = ""
-                elif underline == "-"*len(underline) :
+                elif underline == "-"*len(underline):
                     lines[i] = "## " + lines[i].strip()
                     lines[i+1] = ""
 
@@ -456,24 +456,24 @@ class LinePreprocessor (Preprocessor):
 
     blockquote_re = re.compile(r'^(> )+')
 
-    def run (self, lines) :
-        for i in range(len(lines)) :
+    def run (self, lines):
+        for i in range(len(lines)):
             prefix = ''
             m = self.blockquote_re.search(lines[i])
             if m : prefix = m.group(0)
-            if self._isLine(lines[i][len(prefix):]) :
+            if self._isLine(lines[i][len(prefix):]):
                 lines[i] = prefix + self.stash.store("<hr />", safe=True)
         return lines
 
-    def _isLine(self, block) :
+    def _isLine(self, block):
         """Determines if a block should be replaced with an <:wHR>"""
-        if block.startswith("    ") : return 0  # a code block
+        if block.startswith("    "): return 0  # a code block
         text = "".join([x for x in block if not x.isspace()])
-        if len(text) <= 2 :
+        if len(text) <= 2:
             return 0
-        for pattern in ['isline1', 'isline2', 'isline3'] :
+        for pattern in ['isline1', 'isline2', 'isline3']:
             m = RE.regExp[pattern].match(text)
-            if (m and m.group(1)) :
+            if (m and m.group(1)):
                 return 1
         else:
             return 0
@@ -493,11 +493,11 @@ class HtmlBlockPreprocessor (Preprocessor):
 
     def _equal_tags(self, left_tag, right_tag):
         
-        if left_tag in ['?', '?php', 'div'] : # handle PHP, etc.
+        if left_tag in ['?', '?php', 'div']: # handle PHP, etc.
             return True
         if ("/" + left_tag) == right_tag:
             return True
-        if (right_tag == "--" and left_tag == "--") :
+        if (right_tag == "--" and left_tag == "--"):
             return True
         elif left_tag == right_tag[1:] \
             and right_tag[0] != "<":
@@ -509,7 +509,7 @@ class HtmlBlockPreprocessor (Preprocessor):
         return (tag in ['hr', 'hr/'])
 
     
-    def run (self, text) :
+    def run (self, text):
 
         new_blocks = []
         text = text.split("\n\n")
@@ -520,7 +520,7 @@ class HtmlBlockPreprocessor (Preprocessor):
         in_tag = False # flag
         
         for block in text:
-            if block.startswith("\n") :
+            if block.startswith("\n"):
                 block = block[1:]
 
             if not in_tag:
@@ -570,7 +570,7 @@ class HtmlBlockPreprocessor (Preprocessor):
                         self.stash.store('\n\n'.join(items)))
                     items = []
 
-        if items :
+        if items:
             new_blocks.append(self.stash.store('\n\n'.join(items)))
             new_blocks.append('\n')
             
@@ -581,7 +581,7 @@ HTML_BLOCK_PREPROCESSOR = HtmlBlockPreprocessor()
 
 class ReferencePreprocessor (Preprocessor):
 
-    def run (self, lines) :
+    def run (self, lines):
 
         new_text = [];
         for line in lines:
@@ -589,14 +589,14 @@ class ReferencePreprocessor (Preprocessor):
             if m:
                 id = m.group(2).strip().lower()
                 t = m.group(4).strip()  # potential title
-                if not t :
+                if not t:
                     self.references[id] = (m.group(3), t)
                 elif (len(t) >= 2
                       and (t[0] == t[-1] == "\""
                            or t[0] == t[-1] == "\'"
-                           or (t[0] == "(" and t[-1] == ")") ) ) :
+                           or (t[0] == "(" and t[-1] == ")") ) ):
                     self.references[id] = (m.group(3), t[1:-1])
-                else :
+                else:
                     new_text.append(line)
             else:
                 new_text.append(line)
@@ -665,7 +665,7 @@ STRONG_EM_RE = r'\*\*\*([^_]*)\*\*\*'            # ***strong***
 
 if SMART_EMPHASIS:
     EMPHASIS_2_RE = r'(?<!\S)_(\S[^_]*)_'        # _emphasis_
-else :
+else:
     EMPHASIS_2_RE = r'_([^_]*)_'                 # _emphasis_
 
 STRONG_2_RE = r'__([^_]*)__'                     # __strong__
@@ -687,34 +687,34 @@ LINE_BREAK_2_RE = r'  $'                    # two spaces at end of text
 
 class Pattern:
 
-    def __init__ (self, pattern) :
+    def __init__ (self, pattern):
         self.pattern = pattern
         self.compiled_re = re.compile("^(.*)%s(.*)$" % pattern, re.DOTALL)
 
-    def getCompiledRegExp (self) :
+    def getCompiledRegExp (self):
         return self.compiled_re
 
 BasePattern = Pattern # for backward compatibility
 
-class SimpleTextPattern (Pattern) :
+class SimpleTextPattern (Pattern):
 
-    def handleMatch(self, m, doc) :
+    def handleMatch(self, m, doc):
         return doc.createTextNode(m.group(2))
 
 class SimpleTagPattern (Pattern):
 
-    def __init__ (self, pattern, tag) :
+    def __init__ (self, pattern, tag):
         Pattern.__init__(self, pattern)
         self.tag = tag
 
-    def handleMatch(self, m, doc) :
+    def handleMatch(self, m, doc):
         el = doc.createElement(self.tag)
         el.appendChild(doc.createTextNode(m.group(2)))
         return el
 
 class SubstituteTagPattern (SimpleTagPattern):
 
-    def handleMatch (self, m, doc) :
+    def handleMatch (self, m, doc):
         return doc.createElement(self.tag)
 
 class BacktickPattern (Pattern):
@@ -723,7 +723,7 @@ class BacktickPattern (Pattern):
         Pattern.__init__(self, pattern)
         self.tag = "code"
 
-    def handleMatch(self, m, doc) :
+    def handleMatch(self, m, doc):
         el = doc.createElement(self.tag)
         text = m.group(2).strip()
         #text = text.replace("&", "&amp;")
@@ -731,9 +731,9 @@ class BacktickPattern (Pattern):
         return el
 
 
-class DoubleTagPattern (SimpleTagPattern) :
+class DoubleTagPattern (SimpleTagPattern): 
 
-    def handleMatch(self, m, doc) :
+    def handleMatch(self, m, doc):
         tag1, tag2 = self.tag.split(",")
         el1 = doc.createElement(tag1)
         el2 = doc.createElement(tag2)
@@ -744,7 +744,7 @@ class DoubleTagPattern (SimpleTagPattern) :
 
 class HtmlPattern (Pattern):
 
-    def handleMatch (self, m, doc) :
+    def handleMatch (self, m, doc):
         rawhtml = m.group(2)
         inline = True
         place_holder = self.stash.store(rawhtml)
@@ -753,16 +753,16 @@ class HtmlPattern (Pattern):
 
 class LinkPattern (Pattern):
 
-    def handleMatch(self, m, doc) :
+    def handleMatch(self, m, doc):
         el = doc.createElement('a')
         el.appendChild(doc.createTextNode(m.group(2)))
         parts = m.group(9).split('"')
         # We should now have [], [href], or [href, title]
-        if parts :
+        if parts:
             el.setAttribute('href', parts[0].strip())
-        else :
+        else:
             el.setAttribute('href', "")
-        if len(parts) > 1 :
+        if len(parts) > 1:
             # we also got a title
             title = '"' + '"'.join(parts[1:]).strip()
             title = dequote(title) #.replace('"', "&quot;")
@@ -775,13 +775,13 @@ class ImagePattern (Pattern):
     def handleMatch(self, m, doc):
         el = doc.createElement('img')
         src_parts = m.group(9).split()
-        if src_parts :
+        if src_parts:
             el.setAttribute('src', src_parts[0])
         else:
             el.setAttribute('src', "")
-        if len(src_parts) > 1 :
+        if len(src_parts) > 1:
             el.setAttribute('title', dequote(" ".join(src_parts[1:])))
-        if ENABLE_ATTRIBUTES :
+        if ENABLE_ATTRIBUTES:
             text = doc.createTextNode(m.group(2))
             el.appendChild(text)
             text.handleAttributes()
@@ -796,14 +796,14 @@ class ReferencePattern (Pattern):
 
     def handleMatch(self, m, doc):
 
-        if m.group(9) :
+        if m.group(9):
             id = m.group(9).lower()
-        else :
+        else:
             # if we got something like "[Google][]"
             # we'll use "google" as the id
             id = m.group(2).lower()
 
-        if not self.references.has_key(id) : # ignore undefined refs
+        if not self.references.has_key(id): # ignore undefined refs
             return None
         href, title = self.references[id]
         text = m.group(2)
@@ -812,7 +812,7 @@ class ReferencePattern (Pattern):
     def makeTag(self, href, title, text, doc):
         el = doc.createElement('a')
         el.setAttribute('href', href)
-        if title :
+        if title:
             el.setAttribute('title', title)
         el.appendChild(doc.createTextNode(text))
         return el
@@ -823,7 +823,7 @@ class ImageReferencePattern (ReferencePattern):
     def makeTag(self, href, title, text, doc):
         el = doc.createElement('img')
         el.setAttribute('src', href)
-        if title :
+        if title:
             el.setAttribute('title', title)
         el.setAttribute('alt', text)
         return el
@@ -839,7 +839,7 @@ class AutolinkPattern (Pattern):
 
 class AutomailPattern (Pattern):
 
-    def handleMatch(self, m, doc) :
+    def handleMatch(self, m, doc):
         el = doc.createElement('a')
         email = m.group(2)
         if email.startswith("mailto:"):
@@ -897,7 +897,7 @@ There are currently no standard post-processors, but the footnote
 extension below uses one.
 """
 
-class Postprocessor :
+class Postprocessor:
     pass
 
 
@@ -916,20 +916,20 @@ Text-Post-Processors should extend markdown.Postprocessor.
 """
 
 
-class RawHtmlTextPostprocessor(Postprocessor) :
+class RawHtmlTextPostprocessor(Postprocessor):
 
     def __init__(self):
         pass
 
     def run(self, text):
-        for i in range(self.stash.html_counter) :
+        for i in range(self.stash.html_counter):
             html, safe  = self.stash.rawHtmlBlocks[i]
-            if self.safeMode and not safe :
-                if str(self.safeMode).lower() == 'escape' :
+            if self.safeMode and not safe:
+                if str(self.safeMode).lower() == 'escape':
                     html = self.escape(html)
-                elif str(self.safeMode).lower() == 'remove' :
+                elif str(self.safeMode).lower() == 'remove':
                     html = ''
-                else :
+                else:
                     html = HTML_REMOVED_TEXT
                                    
             text = text.replace("<p>%s\n</p>" % (HTML_PLACEHOLDER % i),
@@ -952,15 +952,15 @@ RAWHTMLTEXTPOSTPROCESSOR = RawHtmlTextPostprocessor()
 ======================================================================
 """
 
-class HtmlStash :
+class HtmlStash:
     """This class is used for stashing HTML objects that we extract
         in the beginning and replace with place-holders."""
 
-    def __init__ (self) :
+    def __init__ (self):
         self.html_counter = 0 # for counting inline html segments
         self.rawHtmlBlocks=[]
 
-    def store(self, html, safe=False) :
+    def store(self, html, safe=False):
         """Saves an HTML segment for later reinsertion.  Returns a
            placeholder string that needs to be inserted into the
            document.
@@ -975,9 +975,9 @@ class HtmlStash :
         return placeholder
 
 
-class BlockGuru :
+class BlockGuru:
 
-    def _findHead(self, lines, fn, allowBlank=0) :
+    def _findHead(self, lines, fn, allowBlank=0):
 
         """Functional magic to help determine boundaries of indented
            blocks.
@@ -995,7 +995,7 @@ class BlockGuru :
 
         i = 0 # to keep track of where we are
 
-        for line in lines :
+        for line in lines:
 
             if not line.strip() and not allowBlank:
                 return items, lines[i:]
@@ -1005,11 +1005,11 @@ class BlockGuru :
                 i += 1
 
                 # Find the next non-blank line
-                for j in range(i, len(lines)) :
-                    if lines[j].strip() :
+                for j in range(i, len(lines)):
+                    if lines[j].strip():
                         next = lines[j]
                         break
-                else :
+                else:
                     # There is no more text => this is the end
                     break
 
@@ -1017,36 +1017,36 @@ class BlockGuru :
 
                 part = fn(next)
 
-                if part :
+                if part:
                     items.append("")
                     continue
-                else :
+                else:
                     break # found end of the list
 
             part = fn(line)
 
-            if part :
+            if part:
                 items.append(part)
                 i += 1
                 continue
-            else :
+            else:
                 return items, lines[i:]
-        else :
+        else:
             i += 1
 
         return items, lines[i:]
 
 
-    def detabbed_fn(self, line) :
+    def detabbed_fn(self, line):
         """ An auxiliary method to be passed to _findHead """
         m = RE.regExp['tabbed'].match(line)
         if m:
             return m.group(4)
-        else :
+        else:
             return None
 
 
-    def detectTabbed(self, lines) :
+    def detectTabbed(self, lines):
 
         return self._findHead(lines, self.detabbed_fn,
                               allowBlank = 1)
@@ -1057,12 +1057,12 @@ def print_error(string):
     sys.stderr.write(string +'\n')
 
 
-def dequote(string) :
+def dequote(string):
     """ Removes quotes from around a string """
     if ( ( string.startswith('"') and string.endswith('"'))
-         or (string.startswith("'") and string.endswith("'")) ) :
+         or (string.startswith("'") and string.endswith("'")) ):
         return string[1:-1]
-    else :
+    else:
         return string
 
 """
@@ -1075,13 +1075,13 @@ see first if you can do it via pre-processors, post-processors,
 inline patterns or a combination of the three.
 """
 
-class CorePatterns :
+class CorePatterns:
     """This class is scheduled for removal as part of a refactoring
         effort."""
 
     patterns = {
         'header':          r'(#*)([^#]*)(#*)', # # A title
-        'reference-def' :  r'(\ ?\ ?\ ?)\[([^\]]*)\]:\s*([^ ]*)(.*)',
+        'reference-def':   r'(\ ?\ ?\ ?)\[([^\]]*)\]:\s*([^ ]*)(.*)',
                            # [Google]: http://www.google.com/
         'containsline':    r'([-]*)$|^([=]*)', # -----, =====, etc.
         'ol':              r'[ ]{0,3}[\d]*\.\s+(.*)', # 1. text
@@ -1090,13 +1090,13 @@ class CorePatterns :
         'isline2':         r'(\-*)', # ---
         'isline3':         r'(\_*)', # ___
         'tabbed':          r'((\t)|(    ))(.*)', # an indented line
-        'quoted' :         r'> ?(.*)', # a quoted block ("> ...")
+        'quoted':          r'> ?(.*)', # a quoted block ("> ...")
     }
 
-    def __init__ (self) :
+    def __init__ (self):
 
         self.regExp = {}
-        for key in self.patterns.keys() :
+        for key in self.patterns.keys():
             self.regExp[key] = re.compile("^%s$" % self.patterns[key],
                                           re.DOTALL)
 
@@ -1128,48 +1128,48 @@ class Markdown:
         self.stripTopLevelTags = 1
         self.docType = ""
 
-        self.textPreprocessors = [ HTML_BLOCK_PREPROCESSOR]
+        self.textPreprocessors = [HTML_BLOCK_PREPROCESSOR]
 
-        self.preprocessors = [ HEADER_PREPROCESSOR,
-                               LINE_PREPROCESSOR,
-                               # A footnote preprocessor will
-                               # get inserted here
-                               REFERENCE_PREPROCESSOR ]
+        self.preprocessors = [HEADER_PREPROCESSOR,
+                              LINE_PREPROCESSOR,
+                              # A footnote preprocessor will
+                              # get inserted here
+                              REFERENCE_PREPROCESSOR]
 
 
         self.postprocessors = [] # a footnote postprocessor will get
                                  # inserted later
 
-        self.textPostprocessors = [ # a footnote postprocessor will get
-                                    # inserted here
-                                    RAWHTMLTEXTPOSTPROCESSOR ]
+        self.textPostprocessors = [# a footnote postprocessor will get
+                                   # inserted here
+                                   RAWHTMLTEXTPOSTPROCESSOR]
 
         self.prePatterns = []
         
 
-        self.inlinePatterns = [ DOUBLE_BACKTICK_PATTERN,
-                                BACKTICK_PATTERN,
-                                ESCAPE_PATTERN,
-                                IMAGE_LINK_PATTERN,
-                                IMAGE_REFERENCE_PATTERN,
-                                REFERENCE_PATTERN,
-                                LINK_ANGLED_PATTERN,
-                                LINK_PATTERN,
-                                AUTOLINK_PATTERN,
-                                AUTOMAIL_PATTERN,
-                                LINE_BREAK_PATTERN_2,
-                                LINE_BREAK_PATTERN,
-                                HTML_PATTERN,
-                                ENTITY_PATTERN,
-                                NOT_STRONG_PATTERN,
-                                STRONG_EM_PATTERN,
-                                STRONG_EM_PATTERN_2,
-                                STRONG_PATTERN,
-                                STRONG_PATTERN_2,
-                                EMPHASIS_PATTERN,
-                                EMPHASIS_PATTERN_2
-                                # The order of the handlers matters!!!
-                                ]
+        self.inlinePatterns = [DOUBLE_BACKTICK_PATTERN,
+                               BACKTICK_PATTERN,
+                               ESCAPE_PATTERN,
+                               IMAGE_LINK_PATTERN,
+                               IMAGE_REFERENCE_PATTERN,
+                               REFERENCE_PATTERN,
+                               LINK_ANGLED_PATTERN,
+                               LINK_PATTERN,
+                               AUTOLINK_PATTERN,
+                               AUTOMAIL_PATTERN,
+                               LINE_BREAK_PATTERN_2,
+                               LINE_BREAK_PATTERN,
+                               HTML_PATTERN,
+                               ENTITY_PATTERN,
+                               NOT_STRONG_PATTERN,
+                               STRONG_EM_PATTERN,
+                               STRONG_EM_PATTERN_2,
+                               STRONG_PATTERN,
+                               STRONG_PATTERN_2,
+                               EMPHASIS_PATTERN,
+                               EMPHASIS_PATTERN_2
+                               # The order of the handlers matters!!!
+                               ]
 
         self.registerExtensions(extensions = extensions,
                                 configs = extension_configs)
@@ -1177,27 +1177,27 @@ class Markdown:
         self.reset()
 
 
-    def registerExtensions(self, extensions, configs) :
+    def registerExtensions(self, extensions, configs):
 
-        if not configs :
+        if not configs:
             configs = {}
 
-        for ext in extensions :
+        for ext in extensions:
 
             extension_module_name = "mdx_" + ext
 
-            try :
+            try:
                 module = __import__(extension_module_name)
 
-            except :
+            except:
                 message(CRITICAL,
                         "couldn't load extension %s (looking for %s module)"
                         % (ext, extension_module_name) )
-            else :
+            else:
 
-                if configs.has_key(ext) :
+                if configs.has_key(ext):
                     configs_for_ext = configs[ext]
-                else :
+                else:
                     configs_for_ext = []
                 extension = module.makeExtension(configs_for_ext)    
                 extension.extendMarkdown(self, globals())
@@ -1205,11 +1205,11 @@ class Markdown:
 
 
 
-    def registerExtension(self, extension) :
+    def registerExtension(self, extension):
         """ This gets called by the extension """
         self.registeredExtensions.append(extension)
 
-    def reset(self) :
+    def reset(self):
         """Resets all state variables so that we can start
             with a new text."""
         self.references={}
@@ -1225,7 +1225,7 @@ class Markdown:
         RAWHTMLTEXTPOSTPROCESSOR.stash = self.htmlStash
         RAWHTMLTEXTPOSTPROCESSOR.safeMode = self.safeMode
 
-        for extension in self.registeredExtensions :
+        for extension in self.registeredExtensions:
             extension.reset()
 
 
@@ -1261,11 +1261,11 @@ class Markdown:
 
 
         buffer = []
-        for line in self.lines :
-            if line.startswith("#") :
+        for line in self.lines:
+            if line.startswith("#"):
                 self._processSection(self.top_element, buffer)
                 buffer = [line]
-            else :
+            else:
                 buffer.append(line)
         self._processSection(self.top_element, buffer)
         
@@ -1275,14 +1275,14 @@ class Markdown:
         self.top_element.appendChild(self.doc.createTextNode('\n'))
 
         # Run the post-processors
-        for postprocessor in self.postprocessors :
+        for postprocessor in self.postprocessors:
             postprocessor.run(self.doc)
 
         return self.doc
 
 
     def _processSection(self, parent_elem, lines,
-                        inList = 0, looseList = 0) :
+                        inList = 0, looseList = 0):
 
         """Process a section of a source document, looking for high
            level structural elements like lists, block quotes, code
@@ -1297,19 +1297,19 @@ class Markdown:
            @returns: None"""
 
         # Loop through lines until none left.
-        while lines :
+        while lines:
 
             # Check if this section starts with a list, a blockquote or
             # a code block
 
-            processFn = { 'ul' :     self._processUList,
-                          'ol' :     self._processOList,
-                          'quoted' : self._processQuote,
-                          'tabbed' : self._processCodeBlock }
+            processFn = { 'ul':     self._processUList,
+                          'ol':     self._processOList,
+                          'quoted': self._processQuote,
+                          'tabbed': self._processCodeBlock}
 
-            for regexp in ['ul', 'ol', 'quoted', 'tabbed'] :
+            for regexp in ['ul', 'ol', 'quoted', 'tabbed']:
                 m = RE.regExp[regexp].match(lines[0])
-                if m :
+                if m:
                     processFn[regexp](parent_elem, lines, inList)
                     return
 
@@ -1328,7 +1328,7 @@ class Markdown:
             #     * Underneath we might have a sublist.
             #
 
-            if inList :
+            if inList:
 
                 start, lines  = self._linesUntil(lines, (lambda line:
                                  RE.regExp['ul'].match(line)
@@ -1339,35 +1339,35 @@ class Markdown:
                                      inList - 1, looseList = looseList)
                 inList = inList-1
 
-            else : # Ok, so it's just a simple block
+            else: # Ok, so it's just a simple block
 
                 paragraph, lines = self._linesUntil(lines, lambda line:
                                                      not line.strip())
 
-                if len(paragraph) and paragraph[0].startswith('#') :
+                if len(paragraph) and paragraph[0].startswith('#'):
                     self._processHeader(parent_elem, paragraph)
 
-                elif paragraph :
+                elif paragraph:
                     self._processParagraph(parent_elem, paragraph,
                                           inList, looseList)
 
-            if lines and not lines[0].strip() :
+            if lines and not lines[0].strip():
                 lines = lines[1:]  # skip the first (blank) line
 
 
-    def _processHeader(self, parent_elem, paragraph) :
+    def _processHeader(self, parent_elem, paragraph):
         m = RE.regExp['header'].match(paragraph[0])
-        if m :
+        if m:
             level = len(m.group(1))
             h = self.doc.createElement("h%d" % level)
             parent_elem.appendChild(h)
-            for item in self._handleInlineWrapper(m.group(2).strip()) :
+            for item in self._handleInlineWrapper(m.group(2).strip()):
                 h.appendChild(item)
-        else :
+        else:
             message(CRITICAL, "We've got a problem header!")
 
 
-    def _processParagraph(self, parent_elem, paragraph, inList, looseList) :
+    def _processParagraph(self, parent_elem, paragraph, inList, looseList):
         list = self._handleInlineWrapper("\n".join(paragraph))
 
         if ( parent_elem.nodeName == 'li'
@@ -1377,25 +1377,25 @@ class Markdown:
             # put <p> around it - append the paragraph bits directly
             # onto parent_elem
             el = parent_elem
-        else :
+        else:
             # Otherwise make a "p" element
             el = self.doc.createElement("p")
             parent_elem.appendChild(el)
 
-        for item in list :
+        for item in list:
             el.appendChild(item)
  
 
-    def _processUList(self, parent_elem, lines, inList) :
+    def _processUList(self, parent_elem, lines, inList):
         self._processList(parent_elem, lines, inList,
                          listexpr='ul', tag = 'ul')
 
-    def _processOList(self, parent_elem, lines, inList) :
+    def _processOList(self, parent_elem, lines, inList):
         self._processList(parent_elem, lines, inList,
                          listexpr='ol', tag = 'ol')
 
 
-    def _processList(self, parent_elem, lines, inList, listexpr, tag) :
+    def _processList(self, parent_elem, lines, inList, listexpr, tag):
         """Given a list of document lines starting with a list item,
            finds the end of the list, breaks it up, and recursively
            processes each list item and the remainder of the text file.
@@ -1416,20 +1416,20 @@ class Markdown:
 
         i = 0  # a counter to keep track of where we are
 
-        for line in lines :
+        for line in lines: 
 
             loose = 0
-            if not line.strip() :
+            if not line.strip():
                 # If we see a blank line, this _might_ be the end of the list
                 i += 1
                 loose = 1
 
                 # Find the next non-blank line
-                for j in range(i, len(lines)) :
-                    if lines[j].strip() :
+                for j in range(i, len(lines)):
+                    if lines[j].strip():
                         next = lines[j]
                         break
-                else :
+                else:
                     # There is no more text => end of the list
                     break
 
@@ -1441,7 +1441,7 @@ class Markdown:
                     items[item].append(line.strip())
                     looseList = loose or looseList
                     continue
-                else :
+                else:
                     break # found end of the list
 
             # Now we need to detect list items (at the current level)
@@ -1450,26 +1450,26 @@ class Markdown:
             for expr in ['ul', 'ol', 'tabbed']:
 
                 m = RE.regExp[expr].match(line)
-                if m :
-                    if expr in ['ul', 'ol'] :  # We are looking at a new item
+                if m:
+                    if expr in ['ul', 'ol']:  # We are looking at a new item
                         #if m.group(1) :
                         # Removed the check to allow for a blank line
                         # at the beginning of the list item
                         items.append([m.group(1)])
                         item += 1
-                    elif expr == 'tabbed' :  # This line needs to be detabbed
+                    elif expr == 'tabbed':  # This line needs to be detabbed
                         items[item].append(m.group(4)) #after the 'tab'
 
                     i += 1
                     break
-            else :
+            else:
                 items[item].append(line)  # Just regular continuation
                 i += 1 # added on 2006.02.25
-        else :
+        else:
             i += 1
 
         # Add the dom elements
-        for item in items :
+        for item in items:
             li = self.doc.createElement("li")
             ul.appendChild(li)
 
@@ -1480,21 +1480,21 @@ class Markdown:
         self._processSection(parent_elem, lines[i:], inList)
 
 
-    def _linesUntil(self, lines, condition) :
+    def _linesUntil(self, lines, condition):
         """ A utility function to break a list of lines upon the
             first line that satisfied a condition.  The condition
             argument should be a predicate function.
             """
 
         i = -1
-        for line in lines :
+        for line in lines:
             i += 1
-            if condition(line) : break
-        else :
+            if condition(line): break
+        else:
             i += 1
         return lines[:i], lines[i:]
 
-    def _processQuote(self, parent_elem, lines, inList) :
+    def _processQuote(self, parent_elem, lines, inList):
         """Given a list of document lines starting with a quote finds
            the end of the quote, unindents it and recursively
            processes the body of the quote and the remainder of the
@@ -1508,20 +1508,20 @@ class Markdown:
         dequoted = []
         i = 0
         blank_line = False # allow one blank line between paragraphs
-        for line in lines :
+        for line in lines:
             m = RE.regExp['quoted'].match(line)
-            if m :
+            if m:
                 dequoted.append(m.group(1))
                 i += 1
                 blank_line = False
-            elif not blank_line and line.strip() != '' :
+            elif not blank_line and line.strip() != '':
                 dequoted.append(line)
                 i += 1
-            elif not blank_line and line.strip() == '' :
+            elif not blank_line and line.strip() == '':
                 dequoted.append(line)
                 i += 1
                 blank_line = True
-            else :
+            else:
                 break
 
         blockquote = self.doc.createElement('blockquote')
@@ -1533,7 +1533,7 @@ class Markdown:
 
 
 
-    def _processCodeBlock(self, parent_elem, lines, inList) :
+    def _processCodeBlock(self, parent_elem, lines, inList):
         """Given a list of document lines starting with a code block
            finds the end of the block, puts it into the dom verbatim
            wrapped in ("<pre><code>") and recursively processes the
@@ -1557,35 +1557,35 @@ class Markdown:
 
 
 
-    def _handleInlineWrapper (self, line, patternIndex=0) :
+    def _handleInlineWrapper (self, line, patternIndex=0):
 
         parts = [line]
 
-        while patternIndex < len(self.inlinePatterns) :
+        while patternIndex < len(self.inlinePatterns):
 
             i = 0
 
-            while i < len(parts) :
+            while i < len(parts):
                 
                 x = parts[i]
 
-                if isinstance(x, (str, unicode)) :
+                if isinstance(x, (str, unicode)):
                     result = self._applyPattern(x, \
                                 self.inlinePatterns[patternIndex], \
-                                patternIndex )
+                                patternIndex)
 
-                    if result :
+                    if result:
                         i -= 1
                         parts.remove(x)
-                        for y in result :
+                        for y in result:
                             parts.insert(i+1,y)
 
                 i += 1
             patternIndex += 1
 
-        for i in range(len(parts)) :
+        for i in range(len(parts)):
             x = parts[i]
-            if isinstance(x, (str, unicode)) :
+            if isinstance(x, (str, unicode)):
                 parts[i] = self.doc.createTextNode(x)
 
         return parts
@@ -1604,13 +1604,13 @@ class Markdown:
         if not(line):
             return [self.doc.createTextNode(' ')]
 
-        for pattern in self.inlinePatterns :
+        for pattern in self.inlinePatterns:
             list = self._applyPattern( line, pattern)
             if list: return list
 
         return [self.doc.createTextNode(line)]
 
-    def _applyPattern(self, line, pattern, patternIndex) :
+    def _applyPattern(self, line, pattern, patternIndex):
 
         """ Given a pattern name, this function checks if the line
         fits the pattern, creates the necessary elements, and returns
@@ -1629,7 +1629,7 @@ class Markdown:
 
 
         m = pattern.getCompiledRegExp().match(line)
-        if not m :
+        if not m:
             return None
 
         # if we got a match let the pattern make us a NanoDom node
@@ -1640,15 +1640,15 @@ class Markdown:
 
         if isinstance(node, Element):
 
-            if not node.nodeName in ["code", "pre"] :
-                for child in node.childNodes :
+            if not node.nodeName in ["code", "pre"]:
+                for child in node.childNodes:
                     if isinstance(child, TextNode):
                         
                         result = self._handleInlineWrapper(child.value, patternIndex+1)
                         
                         if result:
 
-                            if result == [child] :
+                            if result == [child]:
                                 continue
                                 
                             result.reverse()
@@ -1670,13 +1670,13 @@ class Markdown:
 
 
 
-        if node :
+        if node:
             # Those are in the reverse order!
             return ( m.groups()[-1], # the string to the left
                      node,           # the new node
                      m.group(1))     # the string to the right of the match
 
-        else :
+        else:
             return None
 
     def convert (self, source = None):
@@ -1688,12 +1688,12 @@ class Markdown:
         if source is not None: #Allow blank string
             self.source = source
 
-        if not self.source :
+        if not self.source:
             return ""
 
         self.source = removeBOM(self.source, self.encoding)
 
-        for pp in self.textPreprocessors :
+        for pp in self.textPreprocessors:
             self.source = pp.run(self.source)
 
         doc = self._transform()
@@ -1704,10 +1704,10 @@ class Markdown:
 
         # Return everything but the top level tag
 
-        if self.stripTopLevelTags :
+        if self.stripTopLevelTags:
             xml = xml.strip()[23:-7] + "\n"
 
-        for pp in self.textPostprocessors :
+        for pp in self.textPostprocessors:
             xml = pp.run(xml)
 
         return (self.docType + xml).strip()
@@ -1737,14 +1737,14 @@ def markdownFromFile(input = None,
                      extensions = [],
                      encoding = None,
                      message_threshold = CRITICAL,
-                     safe = False) :
+                     safe = False):
 
     global console_hndlr
     console_hndlr.setLevel(message_threshold)
 
     message(DEBUG, "input file: %s" % input)
 
-    if not encoding :
+    if not encoding:
         encoding = "utf-8"
 
     input_file = codecs.open(input, mode="r", encoding=encoding)
@@ -1753,29 +1753,29 @@ def markdownFromFile(input = None,
 
     new_text = markdown(text, extensions, encoding, safe_mode = safe)
 
-    if output :
+    if output:
         output_file = codecs.open(output, "w", encoding=encoding)
         output_file.write(new_text)
         output_file.close()
 
-    else :
+    else:
         sys.stdout.write(new_text.encode(encoding))
 
 def markdown(text,
              extensions = [],
              encoding = None,
-             safe_mode = False) :
+             safe_mode = False):
     
     message(DEBUG, "in markdown.markdown(), received text:\n%s" % text)
 
     extension_names = []
     extension_configs = {}
     
-    for ext in extensions :
+    for ext in extensions:
         pos = ext.find("(") 
-        if pos == -1 :
+        if pos == -1:
             extension_names.append(ext)
-        else :
+        else:
             name = ext[:pos]
             extension_names.append(name)
             pairs = [x.split("=") for x in ext[pos+1:-1].split(",")]
@@ -1789,21 +1789,21 @@ def markdown(text,
     return md.convert(text)
         
 
-class Extension :
+class Extension:
 
-    def __init__(self, configs = {}) :
+    def __init__(self, configs = {}):
         self.config = configs
 
-    def getConfig(self, key) :
-        if self.config.has_key(key) :
+    def getConfig(self, key):
+        if self.config.has_key(key):
             return self.config[key][0]
-        else :
+        else:
             return ""
 
-    def getConfigInfo(self) :
+    def getConfigInfo(self):
         return [(key, self.config[key][1]) for key in self.config.keys()]
 
-    def setConfig(self, key, value) :
+    def setConfig(self, key, value):
         self.config[key][0] = value
 
 
@@ -1815,20 +1815,20 @@ For lower versions of Python use:
     
 """ % EXECUTABLE_NAME_FOR_USAGE
 
-def parse_options() :
+def parse_options():
 
-    try :
+    try:
         optparse = __import__("optparse")
-    except :
-        if len(sys.argv) == 2 :
-            return {'input' : sys.argv[1],
-                    'output' : None,
-                    'message_threshold' : CRITICAL,
-                    'safe' : False,
-                    'extensions' : [],
-                    'encoding' : None }
-
-        else :
+    except:
+        if len(sys.argv) == 2:
+            return {'input': sys.argv[1],
+                    'output': None,
+                    'message_threshold': CRITICAL,
+                    'safe': False,
+                    'extensions': [],
+                    'encoding': None }
+
+        else:
             print OPTPARSE_WARNING
             return None
 
@@ -1857,21 +1857,21 @@ def parse_options() :
 
     (options, args) = parser.parse_args()
 
-    if not len(args) == 1 :
+    if not len(args) == 1:
         parser.print_help()
         return None
-    else :
+    else:
         input_file = args[0]
 
-    if not options.extensions :
+    if not options.extensions:
         options.extensions = []
 
-    return {'input' : input_file,
-            'output' : options.filename,
-            'message_threshold' : options.verbose,
-            'safe' : options.safe,
-            'extensions' : options.extensions,
-            'encoding' : options.encoding }
+    return {'input': input_file,
+            'output': options.filename,
+            'message_threshold': options.verbose,
+            'safe': options.safe,
+            'extensions': options.extensions,
+            'encoding': options.encoding }
 
 if __name__ == '__main__':
     """ Run Markdown from the command line. """
@@ -1880,7 +1880,7 @@ if __name__ == '__main__':
 
     #if os.access(inFile, os.R_OK):
 
-    if not options :
+    if not options:
         sys.exit(0)
     
     markdownFromFile(**options)