laika.io.model

A binary input stream and its virtual path within the input tree.

A resource for binary output.

Most renderers write character data, but formats like PDF or EPUB require a binary stream to write to.

A directory in the file system containing input documents for a tree transformation.

The specified docTypeMatcher is responsible for determining the type of input (e.g. text markup, template, etc.) based on the (virtual) document path.

A directory as a target for a rendering operation of a document tree.

The specified codec will be used for writing all character output.

A (virtual) tree of input documents, either obtained from scanning a directory recursively or constructed programmatically (or a mix of both).

Even though the documents are specified as a flat sequence, they logically form a tree based on their virtual path.

Factory methods for creating InputTreeBuilder instances.

Builder API for freely constructing input trees from directories, files, classpath resources, in-memory strings or pre-constructed AST trees.

If your input is just one or more directories, you can use the corresponding shortcuts on the parser or transformer instances, e.g. transformer.fromDirectory(...).toDirectory(...). This builder is meant to be used for situations where more flexibility is required.

All the specified inputs will be combined into a single logical tree and each document gets a virtual path assigned that describes its logical position within the tree. As a consequence all cross-linking or referencing of images can happen within the virtual path abstraction, meaning a resource from the file system can point to an input constructed in-memory via a relative, virtual path.

When adding strings, files or directories you need to specify a "mount point" that signals where within the virtual tree the inputs should be placed. For adding directories the mount point is optional, when omitted the directory becomes the virtual root of the input tree.

The resulting input tree can be passed to parsers, transformers and theme builders.

Example for composing inputs from two directories, a template loaded from the classpath and a CSS file generated in-memory:

val inputs = InputTree[F]
 .addDirectory("/path-to-my/markup-files")
 .addDirectory("/path-to-my/images", Root / "images")
 .addClasspathResource("my-templates/default.template.html", DefaultTemplatePath.forHTML)
 .addString(generateMyStyles(), Root / "css" / "site.css")

These inputs can then be configured for the sbt plugin:

 laikaInputs := inputs

Or passed to a TreeTransformer instance:

val res: F[RenderedTreeRoot[F]] = transformer.use {
 _.fromInputTree(inputs)
  .toDirectory("target")
  .transform
}

The result of a parsing operation for an entire document tree.

The DocumentTreeRoot is the recursive structure of parsed inputs, like markup document, templates or other file types, represented by their AST.

The static documents are merely a sequence of unprocessed inputs that have been discovered via directory scanning (or have been passed programmatically). The actual processing of these inputs is left to the render step, which might copy them into a target directory, or embed them into an output format like EPUB.

A titled, positional element in the tree of rendered documents.

A single rendered document with the content as a plain string in the target format.

The title and section info are still represented as an AST, so they be used in any subsequent step that needs to produce navigation structures.

Represents a node of the tree of rendered documents.

Represents the root of a tree of rendered documents. In addition to the recursive structure of documents it holds additional items like static or cover documents, which may contribute to the output of a site or an e-book.

Instructs the renderer to produce an in-memory representation of the tree of rendered outputs.

Character input for the various parsers of this library.

Character output for the various renderers of this library

A (virtual) tree of output documents.