StandardDirectives

object StandardDirectives extends DirectiveRegistry

Provides the implementation for the standard directives included in Laika.

These include:

Navigation

- navigationTree: Generates a navigation tree either automatically from specified root nodes of the input tree or by specifying entries manually (or a combination of both). - breadcrumb: Builds a navigation list from the root node of the input tree to the current document. - api: Convenience directive that allows to reference an api documentation entry (e.g. scaladoc, javadoc) - source: Convenience directive that allows to reference a hosted source (e.g. on GitHub)

Inclusions

- include: Includes one template or markup document inside another, with the options to pass attributes that can be referenced in the included document. - embed: All the features of include, but also allows to pass a parsed directive body that can be referenced in the included document.

Applying Styles

- style: Adds one or more style properties to the body element (markup block or span).

Markup Blocks

- image: Alternative to native markup syntax for including images that supports additional attributes, like intrinsicWidth and intrinsicHeight to avoid layout shift, as well as alt and title. - callout: A decorated block element that stands out from the surrounding paragraphs; the default Helium theme renders the content with background color and icon. - select: Allows to create alternative versions of the same documentation, for example one with Scala code examples and one with Java. - fragment: Marks a block in a markup document as being separate from the main content, so that it can be placed independently in templates, e.g. in headers, footers or sidebars. - format: Process the body element only when the output format matches the format specified in the directive (e.g. pdf or html).

HTML Templates

- linkCSS: Adds link elements to HTML/EPUB output for all or selected CSS files found in the document tree - linkJS: Adds link elements to HTML/EPUB output for all or selected JavaScript files found in the document tree - relativePath: Translates an absolute or relative path from the perspective of a template to a path relative to the document the template had been applied to

Conditionals and Loops

- for: Accesses a value from the context and sets it as the reference context for its body elements, executing the body if the referenced value is non-empty and executing it multiple times when it is a collection. - if: Accesses a value from the context and processes the body element only when it is a value recognized as true.

PDF Output

- pageBreak: Inserts a page break element into the tree (will only be rendered by page-based output, like XSL-FO or PDF.

Comments

- todo: simple directive that accepts a string argument that will be ignored by renderers, overcoming the limitation that Markdown does not have a native comment syntax.

For extensive documentation see Standard Directives in the manual.

Linear Supertypes

DirectiveRegistry, ExtensionBundle, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

StandardDirectives
DirectiveRegistry
ExtensionBundle
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyRef → Any
def acceptRawContent: Boolean
Indicates that this bundle deals with raw content embedded in text markup, like HTML.
Indicates that this bundle deals with raw content embedded in text markup, like HTML.
These kind of bundles are disabled by default as Laika is designed to render to multiple output formats from a single input document. With raw content embedded the markup document is tied to a specific output format.
Bundles which have this flag set to true need to be enabled explicitly by the user by calling withRawContent on the Parse or Transform API:
```
val transformer = Transformer.from(Markdown).to(HTML).withRawContent.build
```
Definition Classes
ExtensionBundle
final def asInstanceOf[T0]: T0

Definition Classes
Any
lazy val attr: Templates.Directive
def baseConfig: Config
Base configuration that serves as a fallback for configuration files in the source directories and/or config headers in markup and template documents.
Base configuration that serves as a fallback for configuration files in the source directories and/or config headers in markup and template documents.

Definition Classes
ExtensionBundle
lazy val blockDirectives: Seq[Blocks.Directive]
The complete list of standard directives for block elements in markup documents.
The complete list of standard directives for block elements in markup documents.

Definition Classes
StandardDirectives → DirectiveRegistry
lazy val blockFragment: Blocks.Directive
Implementation of the fragment directive for block elements in markup documents.
lazy val blockStyle: Blocks.Directive
Implementation of the style directive for block elements in markup documents.
lazy val callout: Blocks.Directive
Implementation of the callout directive for block elements in markup documents.
Implementation of the callout directive for block elements in markup documents. The body of such a directive will get two styles assigned: callout and the argument passed to the directive (e.g. @:callout(info)).
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
val description: String
Short string describing the extension for tooling and logging.
Short string describing the extension for tooling and logging.

Definition Classes
StandardDirectives → DirectiveRegistry → ExtensionBundle
def docTypeMatcher: PartialFunction[Path, DocumentType]
Specifies the function to use for determining the document type of the input based on its path.
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.

Definition Classes
ExtensionBundle
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
lazy val format: Blocks.Directive
Implementation of the format directive for block elements in markup documents.
Implementation of the format directive for block elements in markup documents. The content of such a block will only be rendered for the corresponding output format (e.g. pdf or html).
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
lazy val iconSpan: Spans.Directive
Implementation of the icon directive for span elements in markup documents.
lazy val iconTemplate: Templates.Directive
Implementation of the icon directive for span elements in templates.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val linkDirectives: Seq[Directive]
The complete list of standard directives for links.
The complete list of standard directives for links.

Definition Classes
StandardDirectives → DirectiveRegistry
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
val origin: BundleOrigin
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.
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.

Definition Classes
StandardDirectives → ExtensionBundle
lazy val pageBreak: Blocks.Directive
Implementation of the pageBreak directive.
def parsers: ParserBundle
Specifies extensions and/or replacements for parsers that deal with text markup, templates, CSS or configuration headers.
Specifies extensions and/or replacements for parsers that deal with text markup, templates, CSS or configuration headers.

Definition Classes
ExtensionBundle
lazy val path: Templates.Directive
def processExtension: PartialFunction[ExtensionBundle, ExtensionBundle]
Internal API usually only called by other extension bundles.
Internal API usually only called by other extension bundles.
In some cases a bundle might be an extension of another bundle and needs the opportunity to process and modify that bundle without requiring a direct reference to it. An example is a registry for directives which needs to pass all its registered directives to the bundle which deals with finally creating all the directive parsers.
The partial function should match only on the types of bundles it intends to process and is then allowed to return a new, modified instance of that bundle.

Definition Classes
DirectiveRegistry → ExtensionBundle
def renderOverrides: Seq[RenderOverrides]
The overrides for renderers defined by this bundle.
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.

Definition Classes
ExtensionBundle
def rewriteRules: Seq[RewriteRulesBuilder]
Specifies rewrite rules to be applied to the document tree model between the parse and render operations.
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.

Definition Classes
ExtensionBundle
def slugBuilder: Option[(String) ⇒ String]
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).
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

Definition Classes
ExtensionBundle
lazy val spanDirectives: Seq[Spans.Directive]
The complete list of standard directives for span elements in markup documents.
The complete list of standard directives for span elements in markup documents.

Definition Classes
StandardDirectives → DirectiveRegistry
lazy val spanStyle: Spans.Directive
Implementation of the style directive for span elements in markup documents.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
lazy val templateDirectives: Seq[Templates.Directive]
The complete list of standard directives for templates.
The complete list of standard directives for templates.

Definition Classes
StandardDirectives → DirectiveRegistry
lazy val templateFragment: Templates.Directive
Implementation of the fragment directive for templates.
def toString(): String

Definition Classes
AnyRef → Any
val todoBlock: Blocks.Directive
Implementation of the todo directive for block elements.
val todoSpan: Spans.Directive
Implementation of the todo directive for inline elements.
def useInStrictMode: Boolean
Indicates that this bundle should still be used if the user runs a transformation in strict mode.
Indicates that this bundle should still be used if the user runs a transformation in strict mode.
This setting is appropriate if a bundle contains features which are native elements of a text markup language as defined in its specification, but implemented as an extension for technical reasons.

Definition Classes
ExtensionBundle
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
def withBase(base: ExtensionBundle): ExtensionBundle
Returns a new extension bundle by merging the content of this bundle with the content of the base bundle.
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

Definition Classes
ExtensionBundle

Packages

StandardDirectives

object StandardDirectives extends DirectiveRegistry

Value Members

Inherited from DirectiveRegistry

Inherited from ExtensionBundle

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

StandardDirectives 

object StandardDirectives extends DirectiveRegistry

Value Members

Inherited from DirectiveRegistry

Inherited from ExtensionBundle

Inherited from AnyRef

Inherited from Any

Ungrouped

StandardDirectives