BlockParsers

abstract def blockDirective(name: String): Option[DirectivePart[Block]]

Retrieves the block directive with the specified name.

abstract def spanDirective(name: String): Option[DirectivePart[Span]]

Retrieves the span directive with the specified name.

abstract def textRole(name: String): Option[RoleDirectivePart[(String) ⇒ Span]]

Retrieves the text role with the specified name.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object NoSuccess

def OnceParser[T](f: ((BlockParsers.this)#Input) ⇒ (BlockParsers.this)#ParseResult[T]): (BlockParsers.this)#Parser[T] with (BlockParsers.this)#OnceParser[T]

def Parser[T](f: ((BlockParsers.this)#Input) ⇒ (BlockParsers.this)#ParseResult[T]): (BlockParsers.this)#Parser[T]

def accept[U](expected: String, f: PartialFunction[(BlockParsers.this)#Elem, U]): (BlockParsers.this)#Parser[U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[(BlockParsers.this)#Elem]): (BlockParsers.this)#Parser[List[(BlockParsers.this)#Elem]]

implicit def accept(e: (BlockParsers.this)#Elem): (BlockParsers.this)#Parser[(BlockParsers.this)#Elem]

def acceptIf(p: ((BlockParsers.this)#Elem) ⇒ Boolean)(err: ((BlockParsers.this)#Elem) ⇒ String): (BlockParsers.this)#Parser[(BlockParsers.this)#Elem]

def acceptMatch[U](expected: String, f: PartialFunction[(BlockParsers.this)#Elem, U]): (BlockParsers.this)#Parser[U]

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

val any: (BlockParsers.this)#TextParser

Consumes any kind of input, always succeeds.

def anyBut(chars: Char*): (BlockParsers.this)#TextParser

Consumes any number of consecutive characters that are not one of the specified characters.

def anyIn(ranges: Traversable[Char]*): (BlockParsers.this)#TextParser

Consumes any number of consecutive characters that are in one of the specified character ranges.

def anyOf(chars: Char*): (BlockParsers.this)#TextParser

Consumes any number of consecutive occurrences of the specified characters.

def anyUntil(until: ⇒ (BlockParsers.this)#Parser[Any]): (BlockParsers.this)#TextParser

Consumes any number of characters for which the specified parser fails on the corresponding offset.

def anyUntil(chars: Char*): (BlockParsers.this)#TextParser

Consumes any number of consecutive characters that are not one of the specified characters.

def anyWhile(p: (Char) ⇒ Boolean): (BlockParsers.this)#TextParser

Consumes any number of consecutive characters which satisfy the specified predicate.

final def asInstanceOf[T0]: T0

val atStart: (BlockParsers.this)#Parser[(BlockParsers.this)#Parser[Unit]]

Succeeds at the start of the input.

val blankLine: (BlockParsers.this)#Parser[String]

Parses a blank line from the current input offset (which may not be at the start of the line).

val blankLines: (BlockParsers.this)#Parser[List[String]]

Parses one or more blanklines, producing a list of empty strings corresponding to the number of blank lines consumed.

def block(firstLinePrefix: (BlockParsers.this)#Parser[Any], linePrefix: ⇒ (BlockParsers.this)#Parser[Any], nextBlockPrefix: ⇒ (BlockParsers.this)#Parser[Any]): (BlockParsers.this)#Parser[List[String]]

Parses a full block based on the specified helper parsers.

def blockDirective: (BlockParsers.this)#Parser[Block]

Parses a block-level directive.

def blockList(parser: ⇒ (BlockParsers.this)#Parser[Block]): (BlockParsers.this)#Parser[List[Block]]

Builds a parser for a list of blocks based on the parser for a single block.

def blockQuote: (BlockParsers.this)#Parser[Block]

Parses a block quote with an optional attribution.

def bulletList: (BlockParsers.this)#Parser[BulletList]

Parses a bullet list with any of the supported bullet characters.

def chainl1[T, U](first: ⇒ (BlockParsers.this)#Parser[T], p: ⇒ (BlockParsers.this)#Parser[U], q: ⇒ (BlockParsers.this)#Parser[(T, U) ⇒ T]): (BlockParsers.this)#Parser[T]

def chainl1[T](p: ⇒ (BlockParsers.this)#Parser[T], q: ⇒ (BlockParsers.this)#Parser[(T, T) ⇒ T]): (BlockParsers.this)#Parser[T]

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

implicit def charToTraversalble(char: Char): Traversable[Char]

Implicit conversion that allows to pass a single character to the range-based anyIn parser.

def citation: (BlockParsers.this)#Parser[Citation]

Parses a citation.

def clone(): AnyRef

def comment: (BlockParsers.this)#Parser[Comment]

Parses a comment.

def commit[T](p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[T]

def config(path: Path): (BlockParsers.this)#Parser[Either[InvalidBlock, Config]]

def definitionList: (BlockParsers.this)#Parser[Block]

Parses a definition list.

def doctest: (BlockParsers.this)#Parser[Block]

Parses a doctest block.

def elem(e: (BlockParsers.this)#Elem): (BlockParsers.this)#Parser[(BlockParsers.this)#Elem]

def elem(kind: String, p: ((BlockParsers.this)#Elem) ⇒ Boolean): (BlockParsers.this)#Parser[(BlockParsers.this)#Elem]

def enumList: (BlockParsers.this)#Parser[EnumList]

Parses an enumerated list in any of the supported combinations of enumeration style and formatting.

def eof: (BlockParsers.this)#Parser[String]

Succeeds at the end of the input.

def eol: (BlockParsers.this)#Parser[String]

Succeeds at the end of a line, including the end of the input.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def err(msg: String): (BlockParsers.this)#Parser[Nothing]

def explicitBlockItem: (BlockParsers.this)#Parser[Block]

Parses all types of explicit block items.

def failure(msg: String): (BlockParsers.this)#Parser[Nothing]

def fieldList: (BlockParsers.this)#Parser[Block]

Parses a field list.

def finalize(): Unit

def footnote: (BlockParsers.this)#Parser[FootnoteDefinition]

Parses a footnote.

final def getClass(): Class[_]

def gridTable: (BlockParsers.this)#Parser[Table]

Parses a grid table.

def guard[T](p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[T]

def handleWhiteSpace(source: CharSequence, offset: Int): Int

def hashCode(): Int

def headerWithOverline: (BlockParsers.this)#Parser[Block]

Parses a section header with both overline and underline.

def headerWithUnderline: (BlockParsers.this)#Parser[Block]

Parses a section header with an underline, but no overline.

def indentedBlock(minIndent: Int = 1, linePredicate: ⇒ (BlockParsers.this)#Parser[Any] = success(), endsOnBlankLine: Boolean = false, firstLineIndented: Boolean = false, maxIndent: Int = Int.MaxValue): (BlockParsers.this)#Parser[(BlockParsers.this)#IndentedBlock]

Parses a full block based on the specified helper parsers, expecting an indentation for all lines except the first.

final def isInstanceOf[T0]: Boolean

def lineBlock: (BlockParsers.this)#Parser[Block]

Parses a block of lines with line breaks preserved.

def linkTarget: (BlockParsers.this)#Parser[Block with Span with Serializable]

Parses a link definition, either an internal, external or indirect link.

implicit def literal(s: String): (BlockParsers.this)#Parser[String]

def literalBlock: (BlockParsers.this)#Parser[Block]

Parses a literal block, either quoted or indented.

def log[T](p: ⇒ (BlockParsers.this)#Parser[T])(name: String): (BlockParsers.this)#Parser[T]

def lookBehind[T](offset: Int, parser: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[T]

Applies the specified parser at the specified offset behind the current position.

val maxNestLevel: Int

The maximum level of block nesting.

def mkList[T]: ((BlockParsers.this)#~[T, List[T]]) ⇒ List[T]

final def ne(arg0: AnyRef): Boolean

def nestLevel(reader: (BlockParsers.this)#Input): Int

Returns the current nest level from the specified input or 0 if it cannot be determined.

final lazy val nestedBlock: (BlockParsers.this)#Parser[Block]

Parses any kind of nested block supported by a concrete markup language.

def nonRecursiveBlock: (BlockParsers.this)#Parser[Block]

Parses reStructuredText blocks, except for blocks that allow nesting of blocks.

def not[T](p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[Unit]

final def notify(): Unit

final def notifyAll(): Unit

def opt[T](p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[Option[T]]

def optimizedCharLookup(chars: Char*): (Char) ⇒ Boolean

Returns an optimized, Array-based lookup function for the specified characters.

def optimizedRangeLookup(ranges: Traversable[Char]*): (Char) ⇒ Boolean

Returns an optimized, Array-based lookup function for the specified ranges of characters.

def optionList: (BlockParsers.this)#Parser[Block]

Parses an option list.

def paragraph: (BlockParsers.this)#Parser[Paragraph]

Parses a single paragraph.

def parse[T](p: (BlockParsers.this)#Parser[T], in: Reader): (BlockParsers.this)#ParseResult[T]

def parse[T](p: (BlockParsers.this)#Parser[T], in: CharSequence): (BlockParsers.this)#ParseResult[T]

def parse[T](p: (BlockParsers.this)#Parser[T], in: Reader[Char]): (BlockParsers.this)#ParseResult[T]

def parseAll[T](p: (BlockParsers.this)#Parser[T], in: CharSequence): (BlockParsers.this)#ParseResult[T]

def parseAll[T](p: (BlockParsers.this)#Parser[T], in: Reader): (BlockParsers.this)#ParseResult[T]

def parseAll[T](p: (BlockParsers.this)#Parser[T], in: Reader[Char]): (BlockParsers.this)#ParseResult[T]

def parseConfigAndRoot(reader: Reader[Char], path: Path): (Config, RootElement)

Fully parses the input from the specified reader and returns the configuration and root element.

def parseDirectivePart[T](parser: (BlockParsers.this)#Parser[T], source: String): Either[String, T]

Utility method to be used by custom parsers for directive argument or body.

def parseDocument(reader: Reader[Char], path: Path): Document

Fully parses the input from the specified reader and returns the document tree.

def parseMarkup[T](parser: (BlockParsers.this)#Parser[T], reader: Reader[Char]): T

Fully parses the input from the specified reader and returns the result.

def parseMarkup[T](parser: (BlockParsers.this)#Parser[T], source: String): T

Fully parses the specified input string and returns the result.

def parseNestedBlocks(block: (BlockParsers.this)#IndentedBlock): List[Block]

Parses all nested blocks inside the specified indented block.

def parseNestedBlocks(input: String, nestLevel: Int): List[Block]

Parses all nested blocks for the specified input and nest level.

def parseNestedBlocks(lines: List[String], nestLevel: Int): List[Block]

Parses all nested blocks for the specified input and nest level.

def phrase[T](p: (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[T]

def positioned[T <: Positional](p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[T]

def prepareBlockParsers(nested: Boolean): List[(BlockParsers.this)#Parser[Block]]

Extension hook for assembling the block parsers for a particular markup format.

val punctuationChar: (BlockParsers.this)#TextParser

Parses punctuation characters as supported by transitions (rules) and overlines and underlines for header sections.

implicit def regex(r: Regex): (BlockParsers.this)#Parser[String]

def rep[T](first: ⇒ (BlockParsers.this)#Parser[T], next: (T) ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[List[T]]

A parser generator for repetitions where all subsequent parsers after the first depend on the result of the previous.

def rep[T](p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[List[T]]

def rep1[T](first: ⇒ (BlockParsers.this)#Parser[T], p0: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[List[T]]

def rep1[T](p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[List[T]]

def rep1sep[T](p: ⇒ (BlockParsers.this)#Parser[T], q: ⇒ (BlockParsers.this)#Parser[Any]): (BlockParsers.this)#Parser[List[T]]

def repMax[T](num: Int, p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[List[T]]

Uses the parser for at most the specified number of repetitions, always succeeds.

def repMin[T](num: Int, p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[List[T]]

Uses the parser for at least the specified number of repetitions or otherwise fails.

def repN[T](num: Int, p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[List[T]]

def repsep[T](p: ⇒ (BlockParsers.this)#Parser[T], q: ⇒ (BlockParsers.this)#Parser[Any]): (BlockParsers.this)#Parser[List[T]]

def restOfLine: (BlockParsers.this)#Parser[String]

Parses the rest of the line from the current input offset no matter whether it consist of whitespace only or some text.

def roleDirective: (BlockParsers.this)#Parser[Block]

Parses a role directive.

def root: (BlockParsers.this)#Parser[RootElement]

Parses a full document, delegating most of the work to the topLevelBlock parser.

lazy val shortAnonymousLinkTarget: (BlockParsers.this)#Parser[ExternalLinkDefinition]

Parses the short variant of an anonymous link definition (that starts with instead of .. :)

def simpleTable: (BlockParsers.this)#Parser[Table]

Parses a simple table.

def skipWhitespace: Boolean

def substitutionDefinition: (BlockParsers.this)#Parser[Block with Serializable]

Parses a substitution definition.

def success[T](v: T): (BlockParsers.this)#Parser[T]

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

val textLine: (BlockParsers.this)#Parser[String]

Parses a single text line from the current input offset (which may not be at the start of the line.

def textRoleElements: List[CustomizedTextRole]

All the base text roles supported by this parser not including any custom roles specified within document markup.

implicit def toParserOps[A](parser: (BlockParsers.this)#Parser[A]): (BlockParsers.this)#ParserOps[A]

def toString(): String

final lazy val topLevelBlock: (BlockParsers.this)#Parser[Block]

Parses any kind of top-level block supported by a concrete markup language.

val transition: (BlockParsers.this)#Parser[Rule]

Parses a transition (rule).

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val whiteSpace: Regex

def withFailureMessage[T](p: ⇒ (BlockParsers.this)#Parser[T], msg: String): (BlockParsers.this)#Parser[T]

Overrides the failure message to the specified parser.

def withNestLevel[T](p: ⇒ (BlockParsers.this)#Parser[T]): (BlockParsers.this)#Parser[(Int, T)]

Creates a new parser that produces a tuple containing the current nest level as well as the result from the specified parser.

def ws: (BlockParsers.this)#TextParser

Parses horizontal whitespace (space and tab).

def lastNoSuccess: (BlockParsers.this)#NoSuccess

def lastNoSuccess_=(x: (BlockParsers.this)#NoSuccess): Unit