diff options
Diffstat (limited to 'markdown.py')
| -rwxr-xr-x | markdown.py | 391 |
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) |