FM / markdown

/usr/lib/python2.6/site-packages/markdown/

/usr/lib/python2.6/site-packages/markdown

Name	Size	Mode	Actions
extensions/	-	0755	rm
blockparser.py	3358	0644	edit dl rm
blockparser.pyc	4608	0644	edit dl rm
blockparser.pyo	4608	0644	edit dl rm
blockprocessors.py	17769	0644	edit dl rm
blockprocessors.pyc	17263	0644	edit dl rm
blockprocessors.pyo	17263	0644	edit dl rm
commandline.py	3534	0644	edit dl rm
commandline.pyc	3205	0644	edit dl rm
commandline.pyo	3205	0644	edit dl rm
etree_loader.py	1287	0644	edit dl rm
etree_loader.pyc	1212	0644	edit dl rm
etree_loader.pyo	1212	0644	edit dl rm
html4.py	9672	0644	edit dl rm
html4.pyc	7065	0644	edit dl rm
html4.pyo	7019	0644	edit dl rm
inlinepatterns.py	12179	0644	edit dl rm
inlinepatterns.pyc	15952	0644	edit dl rm
inlinepatterns.pyo	15952	0644	edit dl rm
odict.py	5157	0644	edit dl rm
odict.pyc	7396	0644	edit dl rm
odict.pyo	7396	0644	edit dl rm
postprocessors.py	2471	0644	edit dl rm
postprocessors.pyc	3693	0644	edit dl rm
postprocessors.pyo	3693	0644	edit dl rm
preprocessors.py	7140	0644	edit dl rm
preprocessors.pyc	7413	0644	edit dl rm
preprocessors.pyo	7413	0644	edit dl rm
treeprocessors.py	11432	0644	edit dl rm
treeprocessors.pyc	11083	0644	edit dl rm
treeprocessors.pyo	11083	0644	edit dl rm
__init__.py	21496	0644	edit dl rm
__init__.pyc	18151	0644	edit dl rm
__init__.pyo	18151	0644	edit dl rm

Edit: /usr/lib/python2.6/site-packages/markdown/blockparser.py (3358B)

import markdown

class State(list):
    """ Track the current and nested state of the parser. 
    
    This utility class is used to track the state of the BlockParser and 
    support multiple levels if nesting. It's just a simple API wrapped around
    a list. Each time a state is set, that state is appended to the end of the
    list. Each time a state is reset, that state is removed from the end of
    the list.

Therefore, each time a state is set for a nested block, that state must be 
    reset when we back out of that level of nesting or the state could be
    corrupted.

While all the methods of a list object are available, only the three
    defined below need be used.

"""

def set(self, state):
        """ Set a new state. """
        self.append(state)

def reset(self):
        """ Step back one step in nested state. """
        self.pop()

def isstate(self, state):
        """ Test that top (current) level is of given state. """
        if len(self):
            return self[-1] == state
        else:
            return False

class BlockParser:
    """ Parse Markdown blocks into an ElementTree object. 
    
    A wrapper class that stitches the various BlockProcessors together,
    looping through them and creating an ElementTree object.
    """

def __init__(self):
        self.blockprocessors = markdown.odict.OrderedDict()
        self.state = State()

def parseDocument(self, lines):
        """ Parse a markdown document into an ElementTree. 
        
        Given a list of lines, an ElementTree object (not just a parent Element)
        is created and the root element is passed to the parser as the parent.
        The ElementTree object is returned.
        
        This should only be called on an entire document, not pieces.

"""
        # Create a ElementTree from the lines
        self.root = markdown.etree.Element(markdown.DOC_TAG)
        self.parseChunk(self.root, '\n'.join(lines))
        return markdown.etree.ElementTree(self.root)

def parseChunk(self, parent, text):
        """ Parse a chunk of markdown text and attach to given etree node. 
        
        While the ``text`` argument is generally assumed to contain multiple
        blocks which will be split on blank lines, it could contain only one
        block. Generally, this method would be called by extensions when
        block parsing is required. 
        
        The ``parent`` etree Element passed in is altered in place. 
        Nothing is returned.

"""
        self.parseBlocks(parent, text.split('\n\n'))

def parseBlocks(self, parent, blocks):
        """ Process blocks of markdown text and attach to given etree node. 
        
        Given a list of ``blocks``, each blockprocessor is stepped through
        until there are no blocks left. While an extension could potentially
        call this method directly, it's generally expected to be used internally.

This is a public method as an extension may need to add/alter additional
        BlockProcessors which call this method to recursively parse a nested
        block.

"""
        while blocks:
           for processor in self.blockprocessors.values():
               if processor.test(parent, blocks[0]):
                   processor.run(parent, blocks)
                   break

cmd: