Refactored markdown tree traversing logic into a separate class

(InlineProcessor).

1 files changed, 189 insertions, 202 deletions

diff --git a/markdown.py b/markdown.py
index 0aa530d..ae8dc10 100755
--- a/markdown.py
+++ b/markdown.py
@@ -1401,28 +1401,32 @@ class HtmlStash:
         self.html_counter += 1
         return placeholder
     
-    def rest(self):
+    def reset(self):
         self.html_counter = 0
         self.rawHtmlBlocks = []
 
-    
-class InlineStash:
-    
-    def __init__(self):
-        """ Create a InlineStash. """
-        self.prefix = INLINE_PLACEHOLDER_PREFIX
-        self.suffix = ETX
-        self._nodes = {}
-        self.phLength = 4 + len(self.prefix) + len(self.suffix)
-        self._placeholder_re = re.compile(INLINE_PLACEHOLDER % r'([0-9]{4})')
+
+class InlineProcessor:
+    """
+    An auxiliary class to traverse a Markdown tree, applying inline patterns.
+    """
+
+    def __init__ (self, patterns):
+        self.inlinePatterns = patterns
+
+        self.__placeholder_prefix = INLINE_PLACEHOLDER_PREFIX
+        self.__placeholder_suffix = ETX
+        self.__placeholder_length = 4 + len(self.__placeholder_prefix) \
+                                      + len(self.__placeholder_suffix)
+        self.__placeholder_re = re.compile(INLINE_PLACEHOLDER % r'([0-9]{4})')
         
-    def _genPlaceholder(self, type):
+    def __makePlaceholder(self, type):
         """ Generate a placeholder """
-        id = "%04d" % len(self._nodes)
+        id = "%04d" % len(self.stashed_nodes)
         hash = INLINE_PLACEHOLDER % id 
         return hash, id
     
-    def extractId(self, data, index):
+    def __findPlaceholder(self, data, index):
         """ 
         Extract id from data string, start from index
         
@@ -1434,164 +1438,19 @@ class InlineStash:
         Returns: placeholder id and  string index, after 
         found placeholder
         """
-        m = self._placeholder_re.search(data, index)
+        m = self.__placeholder_re.search(data, index)
         if m:
             return m.group(1), m.end()
         else:
             return None, index + 1 
     
-    def isin(self, id):
-        """ Check if node with given id exists in stash """
-        return self._nodes.has_key(id)
-    
-    def get(self, id):
-        """ Return node by id """
-        return self._nodes.get(id)
-    
-    def add(self, node, type):
+    def __stashNode(self, node, type):
         """ Add node to stash """
-        pholder, id = self._genPlaceholder(type)
-        self._nodes[id] = node
-        return pholder
-    
-    def rest(self):
-        """ Reset instance """
-        self._nodes = {}
+        placeholder, id = self.__makePlaceholder(type)
+        self.stashed_nodes[id] = node
+        return placeholder
     
-           
-
-class Markdown:
-    """Convert Markdown to HTML."""
-
-    def __init__(self, 
-                 extensions=[],
-                 extension_configs={},
-                 safe_mode = False):
-        """
-        Creates a new Markdown instance.
-
-        Keyword arguments:
-        
-        * extensions: A list of extensions.  
-           If they are of type string, the module mdx_name.py will be loaded.  
-           If they are a subclass of markdown.Extension, they will be used 
-           as-is.
-        * extension-configs: Configuration setting for extensions.
-        * safe_mode: Disallow raw html. One of "remove", "replace" or "escape".
-        
-        """
-        self.parser = MarkdownParser()
-        self.safeMode = safe_mode
-        self.registeredExtensions = []
-        self.docType = ""
-        self.stripTopLevelTags = True
-
-        self.textPreprocessors = [HTML_BLOCK_PREPROCESSOR]
-
-        self.preprocessors = [HEADER_PREPROCESSOR,
-                              LINE_PREPROCESSOR,
-                              # A footnote preprocessor will
-                              # get inserted here
-                              REFERENCE_PREPROCESSOR]
-
-
-        self.postprocessors = [PRETTIFYPOSTPROCESSOR,
-                               # a footnote postprocessor will get
-                               # inserted later
-                               ]
-
-        self.textPostprocessors = [# a footnote postprocessor will get
-                                   # inserted here
-                                   RAWHTMLTEXTPOSTPROCESSOR,
-                                   AMPSUBSTITUTETEXTPOSTPROCESSOR]
-
-        self.prePatterns = []
-                               
-        self.inlinePatterns = [
-                               BACKTICK_PATTERN,
-                               ESCAPE_PATTERN,
-                               REFERENCE_PATTERN,
-                               LINK_PATTERN,
-                               IMAGE_LINK_PATTERN,
-                               IMAGE_REFERENCE_PATTERN,
-                               AUTOLINK_PATTERN,
-                               AUTOMAIL_PATTERN,
-                               LINE_BREAK_PATTERN_2,
-                               LINE_BREAK_PATTERN,
-                               HTML_PATTERN,
-                               ENTITY_PATTERN,
-                               NOT_STRONG_PATTERN,
-                               STRONG_EM_PATTERN,
-                               STRONG_PATTERN,
-                               EMPHASIS_PATTERN,
-                               EMPHASIS_PATTERN_2
-                               # The order of the handlers matters!!!
-                               ]
-        
-        self.inlineStash = InlineStash()
-        self.references = {}
-        self.htmlStash = HtmlStash()
-
-
-        self.registerExtensions(extensions = extensions,
-                                configs = extension_configs)
-
-        self.reset()
-
-
-    def registerExtensions(self, extensions, configs):
-        """ 
-        Register extensions with this instance of Markdown.
-
-        Keyword aurguments:
-        
-        * extensions: A list of extensions, which can either
-           be strings or objects.  See the docstring on Markdown.
-        * configs: A dictionary mapping module names to config options. 
-        
-        """
-        for ext in extensions:
-            if isinstance(ext, basestring):
-                ext = load_extension(ext, configs.get(ext, []))
-            elif hasattr(ext, 'extendMarkdown'):
-                # Looks like an Extension.
-                # Nothing to do here.
-                pass
-            else:
-                message(ERROR, "Incorrect type! Extension '%s' is "
-                               "neither a string or an Extension." %(repr(ext)))
-                continue
-            ext.extendMarkdown(self, globals())
-
-    def registerExtension(self, extension):
-        """ This gets called by the extension """
-        self.registeredExtensions.append(extension)
-
-    def reset(self):
-        """
-        Resets all state variables so that we can start with a new text.
-        """
-        self.inlineStash.rest()
-        self.htmlStash.rest()
-        self.references.clear()
-
-        HTML_BLOCK_PREPROCESSOR.stash = self.htmlStash
-        LINE_PREPROCESSOR.stash = self.htmlStash
-        REFERENCE_PREPROCESSOR.references = self.references
-        HTML_PATTERN.stash = self.htmlStash
-        ENTITY_PATTERN.stash = self.htmlStash
-        REFERENCE_PATTERN.references = self.references
-        IMAGE_REFERENCE_PATTERN.references = self.references
-        RAWHTMLTEXTPOSTPROCESSOR.stash = self.htmlStash
-        RAWHTMLTEXTPOSTPROCESSOR.safeMode = self.safeMode
-
-        for extension in self.registeredExtensions:
-            extension.reset()
-
-        for pattern in self.inlinePatterns:
-            pattern.safe_mode = self.safeMode
-
-    def _handleInline(self, data, patternIndex=0):
+    def __handleInline(self, data, patternIndex=0):
         """
         Process string with inline patterns and replace it
         with placeholders
@@ -1604,23 +1463,20 @@ class Markdown:
         Returns: String with placeholders. 
         
         """
-        if isinstance(data, AtomicString):
-            return data
-
-        startIndex = 0        
-        while patternIndex < len(self.inlinePatterns):
-            data, matched, startIndex = self._applyInline(
-                                             self.inlinePatterns[patternIndex],
-                                             data, patternIndex, startIndex)
-            if not matched:
-                patternIndex += 1
+        if not isinstance(data, AtomicString):
+            startIndex = 0        
+            while patternIndex < len(self.inlinePatterns):
+                data, matched, startIndex = self.__applyPattern(
+                                                 self.inlinePatterns[patternIndex],
+                                                 data, patternIndex, startIndex)
+                if not matched:
+                    patternIndex += 1
         return data
 
-
-    def _processElementText(self, node, subnode, isText=True):
+    def __processElementText(self, node, subnode, isText=True):
         """
         Process placeholders in Element.text or Element.tail
-        of Elements popped from InlineStash
+        of Elements popped from self.stashed_nodes.
         
         Keywords arguments:
         
@@ -1638,7 +1494,7 @@ class Markdown:
             text = subnode.tail
             subnode.tail = None
         
-        childResult = self._processPlaceholders(text, subnode)
+        childResult = self.__processPlaceholders(text, subnode)
         
         if not isText and node is not subnode:
             pos = node.getchildren().index(subnode)
@@ -1650,7 +1506,7 @@ class Markdown:
         for newChild in childResult:
             node.insert(pos, newChild)
     
-    def _processPlaceholders(self, data, parent):
+    def __processPlaceholders(self, data, parent):
         """
         Process string with placeholders and generate ElementTree tree.
         
@@ -1675,16 +1531,14 @@ class Markdown:
                         parent.text = text
             
         result = []
-        prefix = self.inlineStash.prefix
-        strartIndex = 0
-    
+        strartIndex = 0    
         while data:
-            index = data.find(prefix, strartIndex)
+            index = data.find(self.__placeholder_prefix, strartIndex)
             if index != -1:
-                id, phEndIndex = self.inlineStash.extractId(data, index)
+                id, phEndIndex = self.__findPlaceholder(data, index)
 
-                if self.inlineStash.isin(id):
-                    node = self.inlineStash.get(id)
+                if self.stashed_nodes.has_key(id):
+                    node = self.stashed_nodes.get(id)
              
                     if index > 0:
                         text = data[strartIndex:index]
@@ -1694,10 +1548,10 @@ class Markdown:
                         for child in [node] + node.getchildren():
                             if child.tail:
                                 if child.tail.strip():
-                                    self._processElementText(node, child, False)
+                                    self.__processElementText(node, child, False)
                             if child.text:
                                 if child.text.strip():
-                                    self._processElementText(child, child)
+                                    self.__processElementText(child, child)
                     else: # it's just a string
                         linkText(node)
                         strartIndex = phEndIndex
@@ -1718,10 +1572,10 @@ class Markdown:
         return result
 
     
-    def _applyInline(self, pattern, data, patternIndex, startIndex=0):
+    def __applyPattern(self, pattern, data, patternIndex, startIndex=0):
         """ 
         Check if the line fits the pattern, create the necessary 
-        elements, add it to InlineStash
+        elements, add it to stashed_nodes.
         
         Keyword arguments:
         
@@ -1749,17 +1603,17 @@ class Markdown:
                 for child in [node] + node.getchildren():
                     if not isString(node):
                         if child.text:
-                            child.text = self._handleInline(child.text, 
+                            child.text = self.__handleInline(child.text, 
                                                             patternIndex + 1)
                         if child.tail:
-                            child.tail = self._handleInline(child.tail, 
+                            child.tail = self.__handleInline(child.tail, 
                                                             patternIndex)
    
-        pholder = self.inlineStash.add(node, pattern.type())
+        placeholder = self.__stashNode(node, pattern.type())
 
         return "%s%s%s%s" % (leftData, 
                              match.group(1), 
-                             pholder, match.groups()[-1]), True, 0
+                             placeholder, match.groups()[-1]), True, 0
 
     
     def applyInlinePatterns(self, markdownTree):
@@ -1777,6 +1631,8 @@ class Markdown:
 
         Returns: ElementTree object with applied inline patterns.
         """
+        self.stashed_nodes = {}
+
         stack = [markdownTree.getroot()]
 
         while stack:
@@ -1786,7 +1642,7 @@ class Markdown:
                 if child.text and not isinstance(child.text, AtomicString):
                     text = child.text
                     child.text = None
-                    lst = self._processPlaceholders(self._handleInline(
+                    lst = self.__processPlaceholders(self.__handleInline(
                                                     text), child)
                     stack += lst
                     insertQueue.append((child, lst))
@@ -1811,6 +1667,139 @@ class Markdown:
                
         return markdownTree
 
+
+           
+
+class Markdown:
+    """Convert Markdown to HTML."""
+
+    def __init__(self, 
+                 extensions=[],
+                 extension_configs={},
+                 safe_mode = False):
+        """
+        Creates a new Markdown instance.
+
+        Keyword arguments:
+        
+        * extensions: A list of extensions.  
+           If they are of type string, the module mdx_name.py will be loaded.  
+           If they are a subclass of markdown.Extension, they will be used 
+           as-is.
+        * extension-configs: Configuration setting for extensions.
+        * safe_mode: Disallow raw html. One of "remove", "replace" or "escape".
+        
+        """
+        self.parser = MarkdownParser()
+        self.safeMode = safe_mode
+        self.registeredExtensions = []
+        self.docType = ""
+        self.stripTopLevelTags = True
+
+        self.textPreprocessors = [HTML_BLOCK_PREPROCESSOR]
+
+        self.preprocessors = [HEADER_PREPROCESSOR,
+                              LINE_PREPROCESSOR,
+                              # A footnote preprocessor will
+                              # get inserted here
+                              REFERENCE_PREPROCESSOR]
+
+
+        self.postprocessors = [PRETTIFYPOSTPROCESSOR,
+                               # a footnote postprocessor will get
+                               # inserted later
+                               ]
+
+        self.textPostprocessors = [# a footnote postprocessor will get
+                                   # inserted here
+                                   RAWHTMLTEXTPOSTPROCESSOR,
+                                   AMPSUBSTITUTETEXTPOSTPROCESSOR]
+
+        self.prePatterns = []
+                               
+        self.inlinePatterns = [
+                               BACKTICK_PATTERN,
+                               ESCAPE_PATTERN,
+                               REFERENCE_PATTERN,
+                               LINK_PATTERN,
+                               IMAGE_LINK_PATTERN,
+                               IMAGE_REFERENCE_PATTERN,
+                               AUTOLINK_PATTERN,
+                               AUTOMAIL_PATTERN,
+                               LINE_BREAK_PATTERN_2,
+                               LINE_BREAK_PATTERN,
+                               HTML_PATTERN,
+                               ENTITY_PATTERN,
+                               NOT_STRONG_PATTERN,
+                               STRONG_EM_PATTERN,
+                               STRONG_PATTERN,
+                               EMPHASIS_PATTERN,
+                               EMPHASIS_PATTERN_2
+                               # The order of the handlers matters!!!
+                               ]
+        
+        self.inlineProcessor = InlineProcessor(self.inlinePatterns)
+        self.references = {}
+        self.htmlStash = HtmlStash()
+
+
+        self.registerExtensions(extensions = extensions,
+                                configs = extension_configs)
+
+        self.reset()
+
+
+    def registerExtensions(self, extensions, configs):
+        """ 
+        Register extensions with this instance of Markdown.
+
+        Keyword aurguments:
+        
+        * extensions: A list of extensions, which can either
+           be strings or objects.  See the docstring on Markdown.
+        * configs: A dictionary mapping module names to config options. 
+        
+        """
+        for ext in extensions:
+            if isinstance(ext, basestring):
+                ext = load_extension(ext, configs.get(ext, []))
+            elif hasattr(ext, 'extendMarkdown'):
+                # Looks like an Extension.
+                # Nothing to do here.
+                pass
+            else:
+                message(ERROR, "Incorrect type! Extension '%s' is "
+                               "neither a string or an Extension." %(repr(ext)))
+                continue
+            ext.extendMarkdown(self, globals())
+
+    def registerExtension(self, extension):
+        """ This gets called by the extension """
+        self.registeredExtensions.append(extension)
+
+    def reset(self):
+        """
+        Resets all state variables so that we can start with a new text.
+        """
+        self.htmlStash.reset()
+        self.references.clear()
+
+        HTML_BLOCK_PREPROCESSOR.stash = self.htmlStash
+        LINE_PREPROCESSOR.stash = self.htmlStash
+        REFERENCE_PREPROCESSOR.references = self.references
+        HTML_PATTERN.stash = self.htmlStash
+        ENTITY_PATTERN.stash = self.htmlStash
+        REFERENCE_PATTERN.references = self.references
+        IMAGE_REFERENCE_PATTERN.references = self.references
+        RAWHTMLTEXTPOSTPROCESSOR.stash = self.htmlStash
+        RAWHTMLTEXTPOSTPROCESSOR.safeMode = self.safeMode
+
+        for extension in self.registeredExtensions:
+            extension.reset()
+
+        for pattern in self.inlinePatterns:
+            pattern.safe_mode = self.safeMode
+
     def convert (self, source):
         """Convert markdown to serialized XHTML."""
 
@@ -1823,10 +1812,8 @@ class Markdown:
             message(CRITICAL, 'UnicodeDecodeError: Markdown only accepts unicode or ascii input.')
             return u""
 
-        source = source.replace(STX, "")
-        source = source.replace(ETX, "")
-        source = source.replace("\r\n", "\n").replace("\r", "\n")
-        source += "\n\n"
+        source = source.replace(STX, "").replace(ETX, "")
+        source = source.replace("\r\n", "\n").replace("\r", "\n") + "\n\n"
         source = source.expandtabs(TAB_LENGTH)
 
         # Run the text preprocessors
@@ -1841,7 +1828,8 @@ class Markdown:
         # Parse the high-level elements.
         tree = self.parser.parseDocument(self.lines)
 
-        root = self.applyInlinePatterns(tree).getroot()
+        # Apply inline patterns
+        root = self.inlineProcessor.applyInlinePatterns(tree).getroot()
 
         # Run the post-processors
         for postprocessor in self.postprocessors:
@@ -2042,7 +2030,6 @@ def markdownFromFile(input = None,
                      encoding = None,
                      safe = False):
 
-
     md = Markdown(extensions=load_extensions(extensions),
                   safe_mode = safe_mode)
     md.convertFile(input, output, encoding)