bundle

Type Members

class BlockParser extends AnyRef

Builder API for block parsers.
trait BlockParserBuilder extends ParserBuilder[BlockParserDefinition]

Builds a block parser definition lazily by passing the recursive parsers of the host language.
case class BlockParserDefinition(startChar: Option[Char], parser: Parser[Block], isRecursive: Boolean, position: BlockPosition, precedence: Precedence) extends ParserDefinition[Block] with Product with Serializable

Defines a parser for a single kind of block element, like a quoted block or a bullet list for example.
Defines a parser for a single kind of block element, like a quoted block or a bullet list for example.
startChar
the optional start character (allows performance optimizations when defined)
parser
the parser for the block element after the start character
isRecursive
indicates whether this parser produces child elements by recursively applying the parsers for the host language
position
indicates whether this parser is responsible for root or nested elements only, or for both
precedence
indicates whether the parser should be applied before the base parsers of the host language (high precedence) or after them
sealed trait BlockPosition extends AnyRef

Specifies the position a block element is allowed to appear in.
Specifies the position a block element is allowed to appear in.
RootOnly elements can only appear on the top level of the document hierarchy, while NestedOnly can only appear nested within other elements, e.g. as part of a list item or within a quoted block. Any allows block elements in any position.
trait ExtensionBundle extends AnyRef

An extension bundle is a collection of parser extensions, rewrite rules, render themes and other features to be applied to parse, render and transform operations.
An extension bundle is a collection of parser extensions, rewrite rules, render themes and other features to be applied to parse, render and transform operations. It serves as a central registry for all of Laika's extension and customization hooks.
The base trait contains empty implementations for all these features, therefore any bundle implementation only needs to override the relevant members.
If the bundle implementation is not parameterized, the most convenient choice for users would be to simply implement it as an object, like all built-in extensions do:
```
object MyExtensions extends ExtensionBundle {

  // override one or more members

}
```
This way a user can easily pass it to the operation builders:
```
Transform
  .from(Markdown).to(HTML)
  .using(MyExtensions)
  .fromFile("hello.md").toFile("hello.html")
```
case class MarkupExtensions(blockParsers: Seq[BlockParserBuilder], spanParsers: Seq[SpanParserBuilder], parserHooks: ParserHooks) extends Product with Serializable

Bundles extensions for the text markup parsers defined for the host language to support additional syntax not recognized by the base parsers.
Bundles extensions for the text markup parsers defined for the host language to support additional syntax not recognized by the base parsers.
When extension parsers fail for a given input the built-in parsers will still be tried for the same block or span respectively.
blockParsers
parsers for block elements in text markup, complementing the parsers of the host language
spanParsers
parsers for span elements in text markup, complementing the parsers of the host language
parserHooks
hooks for markup parsers to control aspects beyond the individual span and block parsers
sealed trait ParserBuilder[T <: ParserDefinition[_]] extends AnyRef

Builds a parser definition lazily by passing the recursive parsers of the host language.
Builds a parser definition lazily by passing the recursive parsers of the host language.
This indirection is needed when supplying parser implementations as many parsers recursively parse child elements. A list parser for example needs to be able to detect any other block or span element within a list item. But since it has no way of knowing which extensions a user might have added to the host language, those parsers are supplied from the outside by the parser engine.
case class ParserBundle(blockParsers: Seq[BlockParserBuilder] = Nil, spanParsers: Seq[SpanParserBuilder] = Nil, markupParserHooks: Option[ParserHooks] = None, configHeaderParsers: Seq[(Path) ⇒ Parser[Either[InvalidElement, Config]]] = Nil, templateParser: Option[Parser[TemplateRoot]] = None, styleSheetParser: Option[Parser[Set[StyleDeclaration]]] = None) extends Product with Serializable

Bundles a collection of all types of parsers used in a transformation.
Bundles a collection of all types of parsers used in a transformation.
The parsers for text markup and configuration headers are meant to complement base parsers defined by the host language. If they fail for a given input the built-in parsers will still be tried for the same block, span or configuration header respectively.
The parsers for stylesheets and templates on the other hand are meant to overwrite any previously installed parsers.
blockParsers
parsers for block elements in text markup, complementing the parsers of the host language
spanParsers
parsers for span elements in text markup, complementing the parsers of the host language
markupParserHooks
hooks for markup parsers to control aspects beyond the individual span and block parsers
configHeaderParsers
parser for configuration headers in text markup and template documents
templateParser
parser for template documents
styleSheetParser
parser for CSS documents
sealed trait ParserDefinition[E <: Element] extends AnyRef

Defines a parser for a single kind of text markup, like a literal text span or a bullet list for example.
case class ParserHooks(postProcessBlocks: (Seq[Block]) ⇒ Seq[Block] = identity, postProcessDocument: (Document) ⇒ Document = identity, preProcessInput: (Input) ⇒ Input = identity) extends Product with Serializable

Hooks for markup parsers to control aspects beyond the individual span and block parsers defined for the host language.
Hooks for markup parsers to control aspects beyond the individual span and block parsers defined for the host language.
postProcessBlocks
function invoked for every block container, allowing post-processing of the result
postProcessDocument
function invoked after parsing but before rewriting, allowing to modify the document
preProcessInput
function invoked before parsing, allowing to pre-process the input
sealed trait Precedence extends AnyRef

Indicates whether a parser should be applied before the base parsers of the host language (high precedence) or after them (low precedence).
trait RenderTheme extends AnyRef

Collects templates, styles and custom render functions to form a theme for a specific output format.
class SpanParser extends AnyRef

Builder API for span parsers.
trait SpanParserBuilder extends ParserBuilder[SpanParserDefinition]

Builds a span parser definition lazily by passing the recursive parsers of the host language.
case class SpanParserDefinition(startChar: Char, parser: Parser[Span], isRecursive: Boolean, precedence: Precedence) extends ParserDefinition[Span] with Product with Serializable

Defines a parser for a single kind of span element, like a literal text span or a link reference for example.
Defines a parser for a single kind of span element, like a literal text span or a link reference for example.
startChar
the start character (allows performance optimizations)
parser
the parser for the span element after the start character
isRecursive
indicates whether this parser produces child elements by recursively applying the parsers for the host language
precedence
indicates whether the parser should be applied before the base parsers of the host language (high precedence) or after them
case class StaticDocuments(tree: DocumentTree) extends Product with Serializable

A collection of static documents to be copied over to the target directory in each transform operation.
A collection of static documents to be copied over to the target directory in each transform operation.
This is allows for a central collection of CSS, JavaScript, image and other files needed for a specific theme.

Value Members

object BlockParser

Builder API for block parsers.
object BlockPosition
object ConfigImplicits

Extension methods for Typesafe Config instances.
object ConfigProvider

Factory for Typesafe Config instances that add information about the virtual path of the configuration within a Laika document tree.
object DocumentTypeMatcher

The default implementations for determining the document type of the input based on its path.
object ExtensionBundle

Provides default ExtensionBundle instances.
object Precedence
object RewriteRules

Utilities for dealing with rewrite rules.
object SpanParser

Builder API for span parsers.
object StaticDocuments extends InputTreeOps with Serializable

API for defining a collection of static documents based on one or more directories.
API for defining a collection of static documents based on one or more directories.
Like with all Laika IO, these may be actual file system directories or virtual in-memory trees of input documents.

package bundle

Type Members

class BlockParser extends AnyRef

trait BlockParserBuilder extends ParserBuilder[BlockParserDefinition]

case class BlockParserDefinition(startChar: Option[Char], parser: Parser[Block], isRecursive: Boolean, position: BlockPosition, precedence: Precedence) extends ParserDefinition[Block] with Product with Serializable

sealed trait BlockPosition extends AnyRef

trait ExtensionBundle extends AnyRef

case class MarkupExtensions(blockParsers: Seq[BlockParserBuilder], spanParsers: Seq[SpanParserBuilder], parserHooks: ParserHooks) extends Product with Serializable

sealed trait ParserBuilder[T <: ParserDefinition[_]] extends AnyRef

sealed trait ParserDefinition[E <: Element] extends AnyRef

case class ParserHooks(postProcessBlocks: (Seq[Block]) ⇒ Seq[Block] = identity, postProcessDocument: (Document) ⇒ Document = identity, preProcessInput: (Input) ⇒ Input = identity) extends Product with Serializable

sealed trait Precedence extends AnyRef

trait RenderTheme extends AnyRef

class SpanParser extends AnyRef

trait SpanParserBuilder extends ParserBuilder[SpanParserDefinition]

case class SpanParserDefinition(startChar: Char, parser: Parser[Span], isRecursive: Boolean, precedence: Precedence) extends ParserDefinition[Span] with Product with Serializable

case class StaticDocuments(tree: DocumentTree) extends Product with Serializable

Value Members

object BlockParser

object BlockPosition

object ConfigImplicits

object ConfigProvider

object DocumentTypeMatcher

object ExtensionBundle

object Precedence

object RewriteRules

object SpanParser

object StaticDocuments extends InputTreeOps with Serializable

Ungrouped