""" ========================= FOOTNOTES ================================= This section adds footnote handling to markdown. It can be used as an example for extending python-markdown with relatively complex functionality. While in this case the extension is included inside the module itself, it could just as easily be added from outside the module. Not that all markdown classes above are ignorant about footnotes. All footnote functionality is provided separately and then added to the markdown instance at the run time. Footnote functionality is attached by calling extendMarkdown() method of FootnoteExtension. The method also registers the extension to allow it's state to be reset by a call to reset() method. Example: Footnotes[^1] have a label[^label] and a definition[^!DEF]. [^1]: This is a footnote [^label]: A footnote on "label" [^!DEF]: The footnote for definition """ import re, markdown, random from markdown import etree FN_BACKLINK_TEXT = "zz1337820767766393qq" DEF_RE = re.compile(r'(\ ?\ ?\ ?)\[\^([^\]]*)\]:\s*(.*)') SHORT_USE_RE = re.compile(r'\[\^([^\]]*)\]', re.M) # [^a] class FootnoteExtension(markdown.Extension): """ Footnote Extension. """ def __init__ (self, configs): self.config = {'PLACE_MARKER': ["///Footnotes Go Here///", "The text string that marks where the footnotes go"]} self.parser = markdown.MarkdownParser() for key, value in configs: self.config[key][0] = value self.reset() def extendMarkdown(self, md, md_globals): """ Add pieces to Markdown. """ md.registerExtension(self) # Insert a preprocessor before ReferencePreprocessor md.preprocessors.add("footnote", FootnotePreprocessor(self), "amp_substitute") def reset(self): """ Clear the footnotes on reset. """ self.footnote_suffix = "-" + str(int(random.random()*1000000000)) self.used_footnotes={} self.footnotes = {} def findFootnotesPlaceholder(self, root): def finder(element): for child in element: if child.text: if child.text.find(self.getConfig("PLACE_MARKER")) > -1: return child, True if child.tail: if child.tail.find(self.getConfig("PLACE_MARKER")) > -1: return (child, element), False finder(child) return None res = finder(root) return res def setFootnote(self, id, text): self.footnotes[id] = text def makeFootnoteId(self, num): return 'fn%d%s' % (num, self.footnote_suffix) def makeFootnoteRefId(self, num): return 'fnr%d%s' % (num, self.footnote_suffix) def makeFootnotesDiv(self, root): """Creates the div with class='footnote' and populates it with the text of the footnotes. @returns: the footnote div as a dom element """ if not self.footnotes.keys(): return None div = etree.Element("div") div.set('class', 'footnote') hr = etree.SubElement(div, "hr") ol = etree.SubElement(div, "ol") footnotes = [(self.used_footnotes[id], id) for id in self.footnotes.keys()] footnotes.sort() for i, id in footnotes : li = etree.SubElement(ol, "li") li.set("id", self.makeFootnoteId(i)) self.parser.parseChunk(li, self.footnotes[id].split("\n"), looseList=1) backlink = etree.Element("a") backlink.set("href", "#" + self.makeFootnoteRefId(i)) backlink.set("class", "footnoteBackLink") backlink.set("title", "Jump back to footnote %d in the text" % i) backlink.text = FN_BACKLINK_TEXT if li.getchildren(): node = li[-1] if node.text: li.append(backlink) elif node.tag == "p": node.append(backlink) else: p = etree.SubElement(li, "p") p.append(backlink) return div class FootnotePreprocessor(markdown.Preprocessor): """ Find all footnote references and store for later use. """ def __init__ (self, footnotes): self.footnotes = footnotes def run(self, lines): lines = self._handleFootnoteDefinitions(lines) # Make a hash of all footnote marks in the text so that we # know in what order they are supposed to appear. (This # function call doesn't really substitute anything - it's just # a way to get a callback for each occurence. text = "\n".join(lines) SHORT_USE_RE.sub(self.recordFootnoteUse, text) return text.split("\n") def recordFootnoteUse(self, match): id = match.group(1) id = id.strip() nextNum = len(self.footnotes.used_footnotes.keys()) + 1 self.footnotes.used_footnotes[id] = nextNum def _handleFootnoteDefinitions(self, lines): """Recursively finds all footnote definitions in the lines. @param lines: a list of lines of text @returns: a string representing the text with footnote definitions removed """ i, id, footnote = self._findFootnoteDefinition(lines) if id : plain = lines[:i] detabbed, theRest = self.footnotes.parser.detectTabbed(lines[i+1:]) self.footnotes.setFootnote(id, footnote + "\n" + "\n".join(detabbed)) more_plain = self._handleFootnoteDefinitions(theRest) return plain + [""] + more_plain else : return lines def _findFootnoteDefinition(self, lines): """Finds the first line of a footnote definition. @param lines: a list of lines of text @returns: the index of the line containing a footnote definition """ counter = 0 for line in lines : m = DEF_RE.match(line) if m : return counter, m.group(2), m.group(3) counter += 1 return counter, None, None class FootnotePattern(markdown.Pattern): """ InlinePattern for footnote markers in a document's body text. """ def __init__(self, pattern, footnotes): markdown.Pattern.__init__(self, pattern) self.footnotes = footnotes def handleMatch(self, m): sup = etree.Element("sup") a = etree.SubElement(sup, "a") id = m.group(2) num = self.footnotes.used_footnotes[id] sup.set('id', self.footnotes.makeFootnoteRefId(num)) a.set('href', '#' + self.footnotes.makeFootnoteId(num)) a.text = str(num) return sup class FootnoteTreeprocessor(markdown.Treeprocessor): """ Build and append footnote div to end of document. """ def __init__ (self, footnotes): self.footnotes = footnotes def run(self, root): footnotesDiv = self.footnotes.makeFootnotesDiv(root) if footnotesDiv: result = self.footnotes.findFootnotesPlaceholder(root) if result: node, isText = result if isText: node.text = None node.getchildren().insert(0, footnotesDiv) else: child, element = node ind = element.getchildren().find(child) element.getchildren().insert(ind + 1, footnotesDiv) child.tail = None fnPlaceholder.parent.replaceChild(fnPlaceholder, footnotesDiv) else : root.append(footnotesDiv) class FootnotePostprocessor(markdown.Postprocessor): """ Replace FN_BACKLINK_TEXT with html entity ``↩``. """ def run(self, text): return text.replace(FN_BACKLINK_TEXT, "↩") def makeExtension(configs=[]): """ Return an instance of the FootnoteExtension """ return FootnoteExtension(configs=configs)