%s\n
" % (HTML_PLACEHOLDER % i), + html + "\n") + text = text.replace(HTML_PLACEHOLDER % i, html) + return text + + def escape(self, html): + ''' Basic html escaping ''' + html = html.replace('&', '&') + html = html.replace('<', '<') + html = html.replace('>', '>') + return html.replace('"', '"') + +RAWHTMLTEXTPOSTPROCESSOR = RawHtmlTextPostprocessor() + """ ====================================================================== ========================== MISC AUXILIARY CLASSES ==================== ====================================================================== """ -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) : + 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. @param html: an html segment + @param safe: label an html segment as safe for safemode + @param inline: label a segmant as inline html @returns : a placeholder string """ - self.rawHtmlBlocks.append(html) + self.rawHtmlBlocks.append((html, safe)) placeholder = HTML_PLACEHOLDER % self.html_counter self.html_counter += 1 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. @@ -925,10 +994,11 @@ class BlockGuru : remainder of the original list""" items = [] - + item = -1 + 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:] @@ -938,11 +1008,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 @@ -950,36 +1020,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) @@ -990,12 +1060,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 """ @@ -1008,13 +1078,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 @@ -1023,13 +1093,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) @@ -1043,66 +1113,68 @@ class Markdown: Markdown text """ - def __init__(self, source=None, # deprecated + def __init__(self, source=None, # depreciated extensions=[], extension_configs=None, - encoding="utf-8", safe_mode = False): """Creates a new Markdown instance. - @param source: The text in Markdown format. - @param encoding: The character encoding ofaround it - append the paragraph bits directly - # onto parent_elem - el = parent_elem - else : - # Otherwise make a "p" element - el = self.doc.createElement("p") - parent_elem.appendChild(el) - - for item in list : - el.appendChild(item) - + not line.strip()) + + if len(paragraph) and paragraph[0].startswith('#'): + self._processHeader(parent_elem, paragraph) + + elif paragraph: + self._processParagraph(parent_elem, paragraph, + inList, looseList) + if lines and not lines[0].strip(): lines = lines[1:] # skip the first (blank) line - - def _processUList(self, parent_elem, lines, inList) : + def _processHeader(self, parent_elem, paragraph): + m = RE.regExp['header'].match(paragraph[0]) + 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()): + h.appendChild(item) + else: + message(CRITICAL, "We've got a problem header!") + + + def _processParagraph(self, parent_elem, paragraph, inList, looseList): + list = self._handleInlineWrapper("\n".join(paragraph)) + + if ( parent_elem.nodeName == 'li' + and not (looseList or parent_elem.childNodes)): + + # If this is the first paragraph inside "li", don't + # put
around it - append the paragraph bits directly + # onto parent_elem + el = parent_elem + else: + # Otherwise make a "p" element + el = self.doc.createElement("p") + parent_elem.appendChild(el) + + for item in list: + el.appendChild(item) + + + 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. @@ -1337,20 +1422,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 @@ -1362,7 +1447,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) @@ -1371,26 +1456,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) @@ -1401,21 +1486,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 @@ -1428,15 +1513,22 @@ class Markdown: dequoted = [] i = 0 - for line in lines : + blank_line = False # allow one blank line between paragraphs + for line in lines: m = RE.regExp['quoted'].match(line) - if m : + if m: dequoted.append(m.group(1)) i += 1 - else : + blank_line = False + elif not blank_line and line.strip() != '': + dequoted.append(line) + i += 1 + elif not blank_line and line.strip() == '': + dequoted.append(line) + i += 1 + blank_line = True + else: break - else : - i += 1 blockquote = self.doc.createElement('blockquote') parent_elem.appendChild(blockquote) @@ -1447,7 +1539,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 ("
") and recursively processes the
@@ -1471,32 +1563,35 @@ class Markdown:
- def _handleInlineWrapper (self, line) :
+ def _handleInlineWrapper (self, line, patternIndex=0):
parts = [line]
- for pattern in 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)) :
- result = self._applyPattern(x, pattern)
+ if isinstance(x, (str, unicode)):
+ result = self._applyPattern(x, \
+ self.inlinePatterns[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
@@ -1515,13 +1610,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) :
+ def _applyPattern(self, line, pattern, patternIndex=0):
""" Given a pattern name, this function checks if the line
fits the pattern, creates the necessary elements, and returns
@@ -1540,7 +1635,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
@@ -1551,15 +1646,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)
+ result = self._handleInlineWrapper(child.value, patternIndex+1)
if result:
- if result == [child] :
+ if result == [child]:
continue
result.reverse()
@@ -1581,74 +1676,61 @@ 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):
"""Return the document in XHTML format.
@returns: A serialized XHTML body."""
- #try :
- if source :
+ if source is not None: #Allow blank string
self.source = source
- if not self.source :
- return ""
+ if not self.source:
+ return u""
- self.source = removeBOM(self.source, self.encoding)
+ try:
+ self.source = unicode(self.source)
+ except UnicodeDecodeError:
+ message(CRITICAL, 'UnicodeDecodeError: Markdown only accepts unicode or ascii input.')
+ return u""
for pp in self.textPreprocessors:
self.source = pp.run(self.source)
-
+
doc = self._transform()
xml = doc.toxml()
- #finally:
- # doc.unlink()
- # Let's stick in all the raw html pieces
+ # Return everything but the top level tag
- for i in range(self.htmlStash.html_counter) :
- html = self.htmlStash.rawHtmlBlocks[i]
- if self.safeMode and html != "
" and html != "
":
- html = HTML_REMOVED_TEXT
-
- xml = xml.replace("%s\n
" % (HTML_PLACEHOLDER % i),
- html + "\n")
- xml = xml.replace(HTML_PLACEHOLDER % i,
- html)
-
- # And 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()
- __str__ = convert # deprecated - will be changed in 1.7 to report
- # information about the MD instance
-
- toString = __str__ # toString() method is deprecated
+ def __str__(self):
+ ''' Report info about instance. Markdown always returns unicode. '''
+ if self.source is None:
+ status = 'in which no source text has been assinged.'
+ else:
+ status = 'which contains %d chars and %d line(s) of source.'%\
+ (len(self.source), self.source.count('\n')+1)
+ return 'An instance of "%s" %s'% (self.__class__, status)
+ __unicode__ = convert # markdown should always return a unicode string
- def __unicode__(self):
- """Return the document in XHTML format as a Unicode object.
- """
- return str(self)#.decode(self.encoding)
-
-
- toUnicode = __unicode__ # deprecated - will be removed in 1.7
@@ -1660,46 +1742,46 @@ def markdownFromFile(input = None,
extensions = [],
encoding = None,
message_threshold = CRITICAL,
- safe = False) :
+ safe = False):
- global MESSAGE_THRESHOLD
- MESSAGE_THRESHOLD = message_threshold
+ global console_hndlr
+ console_hndlr.setLevel(message_threshold)
- message(VERBOSE, "input file: %s" % input)
+ message(DEBUG, "input file: %s" % input)
-
- if not encoding :
+ if not encoding:
encoding = "utf-8"
input_file = codecs.open(input, mode="r", encoding=encoding)
text = input_file.read()
input_file.close()
- new_text = markdown(text, extensions, encoding, safe_mode = safe)
+ text = removeBOM(text, encoding)
- if output :
+ new_text = markdown(text, extensions, safe_mode = safe)
+
+ 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(VERBOSE, "in markdown.markdown(), received text:\n%s" % text)
+ 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(",")]
@@ -1713,21 +1795,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
@@ -1739,20 +1821,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 }
+ except:
+ if len(sys.argv) == 2:
+ return {'input': sys.argv[1],
+ 'output': None,
+ 'message_threshold': CRITICAL,
+ 'safe': False,
+ 'extensions': [],
+ 'encoding': None }
- else :
+ else:
print OPTPARSE_WARNING
return None
@@ -1764,63 +1846,45 @@ def parse_options() :
parser.add_option("-e", "--encoding", dest="encoding",
help="encoding for input and output files",)
parser.add_option("-q", "--quiet", default = CRITICAL,
- action="store_const", const=NONE, dest="verbose",
+ action="store_const", const=60, dest="verbose",
help="suppress all messages")
parser.add_option("-v", "--verbose",
action="store_const", const=INFO, dest="verbose",
help="print info messages")
- parser.add_option("-s", "--safe",
- action="store_const", const=True, dest="safe",
- help="same mode (strip user's HTML tag)")
+ parser.add_option("-s", "--safe", dest="safe", default=False,
+ metavar="SAFE_MODE",
+ help="same mode ('replace', 'remove' or 'escape' user's HTML tag)")
parser.add_option("--noisy",
- action="store_const", const=VERBOSE, dest="verbose",
+ action="store_const", const=DEBUG, dest="verbose",
help="print debug messages")
parser.add_option("-x", "--extension", action="append", dest="extensions",
help = "load extension EXTENSION", metavar="EXTENSION")
(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 }
def main():
options = parse_options()
-
- #if os.access(inFile, os.R_OK):
-
- if not options :
- sys.exit(0)
-
+ if not options:
+ return 0
markdownFromFile(**options)
-
- return 0
-
if __name__ == '__main__':
""" Run Markdown from the command line. """
- sys.exit(main())
-
-
-
-
-
-
-
-
-
-
-
+ sys.exit(main)
\ No newline at end of file