BlockParsers

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

object Ruler extends MarkdownBlock

Represents a horizontal ruler

def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

implicit def accept(e: Elem): Parser[Elem]

def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

def anyLine: Parser[MarkdownLine]

Parses any line.

def apply(in: MarkdownLineReader): String

Parses the given input as a markdown document and returns the string result

def apply[T](p: Parser[T], list: List[MarkdownLine]): T

Generic apply method to test a single parser

def apply[T](p: Parser[T], in: MarkdownLineReader): T

Generic apply method to run one of our pasers on the given input.

def applyBlocks(in: MarkdownLineReader): List[MarkdownBlock]

parses all blocks from the given reader

final def asInstanceOf[T0]: T0

def atxHeader: Parser[Header]

def blockquote: Parser[Blockquote]

Parses a quoted block.

def blockquoteFragment: Parser[List[MarkdownLine]]

Parses a blockquote fragment: a block starting with a blockquote line followed by more blockquote or paragraph lines, ends optionally with empty lines

def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

def clone(): AnyRef

def codeBlock: Parser[CodeBlock]

parses a code block

def commit[T](p: ⇒ Parser[T]): Parser[T]

def deco(): Decorator

Used to define the output format of parsed blocks and whether verbatim xml blocks are allowed.

def elem(e: Elem): Parser[Elem]

def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

def emptyLine: Parser[EmptyLine]

def emptyLines: Parser[List[MarkdownLine]]

accepts one or more empty lines

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def err(msg: String): Parser[Nothing]

def failure(msg: String): Parser[Nothing]

def fastBlock: Parser[MarkdownBlock]

speed up block processing by looking ahead

def fencedCodeBlock: Parser[FencedCodeBlock]

Parses a fenced code block: a line starting a fenced code block with "", followed by any lines that do not stop it, optionally followed by the ending line. Optionally parsing the stopping line causes the code block to extend to the end of the document. (This is the github behavior, where omitting the line closing the code block causes the block to extend to the end of the document as well)

def finalize(): Unit

final def getClass(): Class[_]

def guard[T](p: ⇒ Parser[T]): Parser[T]

def hashCode(): Int

def indent(level: Int): String

returns the current indentation string repeated the given number of levels

def innerBlock: Parser[MarkdownBlock]

parses inner blocks (everything excluding xml)

final def isInstanceOf[T0]: Boolean

def itemContinuation: Parser[List[MarkdownLine]]

The continuation of a list item: A line indented by four spaces or a tab (a continuation line), followed by more continuation or paragraph lines followed by empty lines

def itemLines: Parser[List[MarkdownLine]]

parses a list of lines that may make up the body of a list item

def line[T](c: Class[T]): Parser[T]

Parses a line of the given type T

def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

def lookup: Parser[Map[String, LinkDefinition]]

returns the current link lookup from the reader always succeeds, never consumes input

def markdown: Parser[List[MarkdownBlock]]

a markdown parser

def mkList[T]: (~[T, List[T]]) ⇒ List[T]

final def ne(arg0: AnyRef): Boolean

def not[T](p: ⇒ Parser[T]): Parser[Unit]

def notLine[T](c: Class[T]): Parser[MarkdownLine]

Parses a line of any type *but* T

final def notify(): Unit

final def notifyAll(): Unit

def oItem: Parser[ListItem]

parses an item in a sorted list

def oList: Parser[OList]

parses an ordered list

def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

def optEmptyLines: Parser[List[MarkdownLine]]

accepts zero or more empty lines

def outerBlock: Parser[MarkdownBlock]

parses first level blocks (all blocks, including xml)

def paragraph: Parser[Paragraph]

a consecutive block of paragraph lines returns the content of the matched block wrapped in

def phrase[T](p: Parser[T]): Parser[T]

def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

def ruler: Parser[MarkdownBlock]

parses a horizontal ruler

def setExtHeader: Parser[Header]

def success[T](v: T): Parser[T]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def uItem: Parser[ListItem]

parses an item in an unsorted list

def uList: Parser[UList]

parses an unordered list

def verbatimXml: Parser[VerbatimXml]

parses a verbatim xml block

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def lastNoSuccess: NoSuccess

def lastNoSuccess_=(x: NoSuccess): Unit