Spans
The API for declaring directives that can be used as inline elements in markup documents.
Type members
Classlikes
Inherited classlikes
The content of a directive part, either an attribute or the body.
The content of a directive part, either an attribute or the body.
- Inherited from:
- BuilderContext
Provides combinators to describe the expected structure of a specific directive.
Provides combinators to describe the expected structure of a specific directive.
- Inherited from:
- BuilderContext
Represents a directive, its name and its (combined) parts.
Represents a directive, its name and its (combined) parts.
- Inherited from:
- BuilderContext
The content of a parsed directive with the HOCON attributes captured in a Config
instance.
The content of a parsed directive with the HOCON attributes captured in a Config
instance.
- Inherited from:
- BuilderContext
The context of a directive during execution.
The context of a directive during execution.
- Inherited from:
- BuilderContext
Represents a single part (attribute or body) of a directive or a combination of multiple parts.
Represents a single part (attribute or body) of a directive or a combination of multiple parts.
- Inherited from:
- BuilderContext
The content of a body element divided by separator directives.
The content of a body element divided by separator directives.
- Inherited from:
- BuilderContext
Represents a separator directive, its name and its (combined) parts. It also allows to specify requirements for the minimum and maximum number of occurrences allowed for this directive. The default is unbounded, with 0 or more instances allowed.
Represents a separator directive, its name and its (combined) parts. It also allows to specify requirements for the minimum and maximum number of occurrences allowed for this directive. The default is unbounded, with 0 or more instances allowed.
- Inherited from:
- BuilderContext
Provides the basic building blocks for defining directives, Laika's extension mechanism for creating custom tags for both, templates or text markup.
Provides the basic building blocks for defining directives, Laika's extension mechanism for creating custom tags for both, templates or text markup.
This object is used as part of the concrete objects Blocks.dsl
,
Spans.dsl
and Templates.dsl
respectively.
It contains several simple combinators that allow to specify the expected attributes and body elements of the directive, optional converters for these elements and the function responsible for producing the final node element.
In contrast to custom tag hooks in other template engines the result of a directive is not a string. In the same way as markup documents get transformed into a tree of elements before rendering, a directive produces a node of the tree to render. As a result, the directive can be used independent from the output format.
Entry points of the API are the Templates
, Blocks
and Spans
objects for the
three different directive types.
A directive may consist of any combination of attributes and body elements:
@:myDirective { arg1 = value1, arg2 = value2 }
This is the body of the directive. It may consist of any standard or custom
block-level and inline markup.
@:@
In the example above arg1
and arg2
are attributes, followed by a body element
enclosed in curly braces.
For each of these directive elements, the API offers a combinator to specify whether the element is required or optional, and an optional function to convert.
Consider the following simple example of a directive with just one argument and a body, for specifying a specially formatted inline note:
@:note { This is the title }
This is the body of the note.
@:@
The implementation of this directive could look like this:
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], parsedBody).mapN(Note(_,_))
}
)
val spanDirectives = Seq()
}
val transformer = Transformer.from(Markdown).to(HTML).using(MyDirectives)
The defaultAttribute
combinator specifies a required attribute of type String
and without a name. The parsedBody
combinator specifies standard block content (any block
elements that are supported in normal markup, too) which results in a parsed value of type
Seq[Block]
.
Finally you need to provide a function that accepts the results of the specified
directive elements as parameters (of the corresponding type). Here we created a case class
with a matching signature so can pass it directly as the target function. For a block directive
the final result has to be of type Block
which the Note
class satisfies. Finally the directive
gets registered with the Markdown
parser. It can be registered for a reStructuredText
parser,
too, without any changes.
If any conversion of attributes is required it can be performed with the as[T]
method:
case class Message (severity: Int,
content: Seq[Block],
options: Options = NoOpt) extends Block
with BlockContainer[Message]
val blockDirectives = Seq(
Blocks.create("message") {
(defaultAttribute.as[Int], blockContent).mapN(Message(_,_))
}
)
In the example above the built-in Int
decoder gets passed to the defaultAttribute
combinator, but you can easily create and use your own instances of ConfigDecoder[T]
.
If required attributes or bodies are missing or any type conversion fails,
an instance of InvalidBlock
containing the error message and the raw source of the directive
will be inserted into the document tree. In this case the final function (Message
) will never be invoked.
Finally attributes can also be optional. In case they are missing, the directive is still
considered valid and None
will be passed to your function:
case class Message (severity: Int,
content: Seq[Block],
options: Options = NoOpt) extends Block
with BlockContainer[Message]
val blockDirectives = Seq(
Blocks.create("message") {
(defaultAttribute.as[Int].optional, blockContent).mapN {
(severity, content) => Message(severity.getOrElse(0), content)
}
}
)
The attribute may be missing, but if it is present it has to pass the specified validator.
- Inherited from:
- BuilderContext
Types
Inherited types
Value members
Inherited methods
Creates a new directive with the specified name and part specification.
Creates a new directive with the specified name and part specification.
- Inherited from:
- BuilderContext
Creates a new directive with the specified name and part specification.
Creates a new directive with the specified name and part specification.
When the result of the directive is a Left
, the directive will produce
an invalid AST element with the string as the error message.
- Inherited from:
- BuilderContext
Creates a new separator directive with the specified name and part specification.
Creates a new separator directive with the specified name and part specification.
- Inherited from:
- BuilderContext
Turns a collection of directives into a map, using the name of the directive as the key.
Turns a collection of directives into a map, using the name of the directive as the key.
- Inherited from:
- BuilderContext