Why Gemfury?
Push, build, and install
RubyGems
npm packages
Python packages
Maven artifacts
PHP packages
Go Modules
Debian packages
RPM packages
NuGet packages
hemamaps
Repository URL to install this package:
|
Version:
2.6.6 ▾
|
Markdown
/
blockprocessors.pyc
|
|---|
ó
ÂöWc @` s| d Z d d l m Z d d l m Z d d l m Z d d l Z d d l Z d d l m Z d d l m
Z
e j d Z d
Z
d e f d YZ d
e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d S(! uë
CORE MARKDOWN BLOCKPARSER
===========================================================================
This parser handles basic parsing of Markdown blocks. It doesn't concern
itself with inline elements such as **bold** or *italics*, but rather just
catches blocks, lists, quotes, etc.
The BlockParser is made up of a bunch of BlockProssors, each handling a
different type of block. Extensions may add/replace/remove BlockProcessors
as they need to alter how markdown blocks are parsed.
i ( t absolute_import( t division( t unicode_literalsNi ( t util( t BlockParseru MARKDOWNc K` sÎ t | } t | | j d <t | | j d <t | | j d <t | | j d <t | | j d <t | | j d <t | | j d <t | | j d <t
| | j d <t | | j d
<| S( u2 Build the default block parser used by Markdown. u emptyu indentu codeu
hashheaderu setextheaderu hru olistu ulistu quoteu paragraph( R t EmptyBlockProcessort blockprocessorst ListIndentProcessort CodeBlockProcessort HashHeaderProcessort SetextHeaderProcessort HRProcessort OListProcessort UListProcessort BlockQuoteProcessort ParagraphProcessor( t md_instancet kwargst parser( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyt build_block_parser s t BlockProcessorc B` sG e Z d Z d Z d Z d Z d d Z d Z d Z RS( u Base class for block processors.
Each subclass will provide the methods below to work with the source and
tree. Each processor will need to define it's own ``test`` and ``run``
methods. The ``test`` method should return True or False, to indicate
whether the current block should be processed by this processor. If the
test passes, the parser will call the processors ``run`` method.
c C` s | | _ | j j | _ d S( N( R t markdownt
tab_length( t selfR ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyt __init__4 s c C` s t | r | d Sd Sd S( u, Return the last child of an etree element. iÿÿÿÿN( t lent None( R t parent( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyt lastChild8 s c C` s g } | j d } xX | D]P } | j d | j rO | j | | j q | j sk | j d q Pq Wd j | d j | t | f S( u= Remove a tab from the front of each line of the given text. u
u u ( t splitt
startswithR t appendt stript joinR ( R t textt newtextt linest line( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyt detab? s
i c C` ss | j d } xT t t | D]@ } | | j d | j | r" | | | j | | | <q" q" Wd j | S( u? Remove a tab from front of lines but allowing dedented lines. u
u ( R t rangeR R R R! ( R R" t levelR$ t i( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyt
looseDetabL s
c C` s d S( ue Test for block type. Must be overridden by subclasses.
As the parser loops through processors, it will call the ``test``
method on each to determine if the given block of text is of that
type. This method must return a boolean ``True`` or ``False``. The
actual method of testing is left to the needs of that particular
block type. It could be as simple as ``block.startswith(some_string)``
or a complex regular expression. As the block type may be different
depending on the parent of the block (i.e. inside a list), the parent
etree element is also provided and may be used as part of the test.
Keywords:
* ``parent``: A etree element which will be the parent of the block.
* ``block``: A block of text from the source which has been split at
blank lines.
N( ( R R t block( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyt testT s c C` s d S( u½ Run processor. Must be overridden by subclasses.
When the parser determines the appropriate type of a block, the parser
will call the corresponding processor's ``run`` method. This method
should parse the individual lines of the block and append them to
the etree.
Note that both the ``parent`` and ``etree`` keywords are pointers
to instances of the objects which should be edited in place. Each
processor must make changes to the existing objects as there is no
mechanism to return new/different objects to replace them.
This means that this method should be adding SubElements or adding text
to the parent, and should remove (``pop``) or add (``insert``) items to
the list of blocks.
Keywords:
* ``parent``: A etree element which is the parent of the current block.
* ``blocks``: A list of all remaining blocks of the document.
N( ( R R t blocks( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyt runh s ( t __name__t
__module__t __doc__R R R& R* R, R. ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR ) s
R c B` sP e Z d Z d g Z d d g Z d Z d Z d Z d Z d Z RS( u Process children of list items.
Example:
* a list item
process this part
or this part
u liu ulu olc G` s3 t t | j | t j d | j | _ d S( Nu
^(([ ]{%s})+)( t superR R t ret compileR t INDENT_RE( R t args( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR s c C` sn | j d | j om | j j j d om | j | j k pm t | om | d d k om | d j | j k S( Nu u detabbediÿÿÿÿ(
R R R t statet isstatet tagt
ITEM_TYPESR R t
LIST_TYPES( R R R+ ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR, s
c C` s | j d } | j | | \ } } | j | | } | j j j d | j | j k r¶ t | r | d j | j k r | j j
| d | g q| j j
| | g nÊ | j | j k rá | j j
| | g n t | rp| d j | j k rp| d j rVt j
j d } | d j | _ d | d _ | d j d | n | j j | d | n | j | | | j j j d S( Ni u detabbediÿÿÿÿu pu ( t popt get_levelR* R R7 t setR9 R: R R; t parseBlocksR" R t etreet Elementt insertt
parseChunkt create_itemt reset( R R R- R+ R( t siblingt p( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR. s& " "
c C` s/ t j j | d } | j j | | g d S( u< Create a new li and parse the block with it as the parent. u liN( R R@ t
SubElementR R? ( R R R+ t li( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyRD ¾ s c C` sæ | j j | } | r7 t | j d | j } n d } | j j j d r[ d } n d } xx | | k rÛ | j | } | d k r× | j
| j k s¯ | j
| j k r× | j
| j k rÎ | d 7} n | } qd Pqd W| | f S( u* Get level of indent based on list level. i i u listN(
R5 t matchR t groupR R R7 R8 R R R9 R; R: ( R R R+ t mt indent_levelR( t child( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR= Ã s $
(
R/ R0 R1 R: R; R R, R. RD R= ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR s $ R c B` s e Z d Z d Z d Z RS( u Process code blocks. c C` s | j d | j S( Nu ( R R ( R R R+ ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR, ã s c C` s | j | } | j d } d } | d k r¥ | j d k r¥ t | r¥ | d j d k r¥ | d } | j | \ } } t j d | j | j f | _ n[ t j
j | d } t j
j | d } | j | \ } } t j d | j | _ | r| j d | n d S( Ni u u preu codeu %s
%s
u %s
(
R R< R R9 R R& R t AtomicStringR" t rstripR@ RH RB ( R R R- RF R+ t theRestt codet pre( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR. æ s
" ( R/ R0 R1 R, R. ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR à s R c B` s2 e Z e j d Z d Z d Z d Z RS( u (^|\n)[ ]{0,3}>[ ]?(.*)c C` s t | j j | S( N( t boolt REt search( R R R+ ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR, s c C` s | j d } | j j | } | r | | j } | j j | | g d j g | | j j d D] } | j | ^ qm } n | j | } | d k rÁ | j d k rÁ | } n t j
j | d } | j j j d | j j | | | j j j d S( Ni u
u
blockquote( R< RU RV t startR R? R! R t cleanR R R9 R R@ RH R7 R> RC RE ( R R R- R+ RL t beforeR% RF t quote( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR. s ; c C` sC | j j | } | j d k r( d S| r; | j d S| Sd S( u( Remove ``>`` from beginning of a line. u >u i N( RU RJ R RK ( R R% RL ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyRX s
( R/ R0 R3 R4 RU R, R. RX ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR s R c B` sJ e Z d Z d Z d Z d d g Z d Z d Z d Z d Z RS( u Process ordered list blocks. u olu 1u ulc C` s~ t t | j | t j d | j d | _ t j d | j d | _ t j d | j | j d d f | _ d S( Nu ^[ ]{0,%d}\d+\.[ ]+(.*)i u! ^[ ]{0,%d}((\d+\.)|[*+-])[ ]+(.*)u ^[ ]{%d,%d}((\d+\.)|[*+-])[ ]+.*i ( R2 R R R3 R4 R RU t CHILD_RER5 ( R R ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR 7 s c C` s t | j j | S( N( RT RU RJ ( R R R+ ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR, B s c C` sU | j | j d } | j | } | d k r]| j | j k r]| } | d j r t j j d } | d j | _ d | d _ | d j
d | n | j | d } | d k rý | j rý t j j | d d } | j j
| _ d | _ n t j j | d } | j j j d | j d } | j j | | g | j j j nb | j d
k ru| } nJ t j j | | j } | j j j r¿| j d k r¿| j | j d
<n | j j j d xl | D]d }
|
j d | j r| j j | d |
g qÙt j j | d } | j j | |
g qÙW| j j j d S( Ni iÿÿÿÿu pu u liu looselistu olu ulu 1u startu listu ( u olu ul( t get_itemsR< R R R9 t SIBLING_TAGSR" R R@ RA RB t tailRH t lstripR R7 R> R? RE t TAGR t lazy_olt
STARTSWITHt attribR R ( R R R- t itemsRF t lstRG t lchRI t firstitemt item( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR. E s>
c C` s
g } x | j d D]ï } | j j | } | r | r} | j d k r} t j d } | j | j d j | _ n | j | j d q | j j | rí | d j
d | j rÝ d | d | f | d <q| j | q d | d | f | d <q W| S( u Break a block into list items. u
u olu (\d+)i i iÿÿÿÿu u %s
%s( R R[ RJ R` R3 R4 RK Rb R R5 R R ( R R+ Rd R% RL t
INTEGER_RE( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR\ s $ (
R/ R0 R1 R` Rb R] R R, R. R\ ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR + s ;R
c B` s e Z d Z d Z d Z RS( u Process unordered list blocks. u ulc C` s7 t t | j | t j d | j d | _ d S( Nu ^[ ]{0,%d}[*+-][ ]+(.*)i ( R2 R
R R3 R4 R RU ( R R ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR s ( R/ R0 R1 R` R ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR
s R c B` s/ e Z d Z e j d Z d Z d Z RS( u Process Hash Headers. u. (^|\n)(?P<level>#{1,6})(?P<header>.*?)#*(\n|$)c C` s t | j j | S( N( RT RU RV ( R R R+ ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR, ¬ s c C` s× | j d } | j j | } | r | | j } | | j } | rf | j j | | g n t j j | d t
| j d } | j d j | _
| rÓ | j d | qÓ n t j d | d S( Ni u h%du levelu headeru We've got a problem header: %r( R< RU RV RW t endR R? R R@ RH R RK R R" RB t loggert warn( R R R- R+ RL RY t aftert h( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR. ¯ s (( R/ R0 R1 R3 R4 RU R, R. ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR ¦ s R
c B` s5 e Z d Z e j d e j Z d Z d Z RS( u Process Setext-style Headers. u ^.*?\n[=-]+[ ]*(\n|$)c C` s t | j j | S( N( RT RU RJ ( R R R+ ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR, Ë s c C` s | j d j d } | d j d r4 d } n d } t j j | d | } | d j | _ t | d k r | j d d j
| d n d S( Ni u
i u =i u h%d( R< R R R R@ RH R R" R RB R! ( R R R- R$ R( Rn ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR. Î s ( R/ R0 R1 R3 R4 t MULTILINERU R, R. ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR
Å s R c B` s; e Z d Z d Z e j e e j Z d Z d Z RS( u Process Horizontal Rules. uB ^[ ]{0,3}((-+[ ]{0,2}){3,}|(_+[ ]{0,2}){3,}|(\*+[ ]{0,2}){3,})[ ]*c C` sW | j j | } | rS | j t | k sF | | j d k rS | | _ t St S( Nu
( t SEARCH_RERV Rj R RJ t Truet False( R R R+ RL ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR, ã s
4 c C` s | j d } | | j j j d } | rJ | j j | | g n t j j | d | | j j j
d } | r | j d | n d S( Ni u
u hr( R< RJ RW RP R R? R R@ RH Rj R_ RB ( R R R- R+ t prelinest postlines( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR. î s (
R/ R0 R1 RU R3 R4 Ro Rp R, R. ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR Ü s
R c B` s e Z d Z d Z d Z RS( u< Process blocks that are empty or start with an empty line. c C` s | p | j d S( Nu
( R ( R R R+ ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR, s c C` s¾ | j d } d } | rG d } | d } | rG | j d | qG n | j | } | d k rº | j d k rº t | rº | d j d k rº t j d | d j | f | d _ n d S( Ni u
u
i u preu codeu %s%s( R< RB R R R9 R R RO R" ( R R R- R+ t fillerRQ RF ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR. s
( R/ R0 R1 R, R. ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR þ s R c B` s e Z d Z d Z d Z RS( u Process Paragraph blocks. c C` s t S( N( Rq ( R R R+ ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR, s c C` sÜ | j d } | j rØ | j j j d r± | j | } | d k r} | j rm d | j | f | _ q® d | | _ qÕ | j r d | j | f | _ qÕ | j | _ qØ t
j j | d } | j | _ n d S( Ni u listu %s
%su
%su p(
R< R R R7 R8 R R R^ R" R_ R R@ RH ( R R R- R+ RF RG ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR. s ( R/ R0 R1 R, R. ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyR s ( R1 t
__future__R R R t loggingR3 t R t blockparserR t getLoggerRk R t objectR R R R R R
R R
R R R ( ( ( s6 build/lib.linux-x86_64-2.7/markdown/blockprocessors.pyt <module> s( X_!*p "