diff options
Diffstat (limited to 'markdown.py')
| -rw-r--r-- | markdown.py | 281 |
1 files changed, 169 insertions, 112 deletions
diff --git a/markdown.py b/markdown.py index 92e180e..5e5586f 100644 --- a/markdown.py +++ b/markdown.py @@ -33,7 +33,7 @@ __revision__ = "$Rev$" -import re, sys, codecs +import re, sys, codecs, copy from urlparse import urlparse, urlunparse from logging import getLogger, StreamHandler, Formatter, \ @@ -124,6 +124,7 @@ def isBlockLevel (tag): return ( (tag in BLOCK_LEVEL_ELEMENTS) or (tag[0] == 'h' and tag[1] in "0123456789") ) + """ ====================================================================== ========================== NANODOM =================================== @@ -783,16 +784,18 @@ BACKTICK_RE = r'\`([^\`]*)\`' # `e= m*c^2` DOUBLE_BACKTICK_RE = r'\`\`(.*?)\`\`' # ``e=f("`")`` ESCAPE_RE = r'\\(.)' # \< EMPHASIS_RE = r'\*([^\*]*)\*' # *emphasis* -STRONG_RE = r'\*\*(.*?)\*\*' # **strong** -STRONG_EM_RE = r'\*\*\*(.*?)\*\*\*' # ***strong*** +STRONG_RE = r'\*\*(.*?|[^**]+?)\*\*' # **strong** +STRONG_EM_RE = r'\*\*\*(.*?|[^***]+?)\*\*\*' # ***strong*** + + if SMART_EMPHASIS: EMPHASIS_2_RE = r'(?<!\S)_(\S[^_]*)_' # _emphasis_ else: EMPHASIS_2_RE = r'_([^_]*)_' # _emphasis_ -STRONG_2_RE = r'__(.*?)__' # __strong__ -STRONG_EM_2_RE = r'___(.*?)___' # ___strong___ +STRONG_2_RE = r'__(.*?|[^__]+?)__' # __strong__ +STRONG_EM_2_RE = r'___(.*?|[^___]+?)___' # ___strong___ LINK_RE = NOIMG + BRK + r'\s*\(([^\)]*)\)' # [text](url) LINK_ANGLED_RE = NOIMG + BRK + r'\s*\(<([^\)]*)>\)' # [text](<url>) @@ -1294,7 +1297,31 @@ def dequote(string): return string[1:-1] else: return string - + + +class InlineStash: + + def __init__(self): + self.prefix = "k@J!}" + self.suffix = "lL5Qt" + self._nodes = {} + self.phLength = 4 + len(self.prefix) + len(self.suffix) + + def _genPlaceholder(self): + hash = "%s%04d%s" % (self.prefix, len(self._nodes), self.suffix) + return hash + + def isin(self, placeholder): + return self._nodes.has_key(placeholder) + + def get(self, placeholder): + return self._nodes.get(placeholder) + + def add(self, node): + pholder = self._genPlaceholder() + self._nodes[pholder] = node + return pholder + """ ====================================================================== ========================== CORE MARKDOWN ============================= @@ -1387,7 +1414,33 @@ class Markdown: self.prePatterns = [] - + # temporarily disabled patterns + '''DOUBLE_BACKTICK_PATTERN, + BACKTICK_PATTERN, + ESCAPE_PATTERN, + REFERENCE_PATTERN, + LINK_ANGLED_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_EM_PATTERN_2,''' + + '''self.inlinePatterns = [LINK_PATTERN, + 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, @@ -1395,8 +1448,8 @@ class Markdown: LINK_ANGLED_PATTERN, LINK_PATTERN, IMAGE_LINK_PATTERN, - IMAGE_REFERENCE_PATTERN, - AUTOLINK_PATTERN, + IMAGE_REFERENCE_PATTERN, + AUTOLINK_PATTERN, AUTOMAIL_PATTERN, LINE_BREAK_PATTERN_2, LINE_BREAK_PATTERN, @@ -1411,6 +1464,8 @@ class Markdown: EMPHASIS_PATTERN_2 # The order of the handlers matters!!! ] + + self.inlineStash = InlineStash() self.registerExtensions(extensions = extensions, configs = extension_configs) @@ -1453,6 +1508,7 @@ class Markdown: """ self.references={} self.htmlStash = HtmlStash() + self.inlineStash = InlineStash() HTML_BLOCK_PREPROCESSOR.stash = self.htmlStash LINE_PREPROCESSOR.stash = self.htmlStash @@ -1486,6 +1542,7 @@ class Markdown: self.top_element.setAttribute('class', 'markdown') self.doc.appendChild(self.top_element) + # Split into lines and run the preprocessors that will work with # self.lines @@ -1821,134 +1878,133 @@ class Markdown: text = "\n".join(detabbed).rstrip()+"\n" #text = text.replace("&", "&") code.appendChild(self.doc.createTextNode(text)) - self._processSection(parent_elem, theRest, inList) - - - - def _handleInline (self, line, patternIndex=0): + self._processSection(parent_elem, theRest, inList) + + def _handleInline(self, data, patternIndex=0): """ - Transform a Markdown line with inline elements to an XHTML - fragment. - - This function uses auxiliary objects called inline patterns. - See notes on inline patterns above. + Processinf string with inline patterns and replasing it + with placeholders Keyword arguments: - * line: A line of Markdown text + * data: A line of Markdown text * patternIndex: The index of the inlinePattern to start with - Return: A list of NanoDom nodes + Return: String with placeholders. """ - - - parts = [line] - + while patternIndex < len(self.inlinePatterns): + + data, matched = self._applyInline(self.inlinePatterns[patternIndex], + data, patternIndex) + if not matched: + patternIndex += 1 + + return data + #return self._processPlaceholders(data) + + + def _processPlaceholders(self, data): + """ + Processes string with placeholders and generates DOM tree. + + * data: string with placeholders instead of DOM elements. - i = 0 - - while i < len(parts): + Returns: NanoDOM Document object with applied inline patterns. + """ + + result = [] + prefix = self.inlineStash.prefix + strartIndex = 0 + while data: + + index = data.find(prefix, strartIndex) + if index != -1: - x = parts[i] - - if isinstance(x, (str, unicode)): - result = self._applyPattern(x, \ - self.inlinePatterns[patternIndex], \ - patternIndex) - - if result: - i -= 1 - parts.remove(x) - for y in result: - parts.insert(i+1,y) - - i += 1 - patternIndex += 1 - - for i in range(len(parts)): - x = parts[i] - if isinstance(x, (str, unicode)): - parts[i] = self.doc.createTextNode(x) + phEndIndex = index + self.inlineStash.phLength + placeHolder = data[index: phEndIndex] + + if self.inlineStash.isin(placeHolder): + + if index > 0: + + textNode = self.doc.createTextNode(data[strartIndex:index]) + + result.append(textNode) + + node = self.inlineStash.get(placeHolder) - return parts + if isinstance(node, Element): + for child in node.childNodes: + if isinstance(child, TextNode): + childResult = self._processPlaceholders(child.value) + pos = node.childNodes.index(child) + node.removeChild(child) + for newChild in childResult: + node.insertChild(pos, newChild) + + result.append(node) + + strartIndex = phEndIndex + + else: + + strartIndex = index + len(prefix) + else: + text = self.doc.createTextNode(data[strartIndex:]) + result.append(text) + data = "" + + return result + + - def _applyPattern(self, line, pattern, patternIndex): - + def _applyInline(self, pattern, data, patternIndex): """ Given a pattern name, this function checks if the line - fits the pattern, creates the necessary elements, and returns - back a list consisting of NanoDom elements and/or strings. + fits the pattern, creates the necessary elements, adds it + to InlineStash, and returns string with placeholders, + instead of DOM elements. Keyword arguments: - * line: the text to be processed + * data: the text to be processed * pattern: the pattern to be checked + * patternIndex: index of current pattern - Returns: The appropriate newly created NanoDom element if the - pattern matches, None otherwise. + Returns: String with placeholders. """ + + match = pattern.getCompiledRegExp().match(data) + + if not match: + return data, False - # match the line to pattern's pre-compiled reg exp. - # if no match, move on. - - - - m = pattern.getCompiledRegExp().match(line) - if not m: - return None - - # if we got a match let the pattern make us a NanoDom node - # if it doesn't, move on - node = pattern.handleMatch(m, self.doc) - - # check if any of this nodes have children that need processing - + node = pattern.handleMatch(match, self.doc) + if isinstance(node, Element): + for child in node.childNodes: + if isinstance(child, TextNode): + child.value = self._handleInline(child.value, patternIndex) + + + pholder = self.inlineStash.add(node) - if not node.nodeName in ["code", "pre"]: - for child in node.childNodes: - if isinstance(child, TextNode): - - result = self._handleInline(child.value, patternIndex+1) - - if result: - - if result == [child]: - continue - - result.reverse() - #to make insertion easier - - position = node.childNodes.index(child) - - node.removeChild(child) - - for item in result: - - if isinstance(item, (str, unicode)): - if len(item) > 0: - node.insertChild(position, - self.doc.createTextNode(item)) - else: - node.insertChild(position, item) - - - - - 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: - return None + return "%s%s%s" % (match.group(1), pholder, match.groups()[-1]), True def _processTree(self, el): + """ + Processing NanoDOM markdown tree, and applying inline patterns + + Keyword arguments: + + * el - parent element of Document. + + Returns: NanoDOM Document object with applied inline patterns. + """ stack = [el] while stack: @@ -1958,7 +2014,8 @@ class Markdown: if child.type == "inline": - lst = self._handleInline(child.value) + lst = self._processPlaceholders(self._handleInline( + child.value)) pos = currElement.childNodes.index(child) @@ -1971,7 +2028,7 @@ class Markdown: del currElement.childNodes[pos] for newChild in lst: currElement.insertChild(pos, newChild) - pos += 1 + pos += 1 def applyInlinePatterns(self, markdownTree): """ @@ -2003,7 +2060,7 @@ class Markdown: * source: An ascii or unicode string of Markdown formated text. - Returns: NanoDOM document. + Returns: NanoDOM Document object. """ if source is not None: #Allow blank string self.source = source |