Trait

laika.parse.rst.ext

StandardDirectiveParsers

Related Doc: package ext

Permalink

trait StandardDirectiveParsers extends BlockParsers with InlineParsers

Defines the custom argument and body parsers for the standard directives. Most of these delegate to the default block or inline parsers for reStructuredText, but often do only except one specific block type like Table or QuotedBlock whereas the default block parser usually accepts any of the blocks.

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. StandardDirectiveParsers
  2. InlineParsers
  3. URIParsers
  4. InlineParsers
  5. BlockParsers
  6. ExplicitBlockParsers
  7. TableParsers
  8. ListParsers
  9. BlockParsers
  10. MarkupParsers
  11. BaseParsers
  12. RegexParsers
  13. Parsers
  14. AnyRef
  15. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. class CellBuilder extends AnyRef

    Permalink
    Definition Classes
    TableParsers
  2. class CellBuilderRef extends AnyRef

    Permalink
    Definition Classes
    TableParsers
  3. class ColumnBuilder extends AnyRef

    Permalink
    Definition Classes
    TableParsers
  4. type Elem = Char

    Permalink
    Definition Classes
    RegexParsers → Parsers
  5. case class Error extends NoSuccess with Product with Serializable

    Permalink
    Definition Classes
    Parsers
  6. case class Failure extends NoSuccess with Product with Serializable

    Permalink
    Definition Classes
    Parsers
  7. case class IndentedBlock(nestLevel: Int, minIndent: Int, lines: List[String]) extends Product with Serializable

    Permalink
    Definition Classes
    BlockParsers
  8. type Input = Reader[Elem]

    Permalink
    Definition Classes
    Parsers
  9. class MalformedTableException extends RuntimeException

    Permalink
    Definition Classes
    TableParsers
  10. class MarkupParserException extends RuntimeException

    Permalink

    Exception thrown when parsing a text markup document or fragment fails.

    Exception thrown when parsing a text markup document or fragment fails. This can only happen due to a bug in this library, as the behaviour of the parser is to treat all unknown or malformed markup as regular text and always succeed. The result property holds the NoSuccess instance that caused the failure.

    Definition Classes
    MarkupParsers
  11. class NestedCharSequenceReader extends CharSequenceReader

    Permalink

    Reader implementation that keeps the current nest level in case of recursive parsing of block-level elements.

    Reader implementation that keeps the current nest level in case of recursive parsing of block-level elements.

    Definition Classes
    BlockParsers
  12. sealed abstract class NoSuccess extends ParseResult[Nothing]

    Permalink
    Definition Classes
    Parsers
  13. trait OnceParser[+T] extends Parser[T]

    Permalink
    Definition Classes
    Parsers
  14. sealed abstract class ParseResult[+T] extends AnyRef

    Permalink
    Definition Classes
    Parsers
  15. abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

    Permalink
    Definition Classes
    Parsers
  16. implicit class ParserOps[A] extends AnyRef

    Permalink

    Provides additional combinator methods to parsers via implicit conversion.

    Provides additional combinator methods to parsers via implicit conversion.

    Definition Classes
    BaseParsers
  17. case class ReferenceName(original: String) extends Product with Serializable

    Permalink

    Represent a reference name.

    Represent a reference name. When resolving references whitespace needs to be normalized and the name converted to lower case.

    Definition Classes
    InlineParsers
  18. trait ResultBuilder[Elem, +To] extends AnyRef

    Permalink

    Abstracts the internal process of building up the result of an inline parser.

    Abstracts the internal process of building up the result of an inline parser. Since some inline parser produce a tree of nested spans whereas others may only produce a text result, they often require the same logic in how they deal with nested constructs.

    Definition Classes
    InlineParsers
  19. case class Reverse(length: Int, target: Span, fallback: Span, options: Options = NoOpt) extends Element with Span with Product with Serializable

    Permalink
    Attributes
    protected
    Definition Classes
    InlineParsers
  20. class RowBuilder extends AnyRef

    Permalink
    Definition Classes
    TableParsers
  21. class SpanBuilder extends ResultBuilder[Span, List[Span]]

    Permalink

    ResultBuilder that produces a list of spans.

    ResultBuilder that produces a list of spans.

    Definition Classes
    InlineParsers
  22. case class Success[+T] extends ParseResult[T] with Product with Serializable

    Permalink
    Definition Classes
    Parsers
  23. class TableBuilder extends AnyRef

    Permalink
    Definition Classes
    TableParsers
  24. class TextBuilder extends ResultBuilder[String, String]

    Permalink

    ResultBuilder that produces a String.

    ResultBuilder that produces a String.

    Definition Classes
    InlineParsers
  25. class TextParser extends Parser[String]

    Permalink

    API for specifying further constraints on the parsers provided by this base trait.

    API for specifying further constraints on the parsers provided by this base trait.

    For reading 3 or more '*' or '+'characters for example the constraint could be specified as follows:

    anyOf('*','+') min 3
    Definition Classes
    MarkupParsers
  26. implicit class TryOps[A] extends AnyRef

    Permalink

    Provides additional methods to Try via implicit conversion.

    Provides additional methods to Try via implicit conversion.

    Definition Classes
    BaseParsers
  27. case class ~[+a, +b] extends Product with Serializable

    Permalink
    Definition Classes
    Parsers

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  4. object NoSuccess

    Permalink
    Definition Classes
    Parsers
  5. def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

    Permalink
    Definition Classes
    Parsers
  6. def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

    Permalink
    Definition Classes
    Parsers
  7. def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

    Permalink
    Definition Classes
    Parsers
  8. def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

    Permalink
    Definition Classes
    Parsers
  9. implicit def accept(e: Elem): Parser[Elem]

    Permalink
    Definition Classes
    Parsers
  10. def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

    Permalink
    Definition Classes
    Parsers
  11. def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

    Permalink
    Definition Classes
    Parsers
  12. def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

    Permalink
    Definition Classes
    Parsers
  13. val addrSpec: Parser[String]

    Permalink

    Parses a single email address as defined in RFC 6068.

    Parses a single email address as defined in RFC 6068.

    addr-spec = local-part "@" domain
    Definition Classes
    URIParsers
  14. val alpha: TextParser

    Permalink

    Parses letters according to RFC 2234.

    Parses letters according to RFC 2234.

    ALPHA =  %x41-5A / %x61-7A ; A-Z / a-z
    Definition Classes
    URIParsers
  15. val any: TextParser

    Permalink

    Consumes any kind of input, always succeeds.

    Consumes any kind of input, always succeeds. This parser would consume the entire input unless a max constraint is specified.

    Definition Classes
    MarkupParsers
  16. def anyBut(chars: Char*): TextParser

    Permalink

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

    Consumes any number of consecutive characters that are not one of the specified characters. Always succeeds unless a minimum number of required matches is specified.

    Definition Classes
    MarkupParsers
  17. def anyIn(ranges: Traversable[Char]*): TextParser

    Permalink

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

    Consumes any number of consecutive characters that are in one of the specified character ranges. Always succeeds unless a minimum number of required matches is specified.

    Definition Classes
    MarkupParsers
  18. def anyOf(chars: Char*): TextParser

    Permalink

    Consumes any number of consecutive occurrences of the specified characters.

    Consumes any number of consecutive occurrences of the specified characters. Always succeeds unless a minimum number of required matches is specified.

    Definition Classes
    MarkupParsers
  19. def anyUntil(until: ⇒ Parser[Any]): TextParser

    Permalink

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

    Consumes any number of characters for which the specified parser fails on the corresponding offset. This parser fails if the end of input is reached without the specified parser ever succeeding or if the parser causes an Error result instead of a plain Failure or Success. Further constraints like minimum or maximum number of required matching characters can be specified through the API of the returned TextParser instance.

    Definition Classes
    MarkupParsers
  20. def anyUntil(chars: Char*): TextParser

    Permalink

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

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

    This parser is identical to the anyBut parser except for two differences: this parser fails if it reaches the end of the input without seeing any of the specified characters and it also consumes this final character, without adding it to the result. This parser is usually used when a construct like a span enclosed between two characters needs to be parsed.

    Definition Classes
    MarkupParsers
  21. def anyWhile(p: (Char) ⇒ Boolean): TextParser

    Permalink

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

    Consumes any number of consecutive characters which satisfy the specified predicate. Always succeeds unless a minimum number of required matches is specified.

    Definition Classes
    MarkupParsers
  22. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  23. val atStart: Parser[Unit]

    Permalink

    Succeeds at the start of the input.

    Succeeds at the start of the input.

    Definition Classes
    MarkupParsers
  24. val authority: Parser[String]

    Permalink

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

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

    authority = [ userinfo "@" ] host [ ":" port ]
    Definition Classes
    URIParsers
  25. val blankLine: Parser[String]

    Permalink

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

    Parses a blank line from the current input offset (which may not be at the start of the line). Fails for lines that contain any non-whitespace character. Does always produce an empty string as the result, discarding any whitespace characters found in the line.

    Since it also succeeds at the end of the input it should never be used in the form of (blankLine *) or (blankLine +). Use the blankLines parser instead in these cases.

    Definition Classes
    BlockParsers
  26. val blankLines: Parser[List[String]]

    Permalink

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

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

    Definition Classes
    BlockParsers
  27. def block(firstLinePrefix: Parser[Any], linePrefix: ⇒ Parser[Any], nextBlockPrefix: ⇒ Parser[Any]): Parser[List[String]]

    Permalink

    Parses a full block based on the specified helper parsers.

    Parses a full block based on the specified helper parsers.

    firstLinePrefix

    parser that recognizes the start of the first line of this block

    linePrefix

    parser that recognizes the start of subsequent lines that still belong to the same block

    nextBlockPrefix

    parser that recognizes whether a line after one or more blank lines still belongs to the same block

    Definition Classes
    BlockParsers
  28. def blockDirective(name: String): Option[DirectivePart[Block]]

    Permalink

    Retrieves the block directive with the specified name.

    Retrieves the block directive with the specified name.

    See laika.parse.rst.Directives for details on how to implement directives.

    Definition Classes
    StandardDirectiveParsersExplicitBlockParsers
  29. def blockDirective: Parser[Block]

    Permalink

    Parses a block-level directive.

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

    Permalink

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

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

    Overridden to add the processing required for cases where a block has influence on the parsing or processing of the subsequent block.

    This includes checking each Paragraph for a double colon ending which turns the following block into a literal block as well as processing internal link targets and section headers.

    parser

    the parser for a single block element

    returns

    a parser for a list of blocks

    Definition Classes
    BlockParsersBlockParsers
  31. def blockQuote: Parser[Block]

    Permalink

    Parses a block quote with an optional attribution.

    Parses a block quote with an optional attribution.

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#block-quotes

    Definition Classes
    BlockParsers
  32. def bulletList: Parser[BulletList]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#bullet-lists.

    Definition Classes
    ListParsers
  33. def captionAndLegend(p: BlockParsers)(input: String): Either[String, (Seq[Span], Seq[Block])]

    Permalink

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

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

    p

    the standard block parsers including all registered directives for recursive use

    input

    the input to parse

    returns

    Right in case of parser success and Left in case of failure, to adjust to the Directive API

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

    Permalink
    Definition Classes
    Parsers
  35. def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

    Permalink
    Definition Classes
    Parsers
  36. def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

    Permalink
    Definition Classes
    Parsers
  37. implicit def charToTraversalble(char: Char): Traversable[Char]

    Permalink

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

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

    Definition Classes
    MarkupParsers
  38. def citation: Parser[Citation]

    Permalink

    Parses a citation.

  39. lazy val citationRef: Parser[CitationReference]

    Permalink

    Parses a citation reference.

  40. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  41. def comment: Parser[Comment]

    Permalink

    Parses a comment.

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

    Permalink
    Definition Classes
    Parsers
  43. def config(path: Path): Parser[Either[InvalidBlock, Config]]

    Permalink
    Definition Classes
    BlockParsers
  44. def defaultTextRole: String

    Permalink

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

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

    Definition Classes
    InlineParsers
  45. def definitionList: Parser[Block]

    Permalink

    Parses a definition list.

  46. val digit: TextParser

    Permalink

    Parses digits according to RFC 2234.

    Parses digits according to RFC 2234.

    DIGIT =  %x30-39; 0-9
    Definition Classes
    URIParsers
  47. def doctest: Parser[Block]

    Permalink

    Parses a doctest block.

    Parses a doctest block. This is a feature which is very specific to the world of Python where reStructuredText originates. Therefore the resulting DoctestBlock tree element is not part of the standard Laika tree model. When this block type is used the corresponding special renderers must be enabled (e.g. the ExtendedHTML renderer for HTML).

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#doctest-blocks

    Definition Classes
    BlockParsers
  48. val domain: Parser[String]

    Permalink

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

    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 "\"
    Definition Classes
    URIParsers
  49. val dotAtomText: Parser[String]

    Permalink

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

    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.
                      "&" / "'" /
                      "*" / "+" /
                      "-" / "/" /
                      "=" / "?" /
                      "^" / "_" /
                      "`" / "{" /
                      "|" / "}" /
                      "~"
    Definition Classes
    URIParsers
  50. def elem(e: Elem): Parser[Elem]

    Permalink
    Definition Classes
    Parsers
  51. def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

    Permalink
    Definition Classes
    Parsers
  52. lazy val em: Parser[Emphasized]

    Permalink

    Parses a span of emphasized text.

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

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#standalone-hyperlinks

    Definition Classes
    InlineParsers
  54. val emailAddress: Parser[String]

    Permalink

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

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

    Definition Classes
    URIParsers
  55. val emailURI: Parser[String]

    Permalink

    Parses a full mailto URI as defined in RFC 6068.

    Parses a full mailto URI as defined in RFC 6068.

    mailtoURI = "mailto:" [ to ] [ hfields ]
    Definition Classes
    URIParsers
  56. def enumList: Parser[EnumList]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#enumerated-lists.

    Definition Classes
    ListParsers
  57. def eof: Parser[String]

    Permalink

    Succeeds at the end of the input.

    Succeeds at the end of the input.

    Definition Classes
    MarkupParsers
  58. def eol: Parser[String]

    Permalink

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

    Succeeds at the end of a line, including the end of the input. Produces an empty string as a result and consumes any new line characters.

    Definition Classes
    MarkupParsers
  59. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  60. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  61. def err(msg: String): Parser[Nothing]

    Permalink
    Definition Classes
    Parsers
  62. lazy val escapedChar: Parser[String]

    Permalink

    Parses an escaped character.

    Parses an escaped character. For most characters it produces the character itself as the result with the only exception being an escaped space character which is removed from the output in reStructuredText.

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#escaping-mechanism.

    Definition Classes
    InlineParsersInlineParsers
  63. def escapedText(p: TextParser): Parser[String]

    Permalink

    Adds support for escape sequences to the specified text parser.

    Adds support for escape sequences to the specified text parser.

    p

    the parser to add support for escape sequences to

    returns

    a parser for a text span that supports escape sequences

    Definition Classes
    InlineParsers
  64. def escapedUntil(char: Char*): Parser[String]

    Permalink

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

    Parses a span of text until one of the specified characters is seen (unless it is escaped), while also processing escaped characters, but no other nested spans. The final character is not included in the result.

    char

    the character that signals the end of the text span

    returns

    a parser for a text span that supports escape sequences

    Definition Classes
    InlineParsers
  65. def explicitBlockItem: Parser[Block]

    Permalink

    Parses all types of explicit block items.

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

    Permalink
    Definition Classes
    Parsers
  67. def fieldList: Parser[Block]

    Permalink

    Parses a field list.

  68. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  69. def flatten(result: Any): String

    Permalink

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

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

    Definition Classes
    URIParsers
  70. def footnote: Parser[FootnoteDefinition]

    Permalink

    Parses a footnote.

  71. val footnoteLabel: Parser[FootnoteLabel]

    Permalink

    Parses any of the four supported types of footnote labels.

    Parses any of the four supported types of footnote labels.

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#footnote-references.

    Definition Classes
    InlineParsers
  72. lazy val footnoteRef: Parser[FootnoteReference]

    Permalink

    Parses a footnote reference.

  73. val fragment: Parser[String]

    Permalink

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

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

    fragment = *( pchar / "/" / "?" )
    Definition Classes
    URIParsers
  74. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  75. def gridTable: Parser[Table]

    Permalink

    Parses a grid table.

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

    Permalink
    Definition Classes
    Parsers
  77. def handleWhiteSpace(source: CharSequence, offset: Int): Int

    Permalink
    Attributes
    protected
    Definition Classes
    RegexParsers
  78. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  79. def headerWithOverline: Parser[Block]

    Permalink

    Parses a section header with both overline and underline.

    Parses a section header with both overline and underline.

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#sections.

    Definition Classes
    BlockParsers
  80. def headerWithUnderline: Parser[Block]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#sections.

    Definition Classes
    BlockParsers
  81. val hexdig: TextParser

    Permalink

    Parses a hexadecimal value according to RFC 2234.

    Parses a hexadecimal value according to RFC 2234.

    HEXDIG = DIGIT / "A" / "B" / "C" / "D" / "E" / "F"
    Definition Classes
    URIParsers
  82. val hfields: Parser[String]

    Permalink

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

    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  = "!" / "$" / "'" / "(" / ")" / "*"
                 / "+" / "," / ";" / ":" / "@"
    Definition Classes
    URIParsers
  83. val hierPart: Parser[String]

    Permalink

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

    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
    Definition Classes
    URIParsers
  84. val host: Parser[String]

    Permalink

    Parses a host as defined in RFC 3986.

    Parses a host as defined in RFC 3986.

    host = IP-literal / IPv4address / reg-name
    Definition Classes
    URIParsers
  85. val httpUri: Parser[String]

    Permalink

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

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

    Definition Classes
    URIParsers
  86. val httpUriNoScheme: Parser[String]

    Permalink

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

    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 ]
    Definition Classes
    URIParsers
  87. val httpsUri: Parser[String]

    Permalink

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

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

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

    Permalink

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

    Parses a full block based on the specified helper parsers, expecting an indentation for all lines except the first. The indentation may vary between the parts of the indented block, so that this parser only cuts off the minimum indentation shared by all lines, but each line must have at least the specified minimum indentation.

    minIndent

    the minimum indentation that each line in this block must have

    linePredicate

    parser that recognizes the start of subsequent lines that still belong to the same block

    endsOnBlankLine

    indicates whether parsing should end on the first blank line

    firstLineIndented

    indicates whether the first line is expected to be indented, too

    maxIndent

    the maximum indentation that will get dropped from the start of each line of the result

    returns

    a parser that produces an instance of IndentedBlock

    Definition Classes
    BlockParsers
  89. def inline[Elem, To](text: ⇒ TextParser, nested: ⇒ Map[Char, Parser[Elem]], resultBuilder: ⇒ ResultBuilder[Elem, To]): Parser[To]

    Permalink

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

    Generic base parser that parses inline elements based on the specified helper parsers. Usually not used directly by parser implementations, this is the base parser the other inline parsers of this trait delegate to.

    Elem

    the element type produced by a single parser for a nested span

    To

    the type of the result this parser produces

    nested

    a mapping from the start character of a span to the corresponding parser for nested span elements

    resultBuilder

    responsible for building the final result of this parser based on the results of the helper parsers

    returns

    the resulting parser

    Definition Classes
    InlineParsers
  90. lazy val inlineLiteral: Parser[Literal]

    Permalink

    Parses an inline literal element.

  91. val internalTarget: Parser[Text]

    Permalink

    Parses an inline internal link target.

  92. lazy val interpretedTextWithRolePrefix: Parser[InterpretedText]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#interpreted-text

    Definition Classes
    InlineParsers
  93. lazy val interpretedTextWithRoleSuffix: Parser[InterpretedText]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#interpreted-text

    Definition Classes
    InlineParsers
  94. val ipLiteral: Parser[String]

    Permalink

    Parses an ip literal as defined in RFC 3986.

    Parses an ip literal as defined in RFC 3986.

    IP-literal = "[" ( IPv6address / IPvFuture  ) "]"
    Definition Classes
    URIParsers
  95. val ipv4address: Parser[String]

    Permalink

    Parses an IPv4 address as defined in RFC 3986.

    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

    The implementation has been simplified to parse a 3-digit number and check its value.

    Definition Classes
    URIParsers
  96. val ipv6address: Parser[~[Any, Any]]

    Permalink

    Parses an IPv6 address as defined in RFC 3986.

    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
    Definition Classes
    URIParsers
  97. val ipvFuture: Parser[~[~[~[Char, String], Char], List[Any]]]

    Permalink

    Parses a future IP address as defined in RFC 3986.

    Parses a future IP address as defined in RFC 3986.

    IPvFuture = "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
    Definition Classes
    URIParsers
  98. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  99. def lineBlock: Parser[Block]

    Permalink

    Parses a block of lines with line breaks preserved.

    Parses a block of lines with line breaks preserved.

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#line-blocks.

    Definition Classes
    ListParsers
  100. def linkTarget: Parser[Block with Span]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#hyperlink-targets.

    Definition Classes
    ExplicitBlockParsers
  101. implicit def literal(s: String): Parser[String]

    Permalink
    Definition Classes
    RegexParsers
  102. def literalBlock: Parser[Block]

    Permalink

    Parses a literal block, either quoted or indented.

    Parses a literal block, either quoted or indented. Only used when the preceding block ends with a double colon (::).

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#literal-blocks

    Definition Classes
    BlockParsers
  103. val localPart: Parser[String]

    Permalink

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

    Parses the local part of an email address (before the @), with one deviation from RFC 6068: a quoted string is not allowed. It is rarely used, not supported by the reStructuredText reference parser and would be hard to combine within text markup as it allows for whitespace and line break characters.

    local-part = dot-atom-text / quoted-string ; quoted-string omitted
    Definition Classes
    URIParsers
  104. def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

    Permalink
    Definition Classes
    Parsers
  105. def lookBehind[T](offset: Int, parser: ⇒ Parser[T]): Parser[T]

    Permalink

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

    Applies the specified parser at the specified offset behind the current position. Never consumes any input.

    Definition Classes
    BaseParsers
  106. def markupEnd(end: Parser[String]): Parser[String]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#inline-markup-recognition-rules.

    end

    the parser that recognizes the markup at the end of an inline element

    returns

    a parser that produces the same result as the parser passed as an argument

    Definition Classes
    InlineParsers
  107. def markupStart(end: Parser[String]): Parser[Any]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#inline-markup-recognition-rules.

    end

    the parser that recognizes the markup at the end of an inline element, needed to verify the start sequence is not immediately followed by an end sequence as empty elements are not allowed.

    returns

    a parser without a useful result, as it is only needed to verify it succeeds

    Definition Classes
    InlineParsers
  108. def markupStart(start: Parser[Any], end: Parser[String]): Parser[Any]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#inline-markup-recognition-rules.

    start

    the parser that recognizes the markup at the start of an inline element

    end

    the parser that recognizes the markup at the end of an inline element, needed to verify the start sequence is not immediately followed by an end sequence as empty elements are not allowed.

    returns

    a parser without a useful result, as it is only needed to verify it succeeds

    Definition Classes
    InlineParsers
  109. val maxNestLevel: Int

    Permalink

    The maximum level of block nesting.

    The maximum level of block nesting. Some block types like lists and blockquotes contain nested blocks. To protect against malicious input or accidentally broken markup, the level of nesting is restricted.

    Definition Classes
    BlockParsers
  110. def mkList[T]: (~[T, List[T]]) ⇒ List[T]

    Permalink
    Definition Classes
    Parsers
  111. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  112. def nestLevel(reader: Input): Int

    Permalink

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

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

    The nest level is usually only used to prevent endless recursion of nested blocks.

    Definition Classes
    BlockParsers
  113. final lazy val nestedBlock: Parser[Block]

    Permalink

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

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

    Definition Classes
    BlockParsers
  114. def nonRecursiveBlock: Parser[Block]

    Permalink

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

    Parses reStructuredText blocks, except for blocks that allow nesting of blocks. Only used in rare cases when the maximum nest level allowed had been reached

    Definition Classes
    BlockParsersBlockParsers
  115. def not[T](p: ⇒ Parser[T]): Parser[Unit]

    Permalink
    Definition Classes
    Parsers
  116. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  117. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  118. def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

    Permalink
    Definition Classes
    Parsers
  119. def optimizedCharLookup(chars: Char*): (Char) ⇒ Boolean

    Permalink

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

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

    Attributes
    protected
    Definition Classes
    MarkupParsers
  120. def optimizedRangeLookup(ranges: Traversable[Char]*): (Char) ⇒ Boolean

    Permalink

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

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

    Attributes
    protected
    Definition Classes
    MarkupParsers
  121. def optionList: Parser[Block]

    Permalink

    Parses an option list.

  122. val pChar: Parser[Any]

    Permalink

    Parses one path character as defined in RFC 3986.

    Parses one path character as defined in RFC 3986.

    pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
    Definition Classes
    URIParsers
  123. def paragraph: Parser[Paragraph]

    Permalink

    Parses a single paragraph.

    Parses a single paragraph. Everything between two blank lines that is not recognized as a special reStructuredText block type will be parsed as a regular paragraph.

    Definition Classes
    BlockParsers
  124. def parse[T](p: Parser[T], in: Reader): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  125. def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  126. def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  127. def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  128. def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  129. def parseAll[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  130. def parseConfigAndRoot(reader: Reader[Char], path: Path): (Config, RootElement)

    Permalink

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

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

    Attributes
    protected
    Definition Classes
    BlockParsers
  131. def parseDirectivePart[T](parser: Parser[T], source: String): Either[String, T]

    Permalink

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

    Utility method to be used by custom parsers for directive argument or body. It translates a Success into a Right and a NoSuccess into a Left.

    Definition Classes
    ExplicitBlockParsers
  132. def parseDocument(reader: Reader[Char], path: Path): Document

    Permalink

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

    Fully parses the input from the specified reader and returns the document tree. This function is expected to always succeed, errors would be considered a bug of this library, as the parsers treat all unknown or malformed markup as regular text.

    Definition Classes
    BlockParsersBlockParsers
  133. def parseInline(source: String, spanParsers: Map[Char, Parser[Span]]): List[Span]

    Permalink

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

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

    This function is expected to always succeed, errors would be considered a bug of this library, as the parsers treat all unknown or malformed markup as regular text. Some parsers might additionally insert system message elements in case of markup errors.

    source

    the input to parse

    spanParsers

    a mapping from the start character of a span to the corresponding parser

    returns

    the result of the parser in form of a list of spans

    Definition Classes
    InlineParsersInlineParsers
  134. def parseInline(source: String): List[Span]

    Permalink

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

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

    This function is expected to always succeed, errors would be considered a bug of this library, as the parsers treat all unknown or malformed markup as regular text. Some parsers might additionally insert system message elements in case of markup errors.

    source

    the input to parse

    returns

    the result of the parser in form of a list of spans

    Definition Classes
    InlineParsers
  135. def parseMarkup[T](parser: Parser[T], reader: Reader[Char]): T

    Permalink

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

    Fully parses the input from the specified reader and returns the result. This function is expected to always succeed, errors would be considered a bug in this library, as the parsers treat all unknown or malformed markup as regular text.

    Definition Classes
    MarkupParsers
  136. def parseMarkup[T](parser: Parser[T], source: String): T

    Permalink

    Fully parses the specified input string and returns the result.

    Fully parses the specified input string and returns the result. This function is expected to always succeed, errors would be considered a bug in this library, as the parsers treat all unknown or malformed markup as regular text.

    Definition Classes
    MarkupParsers
  137. def parseNestedBlocks(block: IndentedBlock): List[Block]

    Permalink

    Parses all nested blocks inside the specified indented block.

    Parses all nested blocks inside the specified indented block.

    Definition Classes
    BlockParsers
  138. def parseNestedBlocks(input: String, nestLevel: Int): List[Block]

    Permalink

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

    Parses all nested blocks for the specified input and nest level. Delegates to the abstract nestedBlock parser that sub-traits need to define. The nest level is primarily used as a protection against malicious input that forces endless recursion.

    input

    the input to parse

    nestLevel

    the level of nesting with 0 being the outermost level

    returns

    the parser result as a list of blocks

    Definition Classes
    BlockParsers
  139. def parseNestedBlocks(lines: List[String], nestLevel: Int): List[Block]

    Permalink

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

    Parses all nested blocks for the specified input and nest level. Delegates to the abstract nestedBlock parser that sub-traits need to define. The nest level is primarily used as a protection against malicious input that forces endless recursion.

    lines

    the input to parse

    nestLevel

    the level of nesting with 0 being the outermost level

    returns

    the parser result as a list of blocks

    Definition Classes
    BlockParsers
  140. val path: Parser[String]

    Permalink

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

    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
    Definition Classes
    URIParsers
  141. val pctEncoded: Parser[~[Char, String]]

    Permalink

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

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

    pct-encoded = "%" HEXDIG HEXDIG
    Definition Classes
    URIParsers
  142. def phrase[T](p: Parser[T]): Parser[T]

    Permalink
    Definition Classes
    RegexParsers → Parsers
  143. lazy val phraseLinkRef: Parser[Span]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#hyperlink-references

    Definition Classes
    InlineParsers
  144. val phraseRef: Parser[String]

    Permalink

    Parses a phrase reference name enclosed in back ticks.

    Parses a phrase reference name enclosed in back ticks.

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#reference-names.

    Definition Classes
    InlineParsers
  145. val port: Parser[String]

    Permalink

    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.

    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
    Definition Classes
    URIParsers
  146. def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

    Permalink
    Definition Classes
    RegexParsers → Parsers
  147. def prepareBlockParsers(nested: Boolean): List[Parser[Block]]

    Permalink

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

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

    nested

    true if these are parsers for nested blocks, false if they are for top level blocks

    returns

    a list of block parsers which later will be interpreted as choices in the specified order

    Attributes
    protected
    Definition Classes
    BlockParsersBlockParsers
  148. def prepareSpanParsers: Map[Char, Parser[Span]]

    Permalink

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

    A mapping of the start character of an inline element to the corresponding parser. The mapping is used to provide a fast implementation of an inline parser that only stops at known special characters.

    Attributes
    protected
    Definition Classes
    InlineParsersInlineParsers
  149. val punctuationChar: TextParser

    Permalink

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

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

    Definition Classes
    BlockParsersListParsers
  150. val query: Parser[String]

    Permalink

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

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

    query = *( pchar / "/" / "?" )
    Definition Classes
    URIParsers
  151. def quotedBlock(p: BlockParsers, style: String)(input: String): Either[String, Block]

    Permalink

    Parses a quoted block with nested blocks.

    Parses a quoted block with nested blocks.

    p

    the standard block parsers including all registered directives for recursive use

    input

    the input to parse

    returns

    Right in case of parser success and Left in case of failure, to adjust to the Directive API

  152. val refName: Parser[String]

    Permalink

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

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

    Definition Classes
    MarkupParsers
  153. val regName: Parser[String]

    Permalink

    Parses a server name as defined in RFC 3986.

    Parses a server name as defined in RFC 3986.

    reg-name = *( unreserved / pct-encoded / sub-delims )
    Definition Classes
    URIParsers
  154. implicit def regex(r: Regex): Parser[String]

    Permalink
    Definition Classes
    RegexParsers
  155. def rep[T](first: ⇒ Parser[T], next: (T) ⇒ Parser[T]): Parser[List[T]]

    Permalink

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

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

    first

    the parser to use for the first piece of input

    next

    a function that determines the next parser based on the result of the previous

    Definition Classes
    BaseParsers
  156. def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
  157. def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) The p0 call-by-name arguments is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.

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

    Permalink
    Definition Classes
    Parsers
  159. def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
  160. def repMax[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

    Permalink

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

    Uses the parser for at most the specified number of repetitions, always succeeds. The result is the list of results from applying the parser repeatedly.

    Definition Classes
    BaseParsers
  161. def repMin[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

    Permalink

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

    Uses the parser for at least the specified number of repetitions or otherwise fails. Continues to apply the parser after the minimum has been reached until if fails. The result is the list of results from applying the parser repeatedly.

    Definition Classes
    BaseParsers
  162. def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
  163. def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
  164. def restOfLine: Parser[String]

    Permalink

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

    Parses the rest of the line from the current input offset no matter whether it consist of whitespace only or some text. Does not include the eol character(s).

    Definition Classes
    BlockParsers
  165. def roleDirective: Parser[Block]

    Permalink

    Parses a role directive.

  166. def rootElement: Parser[RootElement]

    Permalink

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

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

    Definition Classes
    BlockParsers
  167. lazy val shortAnonymousLinkTarget: Parser[ExternalLinkDefinition]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#anonymous-hyperlinks.

    Definition Classes
    ExplicitBlockParsers
  168. lazy val simpleLinkRef: Parser[Span]

    Permalink

    Parses a simple link reference.

  169. val simpleRefName: Parser[String]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#reference-names.

    Definition Classes
    InlineParsers
  170. def simpleTable: Parser[Table]

    Permalink

    Parses a simple table.

  171. def skipWhitespace: Boolean

    Permalink
    Definition Classes
    MarkupParsers → RegexParsers
  172. def spanDirective(name: String): Option[DirectivePart[Span]]

    Permalink

    Retrieves the span directive with the specified name.

    Retrieves the span directive with the specified name.

    See laika.parse.rst.Directives for details on how to implement directives.

    Definition Classes
    StandardDirectiveParsersExplicitBlockParsers
  173. final lazy val spanParsers: Map[Char, Parser[Span]]

    Permalink

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

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

    A parser mapped to a start character is not required to successfully parse the subsequent input. If it fails the character that triggered the parser invocation will be treated as normal text. The mapping is merely used as a performance optimization. The parser will be invoked with the input offset pointing to the character after the one specified as the key for the mapping.

    Definition Classes
    InlineParsers
  174. def spans(parser: ⇒ TextParser, spanParsers: ⇒ Map[Char, Parser[Span]]): Parser[List[Span]]

    Permalink

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

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

    parser

    the parser for the text of the current span element

    returns

    the resulting parser

    Definition Classes
    InlineParsers
  175. def standardSpans(p: InlineParsers)(input: String): Either[String, Seq[Span]]

    Permalink

    Parses all standard inline markup supported by reStructuredText.

    Parses all standard inline markup supported by reStructuredText.

    p

    the standard inline parsers including all registered directives for recursive use

    input

    the input to parse

    returns

    Right in case of parser success and Left in case of failure, to adjust to the Directive API

  176. lazy val strong: Parser[Strong]

    Permalink

    Parses a span of text with strong emphasis.

    Definition Classes
    InlineParsers
  177. val subDelims: TextParser

    Permalink

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

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

    sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
                     / "*" / "+" / "," / ";" / "="
    Definition Classes
    URIParsers
  178. def substitutionDefinition: Parser[Block]

    Permalink

    Parses a substitution definition.

  179. lazy val substitutionRef: Parser[Reference]

    Permalink

    Parses a substitution reference.

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

    Permalink
    Definition Classes
    Parsers
  181. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  182. def table(p: BlockParsers)(input: String): Either[String, Table]

    Permalink

    Parses one of the two table types supported by reStructuredText.

    Parses one of the two table types supported by reStructuredText.

    p

    the standard block parsers including all registered directives for recursive use

    input

    the input to parse

    returns

    Right in case of parser success and Left in case of failure, to adjust to the Directive API

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

    Permalink

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

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

    input

    the input to parse

    returns

    Right in case of parser success and Left in case of failure, to adjust to the Directive API

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

    Permalink

    Parses text based on the specified helper parsers.

    Parses text based on the specified helper parsers.

    parser

    the parser for the text of the current element

    nested

    a mapping from the start character of a span to the corresponding parser for nested span elements

    returns

    the resulting parser

    Definition Classes
    InlineParsers
  185. val textLine: Parser[String]

    Permalink

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

    Parses a single text line from the current input offset (which may not be at the start of the line. Fails for blank lines. Does not include the eol character(s).

    Definition Classes
    BlockParsers
  186. def textRole(name: String): Option[RoleDirectivePart[(String) ⇒ Span]]

    Permalink

    Retrieves the text role with the specified name.

    Retrieves the text role with the specified name.

    See laika.parse.rst.TextRoles for details on how to implement text roles.

    Definition Classes
    StandardDirectiveParsersExplicitBlockParsers
  187. def textRoleElements: List[CustomizedTextRole]

    Permalink

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

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

    Definition Classes
    BlockParsers
  188. val to: Parser[String]

    Permalink

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

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

    to = addr-spec *("," addr-spec )
    Definition Classes
    URIParsers
  189. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  190. final lazy val topLevelBlock: Parser[Block]

    Permalink

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

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

    Definition Classes
    BlockParsers
  191. val transition: Parser[Rule]

    Permalink

    Parses a transition (rule).

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

    Permalink

    Parses unicode values in various notations intertwined with normal text.

    Parses unicode values in various notations intertwined with normal text.

    input

    the input to parse

    returns

    Right in case of parser success and Left in case of failure, to adjust to the Directive API

  193. val unreserved: Parser[String]

    Permalink

    Parses a single unreserved character as defined in RFC 3986.

    Parses a single unreserved character as defined in RFC 3986.

    sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
                     / "*" / "+" / "," / ";" / "="
    Definition Classes
    URIParsers
  194. lazy val uri: Parser[(String, String, String)]

    Permalink

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

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

    See http://docutils.sourceforge.net/docs/ref/rst/restructuredtext.html#standalone-hyperlinks

    Definition Classes
    InlineParsers
  195. val userInfo: Parser[String]

    Permalink

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

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

    userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
    Definition Classes
    URIParsers
  196. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  197. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  198. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  199. val whiteSpace: Regex

    Permalink
    Attributes
    protected
    Definition Classes
    RegexParsers
  200. def withNestLevel[T](p: ⇒ Parser[T]): Parser[(Int, T)]

    Permalink

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

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

    The nest level is usually only used to prevent endless recursion of nested blocks.

    Definition Classes
    BlockParsers
  201. def ws: TextParser

    Permalink

    Parses horizontal whitespace (space and tab).

    Parses horizontal whitespace (space and tab). Always succeeds, consuming all whitespace found.

    Definition Classes
    BlockParsersMarkupParsers

Inherited from InlineParsers

Inherited from URIParsers

Inherited from parse.InlineParsers

Inherited from BlockParsers

Inherited from ExplicitBlockParsers

Inherited from TableParsers

Inherited from ListParsers

Inherited from parse.BlockParsers

Inherited from MarkupParsers

Inherited from BaseParsers

Inherited from RegexParsers

Inherited from Parsers

Inherited from AnyRef

Inherited from Any

Ungrouped