StandardDirectiveParsers

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: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

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

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]]

val addrSpec: Parser[String]

Parses a single email address as defined in RFC 6068.

addr-spec = local-part "@" domain

val alpha: TextParser

Parses letters according to RFC 2234.

ALPHA =  %x41-5A / %x61-7A ; A-Z / a-z

val any: TextParser

Consumes any kind of input, always succeeds.

def anyBut(chars: Char*): TextParser

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

def anyIn(ranges: Traversable[Char]*): TextParser

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

def anyOf(chars: Char*): TextParser

Consumes any number of consecutive occurrences of the specified characters.

def anyUntil(until: ⇒ Parser[Any]): TextParser

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

def anyUntil(chars: Char*): TextParser

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

def anyWhile(p: (Char) ⇒ Boolean): TextParser

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

final def asInstanceOf[T0]: T0

val atStart: Parser[Parser[Unit]]

Succeeds at the start of the input.

val authority: Parser[String]

Parses the authority part of a URI as defined in RFC 3986.

authority = [ userinfo "@" ] host [ ":" port ]

val blankLine: Parser[String]

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

val blankLines: 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: Parser[Any], linePrefix: ⇒ Parser[Any], nextBlockPrefix: ⇒ Parser[Any]): Parser[List[String]]

Parses a full block based on the specified helper parsers.

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

Retrieves the block directive with the specified name.

def blockDirective: Parser[Block]

Parses a block-level directive.

def blockList(parser: ⇒ Parser[Block]): Parser[List[Block]]

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

def blockQuote: Parser[Block]

Parses a block quote with an optional attribution.

def bulletList: Parser[BulletList]

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

def captionAndLegend(p: BlockParsers)(input: String): Either[String, (Seq[Span], List[Block])]

Parses a caption (a single paragraph) and a legend (one or more blocks), both being optional.

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]

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

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

def citation: Parser[Citation]

Parses a citation.

lazy val citationRef: Parser[CitationReference]

Parses a citation reference.

def clone(): AnyRef

def comment: Parser[Comment]

Parses a comment.

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

def config(path: Path): Parser[Either[InvalidBlock, Config]]

def defaultTextRole: String

The default text role to use when no role is specified in an interpreted text element.

def definitionList: Parser[Block]

Parses a definition list.

val digit: TextParser

Parses digits according to RFC 2234.

DIGIT =  %x30-39; 0-9

def doctest: Parser[Block]

Parses a doctest block.

val domain: Parser[String]

Parses the domain portion of an email address as defined in RFC 6068.

domain       = dot-atom-text / "[" *dtext-no-obs "]"
dtext-no-obs = %d33-90 / ; Printable US-ASCII
               %d94-126  ; characters not including
                         ; "[", "]", or "\"

val dotAtomText: Parser[String]

Parses a dot-atom-text sequence as defined in RFC 5322.

dot-atom-text   =   1*atext *("." 1*atext)

atext           =   ALPHA / DIGIT /    ; Printable US-ASCII
                 "!" / "#" /        ;  characters not including
                 "$" / "%" /        ;  specials.  Used for atoms.
                 "&" / "'" /
                 "*" / "+" /
                 "-" / "/" /
                 "=" / "?" /
                 "^" / "_" /
                 "`" / "{" /
                 "|" / "}" /
                 "~"

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

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

lazy val em: Parser[Emphasized]

Parses a span of emphasized text.

lazy val email: Parser[(String, String, String)]

Parses a standalone email address (with no surrounding markup).

val emailAddress: Parser[String]

Parses a mailto URI without the scheme part as defined in RFC 6068.

val emailURI: Parser[String]

Parses a full mailto URI as defined in RFC 6068.

mailtoURI = "mailto:" [ to ] [ hfields ]

def enumList: Parser[EnumList]

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

def eof: Parser[String]

Succeeds at the end of the input.

def eol: 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): Parser[Nothing]

lazy val escapedChar: Parser[String]

Parses an escaped character.

def escapedText(p: TextParser): Parser[String]

Adds support for escape sequences to the specified text parser.

def escapedUntil(char: Char): Parser[String]

Parses a span of text until the specified character is seen (unless it is escaped), while also processing escaped characters, but no other nested spans.

def explicitBlockItem: Parser[Block]

Parses all types of explicit block items.

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

def fieldList: Parser[Block]

Parses a field list.

def finalize(): Unit

def flatten(result: Any): String

Flattens the result from various combinators, including the repX variants and ~ into a single string.

def footnote: Parser[FootnoteDefinition]

Parses a footnote.

val footnoteLabel: Parser[Product with Serializable with FootnoteLabel]

Parses any of the four supported types of footnote labels.

lazy val footnoteRef: Parser[FootnoteReference]

Parses a footnote reference.

val fragment: Parser[String]

Parses the fragment part of a URI as defined in RFC 3986.

fragment = *( pchar / "/" / "?" )

final def getClass(): Class[_]

def gridTable: Parser[Table]

Parses a grid table.

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

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

def hashCode(): Int

def headerWithOverline: Parser[Block]

Parses a section header with both overline and underline.

def headerWithUnderline: Parser[Block]

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

val hexdig: TextParser

Parses a hexadecimal value according to RFC 2234.

HEXDIG = DIGIT / "A" / "B" / "C" / "D" / "E" / "F"

val hfields: Parser[String]

Parses header fields of an email address as defined in RFC 6068.

hfields      = "?" hfield *( "&" hfield )
hfield       = hfname "=" hfvalue
hfname       = *qchar
hfvalue      = *qchar

qchar        = unreserved / pct-encoded / some-delims
some-delims  = "!" / "$" / "'" / "(" / ")" / "*"
             / "+" / "," / ";" / ":" / "@"

val hierPart: Parser[String]

Parses the hierarchical part of a URI with an authority component as defined in RFC 3986, but only the variant including an authority component.

hier-part     = "//" authority path-abempty
/ path-absolute ; excluded
/ path-rootless ; excluded
/ path-empty    ; excluded

val host: Parser[String]

Parses a host as defined in RFC 3986.

host = IP-literal / IPv4address / reg-name

val httpUri: Parser[String]

Parses a full HTTP URI including the scheme part and an authority component as defined in RFC 3986.

val httpUriNoScheme: Parser[String]

Parses an HTTP or HTTPS URI with an authority component, but without the scheme part (therefore starting with "//") as defined in RFC 3986.

URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]

val httpsUri: Parser[String]

Parses a full HTTPS URI including the scheme part and an authority component as defined in RFC 3986.

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

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

def inline[Elem, To](text: ⇒ TextParser, nested: ⇒ Map[Char, Parser[Elem]], resultBuilder: ⇒ ResultBuilder[Elem, To]): Parser[To]

Generic base parser that parses inline elements based on the specified helper parsers.

lazy val inlineLiteral: Parser[Literal]

Parses an inline literal element.

val internalTarget: Parser[Text]

Parses an inline internal link target.

lazy val interpretedTextWithRolePrefix: Parser[InterpretedText]

Parses an interpreted text element with the role name as a prefix.

lazy val interpretedTextWithRoleSuffix: Parser[InterpretedText]

Parses an interpreted text element with the role name as a suffix.

val ipLiteral: Parser[String]

Parses an ip literal as defined in RFC 3986.

IP-literal = "[" ( IPv6address / IPvFuture  ) "]"

val ipv4address: Parser[String]

Parses an IPv4 address as defined in RFC 3986.

IPv4address   = dec-octet "." dec-octet "." dec-octet "." dec-octet

dec-octet     = DIGIT                 ; 0-9
              / %x31-39 DIGIT         ; 10-99
              / "1" 2DIGIT            ; 100-199
              / "2" %x30-34 DIGIT     ; 200-249
              / "25" %x30-35          ; 250-255

val ipv6address: Parser[~[Product, Serializable]]

Parses an IPv6 address as defined in RFC 3986.

IPv6address  =                            6( h16 ":" ) ls32
             /                       "::" 5( h16 ":" ) ls32
             / [               h16 ] "::" 4( h16 ":" ) ls32
             / [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32
             / [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32
             / [ *3( h16 ":" ) h16 ] "::"    h16 ":"   ls32
             / [ *4( h16 ":" ) h16 ] "::"              ls32
             / [ *5( h16 ":" ) h16 ] "::"              h16
             / [ *6( h16 ":" ) h16 ] "::"

h16          = 1*4HEXDIG

ls32         = ( h16 ":" h16 ) / IPv4address

val ipvFuture: Parser[~[~[~[Elem, String], Elem], List[Any]]]

Parses a future IP address as defined in RFC 3986.

IPvFuture = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )

final def isInstanceOf[T0]: Boolean

def lineBlock: Parser[Block]

Parses a block of lines with line breaks preserved.

def linkTarget: Parser[Block with Span with Serializable]

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

implicit def literal(s: String): Parser[String]

def literalBlock: Parser[Block]

Parses a literal block, either quoted or indented.

val localPart: Parser[String]

Parses the local part of an email address (before the @), with one deviation from RFC 6068: a quoted string is not allowed.

local-part = dot-atom-text / quoted-string ; quoted-string omitted

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

def lookBehind[T](offset: Int, parser: ⇒ Parser[T]): Parser[T]

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

def markupEnd(end: Parser[String]): Parser[String]

Parses the end of an inline element according to reStructuredText markup recognition rules.

def markupStart(end: Parser[String]): Parser[Any]

Parses the start of an inline element without specific start markup according to reStructuredText markup recognition rules.

def markupStart(start: Parser[Any], end: Parser[String]): Parser[Any]

Parses the markup at the start of an inline element according to reStructuredText markup recognition rules.

val maxNestLevel: Int

The maximum level of block nesting.

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

final def ne(arg0: AnyRef): Boolean

def nestLevel(reader: Input): Int

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

final lazy val nestedBlock: Parser[Block]

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

def nonRecursiveBlock: Parser[Block]

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

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

final def notify(): Unit

final def notifyAll(): Unit

def opt[T](p: ⇒ Parser[T]): 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: Parser[Block]

Parses an option list.

val pChar: Parser[Serializable]

Parses one path character as defined in RFC 3986.

pchar = unreserved / pct-encoded / sub-delims / ":" / "@"

def paragraph: Parser[Paragraph]

Parses a single paragraph.

def parse[T](p: Parser[T], in: Reader): ParseResult[T]

def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

def parseAll[T](p: Parser[T], in: Reader[Char]): 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: 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 parseInline(source: String, spanParsers: Map[Char, Parser[Span]]): List[Span]

Fully parses the input string and produces a list of spans.

def parseInline(source: String): List[Span]

Fully parses the input string and produces a list of spans, using the default span parsers returned by the spanParsers method.

def parseMarkup[T](parser: Parser[T], reader: Reader[Char]): T

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

def parseMarkup[T](parser: Parser[T], source: String): T

Fully parses the specified input string and returns the result.

def parseNestedBlocks(block: 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.

val path: Parser[String]

Parses the path of a URI as defined in RFC 3986, but only the path variant following an authority component.

path-abempty  = *( "/" segment )

segment       = *pchar

val pctEncoded: Parser[~[Elem, String]]

Parses a percent-encoded character as defined in RFC 3986.

pct-encoded = "%" HEXDIG HEXDIG

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

lazy val phraseLinkRef: Parser[SpanContainer[_ >: SpanSequence with ExternalLink with LinkReference <: SpanContainer[_ >: SpanSequence with ExternalLink with LinkReference <: SpanContainer[_ >: SpanSequence with ExternalLink with LinkReference <: Span with Container[Seq[Span]] with Serializable] with Span with Serializable] with Span with Serializable] with Span with Serializable]

Parses a phrase link reference (enclosed in back ticks).

val phraseRef: Parser[String]

Parses a phrase reference name enclosed in back ticks.

val port: TextParser

Parses a port as defined in RFC 3986, except for requiring at least one digit; instead the port is defined as optional in a higher level combinator.

port = *DIGIT

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

def prepareBlockParsers(nested: Boolean): List[Parser[Block]]

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

def prepareSpanParsers: Map[Char, Parser[Span]]

A mapping of the start character of an inline element to the corresponding parser.

val punctuationChar: TextParser

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

val query: Parser[String]

Parses the query part of a URI as defined in RFC 3986.

query = *( pchar / "/" / "?" )

def quotedBlock(p: BlockParsers, style: String)(input: String): Serializable with Product with Either[String, QuotedBlock]

Parses a quoted block with nested blocks.

val refName: Parser[ReferenceName]

Parses a reference name, either a simple or a phrase reference name.

val regName: Parser[String]

Parses a server name as defined in RFC 3986.

reg-name = *( unreserved / pct-encoded / sub-delims )

implicit def regex(r: Regex): Parser[String]

def rep[T](first: ⇒ Parser[T], next: (T) ⇒ Parser[T]): 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: ⇒ 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 repMax[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

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

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

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

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

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

def restOfLine: 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: Parser[Block]

Parses a role directive.

def root: Parser[RootElement]

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

lazy val shortAnonymousLinkTarget: Parser[ExternalLinkDefinition]

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

lazy val simpleLinkRef: Parser[Span]

Parses a simple link reference.

val simpleRefName: Parser[String]

Parses a simple reference name that only allows alphanumerical characters and the punctuation characters -, _, ., :, +.

def simpleTable: Parser[Table]

Parses a simple table.

def skipWhitespace: Boolean

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

Retrieves the span directive with the specified name.

final lazy val spanParsers: Map[Char, Parser[Span]]

The mapping of markup start characters to their corresponding span parsers.

def spans(parser: ⇒ TextParser, spanParsers: ⇒ Map[Char, Parser[Span]]): Parser[List[Span]]

Parses a list of spans based on the specified helper parsers.

def standardSpans(p: InlineParsers)(input: String): Either[String, Seq[Span]]

Parses all standard inline markup supported by reStructuredText.

lazy val strong: Parser[Strong]

Parses a span of text with strong emphasis.

val subDelims: TextParser

Parses a single sub-delimiter as defined in RFC 3986.

sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
/ "*" / "+" / "," / ";" / "="

def substitutionDefinition: Parser[Block with Serializable]

Parses a substitution definition.

lazy val substitutionRef: Parser[Reference with Serializable]

Parses a substitution reference.

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

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

def table(p: BlockParsers)(input: String): Either[String, Table]

Parses one of the two table types supported by reStructuredText.

def target(input: String): Either[String, Span]

Parses a target which might be a simple reference, a phrase reference or an uri.

def text(parser: ⇒ TextParser, nested: ⇒ Map[Char, Parser[String]]): Parser[String]

Parses text based on the specified helper parsers.

val textLine: Parser[String]

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

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

Retrieves the text role with the specified name.

def textRoleElements: List[CustomizedTextRole]

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

val to: Parser[String]

Parses a sequence of email addresses as defined in RFC 6068.

to = addr-spec *("," addr-spec )

implicit def toParserOps[A](parser: Parser[A]): ParserOps[A]

def toString(): String

final lazy val topLevelBlock: Parser[Block]

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

val transition: Parser[Rule]

Parses a transition (rule).

def unicode(input: String): Either[String, String]

Parses unicode values in various notations intertwined with normal text.

val unreserved: Parser[String]

Parses a single unreserved character as defined in RFC 3986.

sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
/ "*" / "+" / "," / ";" / "="

lazy val uri: Parser[(String, String, String)]

Parses a standalone HTTP or HTTPS hyperlink (with no surrounding markup).

val userInfo: Parser[String]

Parses the user info portion of a URI as defined in RFC 3986.

userinfo = *( unreserved / pct-encoded / sub-delims / ":" )

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: ⇒ Parser[T], msg: String): Parser[T]

Overrides the failure message to the specified parser.

def withNestLevel[T](p: ⇒ Parser[T]): 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: TextParser

Parses horizontal whitespace (space and tab).

def lastNoSuccess: NoSuccess

def lastNoSuccess_=(x: NoSuccess): Unit