laika.bundle

Builder API for block parsers.

The entry points provide access to the parsers for child blocks (recursive), child spans (withSpans) or escape sequences (withEscapedText). These are methods with decreasing power, as the parser for recursive blocks does also provide the span parsers.

If your parser implementation is completely independent from the host markup language you can use the standalone method.

Attributes

Supertypes: class Object

trait Matchable

class Any
Self type: BlockParser.type

Builds a block parser definition lazily by passing the recursive parsers of the host language.

Attributes

Supertypes: trait ParserBuilder[BlockParserDefinition]

class Object

trait Matchable

class Any
Known subtypes: class BlockParserBuilderOps

Builder API for block parsers that allows to set the parser precedence.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait BlockParserBuilder

trait ParserBuilder[BlockParserDefinition]

class Object

trait Matchable

class Any
Show all

Defines a parser for a single kind of block element, like a quoted block or a bullet list for example.

Value parameters

isRecursive: indicates whether this parser produces child elements by recursively applying the parsers for the host language
paragraphLineCheck: a test for the start of each line in plain paragraphs that indicates whether the line might be the start of a block identified by this parser
parser: the parser for the block element
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
startChars: the optional start characters that can start this block (allows performance optimizations when defined)

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait ParserDefinition[Block]

class Object

trait Matchable

class Any
Show all

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.

Attributes

Companion: object
Supertypes: class Object

trait Matchable

class Any
Known subtypes: object Any.type

object NestedOnly.type

object RootOnly.type

Attributes

Companion: trait
Supertypes: trait Sum

trait Mirror

class Object

trait Matchable

class Any
Self type: BlockPosition.type

Indicates whether an extension bundle is a built-in default provided by the library, a collection of extensions installed by a markup format or user-defined.

This is relevant for determining the precedence of installed bundles when merging them, as user-supplied functionality always overrides library defaults.

Attributes

Companion: object
Supertypes: class Object

trait Matchable

class Any
Known subtypes: object Library.type

object Mixed.type

object Parser.type

object Theme.type

object User.type

Attributes

Companion: trait
Supertypes: trait Sum

trait Mirror

class Object

trait Matchable

class Any
Self type: BundleOrigin.type

Responsible for providing the parsers for configuration files and configuration headers in markup documents as part of an ExtensionBundle.

Laika has a built-in implementation of this API that parses configuration as HOCON, but these can be overridden by adding an instance of this trait to a ParserBundle within an ExtensionBundle.

Attributes

Companion: object
Supertypes: class Object

trait Matchable

class Any
Self type: ConfigProvider

Attributes

Companion: trait
Supertypes: class Object

trait Matchable

class Any
Self type: ConfigProvider.type

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

Attributes

Supertypes: class Object

trait Matchable

class Any
Self type: DocumentTypeMatcher.type

An extension bundle is a collection of parser extensions, rewrite rules, render overrides 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:

val transformer = Transformer
 .from(Markdown)
 .to(HTML)
 .using(MyExtensions)
 .build

Attributes

Companion: object
Supertypes: class Object

trait Matchable

class Any
Known subtypes: object Empty.type

object LaikaDefaults.type

trait DirectiveRegistry

object StandardDirectives.type

class DirectiveSupport

object DirectiveSupport.type

object BundledDefaults.type

object VerbatimHTML.type

object GitHubFlavor.type

object SyntaxHighlighting.type

object PrettyURLs.type

trait RstExtensionRegistry

object RawContentExtensions.type

object StandardExtensions.type

class RstExtensionSupport

object RstExtensionSupport.type
Show all
Self type: ExtensionBundle

Provides default ExtensionBundle instances.

Attributes

Companion: trait
Supertypes: class Object

trait Matchable

class Any
Self type: ExtensionBundle.type

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.

Value parameters

blockParsers: parsers for block 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
spanParsers: parsers for span elements in text markup, complementing the parsers of the host language
syntaxHighlighters: parsers for syntax highlighting of code blocks

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

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.

Attributes

Supertypes: class Object

trait Matchable

class Any
Known subtypes: trait BlockParserBuilder

class BlockParserBuilderOps

trait SpanParserBuilder

class SpanParserBuilderOps

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.

Value parameters

blockParsers: parsers for block elements in text markup, complementing the parsers of the host language
configProvider: parser for configuration headers in text markup and template documents and configuration documents
markupParserHooks: hooks for markup parsers to control aspects beyond the individual span and block parsers
spanParsers: parsers for span elements in text markup, complementing the parsers of the host language
styleSheetParser: parser for CSS documents
syntaxHighlighters: parsers for syntax highlighting of code blocks
templateParser: parser for template documents

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Defines a parser for a single kind of text markup, like a literal text span or a bullet list for example.

Attributes

Supertypes: class Object

trait Matchable

class Any
Known subtypes: class BlockParserDefinition

class SpanParserDefinition

Hooks for markup parsers to control aspects beyond the individual span and block parsers defined for the host language.

Value parameters

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

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

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

Attributes

Companion: object
Supertypes: class Object

trait Matchable

class Any
Known subtypes: object High.type

object Low.type

Attributes

Companion: trait
Supertypes: trait Sum

trait Mirror

class Object

trait Matchable

class Any
Self type: Precedence.type

Collects custom render functions that adjust the rendered output of one or more AST nodes.

Attributes

Supertypes: class Object

trait Matchable

class Any
Known subtypes: class Overrides

Builder API for span parsers.

The two entry points are either recursive if your parser implementation needs to recursively parse child spans defined by the host language or standalone if it doesn't.

Attributes

Supertypes: class Object

trait Matchable

class Any
Self type: SpanParser.type

Builds a span parser definition lazily by passing the recursive parsers of the host language.

Attributes

Supertypes: trait ParserBuilder[SpanParserDefinition]

class Object

trait Matchable

class Any
Known subtypes: class SpanParserBuilderOps

Builder API for span parsers that allows to set the parser precedence.

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait SpanParserBuilder

trait ParserBuilder[SpanParserDefinition]

class Object

trait Matchable

class Any
Show all

Defines a parser for a single kind of span element, like a literal text span or a link reference for example.

Value parameters

isRecursive: indicates whether this parser produces child elements by recursively applying the parsers for the host language
parser: the parser for the span element
precedence: indicates whether the parser should be applied before the base parsers of the host language (high precedence) or after them
startChars: all start characters that can start this span (allows performance optimizations)

Attributes

Supertypes: trait Serializable

trait Product

trait Equals

trait ParserDefinition[Span]

class Object

trait Matchable

class Any
Show all

Attributes

Supertypes: class Object

trait Matchable

class Any
Known subtypes: object AlloySyntax.type

object CSSSyntax.type

object DartSyntax.type

object DhallSyntax.type

object DottySyntax.type

object EBNFSyntax.type

object HOCONSyntax.type

object HTMLSyntax.type

object HaskellSyntax.type

object JSONSyntax.type

object JSX.type

object JavaScriptSyntax.type

object JavaSyntax.type

object LaikaASTSyntax.type

object MarkdownSyntax.type

object PythonSyntax.type

object ReStructuredTextSyntax.type

object SQLSyntax.type

object ScalaSyntax.type

object ShellSyntax.type

object TSX.type

object TypeScriptSyntax.type

object XMLSyntax.type

object YAMLSyntax.type
Show all

laika.bundle

Members list

Type members

Classlikes

Attributes

Attributes

Attributes

Value parameters

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Value parameters

Attributes

Attributes

Value parameters

Attributes

Attributes

Value parameters

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Value parameters

Attributes

Attributes