DirectiveRegistry

Registers the specified block directives.

Example:

case class Note (title: String, content: Seq[Block], options: Options = NoOpt)
                                                     extends Block with BlockContainer[Note]
object MyDirectives extends DirectiveRegistry {
  val blockDirectives = Seq(
    Blocks.create("note") {
      (defaultAttribute.as[String] ~ body).map { case title ~ content => Note(title, content) }
    }
  )
  val spanDirectives = Seq()
  val templateDirectives = Seq()
  val linkDirectives = Seq()
}

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

For more details on implementing Laika directives see laika.directive.BuilderContext.dsl.

Registers the specified link directives.

Example:

object MyDirectives extends DirectiveRegistry {
  val linkDirectives = Seq(
    Links.eval("rfc") { linkId =>
      Try(Integer.parseInt(linkId))
       .toEither
       .fold(
         _ => Left(s"Not a valid RFC id: $linkId"),
         id => Right(SpanLink.external(s"http://tools.ietf.org/html/rfc$linkId")(s"RFC $id"))
       )
    }
  )
  val blockDirectives = Seq()
  val spanDirectives = Seq()
}

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

The code above registers a link directive that detects markup like @:rfc(2356) and turns it into an external link node for the URL http://tools.ietf.org/html/rfc2356.

For more details on implementing Laika directives see laika.directive.BuilderContext.dsl.

Registers the specified span directives.

Example:

object MyDirectives extends DirectiveRegistry {
  val spanDirectives = Seq(
    Spans.create("ticket") {
      (defaultAttribute.as[String] ~ attribute("param").optional).map { case ticketNo ~ param =>
        val base = "http://tickets.service.com/"+ticketNo
        val url = base + (param map (p => "?param="+p) getOrElse "")
        SpanLink.external(url)("Ticket "+ticketNo).withOptions(Styles("ticket"))
      }
    }
  )
  val blockDirectives = Seq()
  val templateDirectives = Seq()
  val linkDirectives = Seq()
}

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

The code above registers a span directive that detects markup like @:ticket(2356) and turns it into an external link node for the URL http://tickets.service.com/2356.

For more details on implementing Laika directives see laika.directive.BuilderContext.dsl.

Registers the specified template directives.

Example:

object MyDirectives extends DirectiveRegistry {
  val templateDirectives = Seq(
    Templates.create("ticket") {
      (defaultAttribute.as[String] ~ attribute("param").optional).map { case ticketNo ~ param =>
        val base = "http://tickets.service.com/"+ticketNo
        val url = base + (param map (p => "&param="+p) getOrElse "")
        val link = SpanLink.external(url)("Ticket "+ticketNo).withOptions(Styles("ticket"))
        TemplateElement(link)
      }
    }
  )
  val blockDirectives = Seq()
  val spanDirectives = Seq()
  val linkDirectives = Seq()
}

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

The code above registers a template directive that detects markup like @:ticket(2356) and turns it into an external link node for the URL http://tickets.service.com/2356.

For more details on implementing Laika directives see laika.directive.BuilderContext.dsl.

Base configuration that serves as a fallback for configuration files in the source directories and/or config headers in markup and template documents.

Specifies the function to use for determining the document type of the input based on its path.

Any path for which this function is not defined will be processed by the remaining defined bundles. The documents for paths for which none of the extensions provides a DocumentType will be treated as static files to be copied over to the target directory in transformations by default.

Extends the built-in path translator with additional functionality.

The internal path translator deals with aspects like applying the suffix for the output format or modifying the path for versioned documents and more.

The PathTranslatorExtensionContext provides access to this internal path translator, to the output format it is going to be used for and the complete user configuration.

In most cases, extensions can simply be created by using either PathTranslator.preTranslate or PathTranslator.postTranslate to apply additional translation steps either before or after applying the internal translator.

Alternatively a completely custom implementation of the PathTranslator trait can be provided, but this will usually not be necessary.

PathTranslator implementations usually do not deal with the fragment part of the path. Use the slugBuilder extension point for this purpose.

Indicates whether the 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.

Specifies extensions and/or replacements for parsers that deal with text markup, templates, CSS or configuration headers.

Provides a version of this bundle that can be used in the default run mode where raw content in markup documents (such as embedded HTML) is disabled.

When a bundle does not add parsers for raw content it can return Some(this).

Any bundle to be used in the default run mode should be free from any parser extensions that allow raw content in markup. When the user switches the acceptRawContent flag to true then this method will not be invoked and the initial instance of the bundle is used.

The overrides for renderers defined by this bundle.

An override is always specific to a particular output format like HTML or PDF. A bundle can contain multiple overrides for the same output format which will be merged before use.

Specifies rewrite rules to be applied to the document tree model between the parse and render operations.

The specified functions will be invoked for each document, allowing to capture information from the entire document tree before returning the actual rule, which is a partial function from Element to Option[Element] that allows to remove or replace elements from the tree.

Function that receives the text of a headline, the name of a document or directory or a manually assigned identifier, and builds a slug from it that becomes part of the final URL or identifier (depending on output format).

The result of the function must be:

• a valid identifier in HTML and XML
• a valid path segment in a URL
• a valid file name

Returns a new extension bundle by merging the content of this bundle with the content of the base bundle.

The other bundle is treated as the base of this bundle, which means that:

• in case of optional features a feature defined in this bundle will overwrite a feature defined in the base

• in case of features applied in sequence, the features in this bundle will be applied before the features in the base bundle

• in case of feature collections, the features of this bundle will be merged with those of the base bundle