Crate crowbook [] [src]

Note: this documentation is relative to crowbook as a library. For documentation regarding the program crowbook, see the Github page.


Just like any other library, just add a dependency on crowbook in your Cargo.toml file. You will probably want to deactivate default features that are mostly useful for the binary:

Be careful when using this code, it's not being tested!
crowbook = {version = "0.11", default-features = false}


The central structure of Crowbook is Book, which coordinates everything.

Its roles are:

  • read a book configuration file and setting the book options accordingly;
  • read the chapters (written in Markdown) listed in this configuration file and pass them to to Parser, get back an AST and store it in memory
  • call the various renderers according to the book's parameters and generate the appopriate files.


Be careful when using this code, it's not being tested!
use crowbook::Book;
// Reads configuration file "" and render all formats according to this
// configuration file

This is basically the code for the crowbook binary (though it contains a bit more error handling, checking parameters from command line and so on). This is, however, not very interesting for a library usage.

The Book structure, however, exposes its chapter fields, which contains a vector with an element by chapter. With it, you can access the Markdown for all chapters represented as an Abstact Syntax Tree (i.e., a vector of Tokens). It is thus possible to create a new renderer (or manipulate this AST in other ways).


It is also possible to directly use Parser to transform some markdown string or file to this AST:

use crowbook::{Parser,Token};
let mut parser = Parser::new();
let result = parser.parse("Some *valid* Markdown").unwrap();
assert_eq!(format!("{:?}", result),
r#"[Paragraph([Str("Some "), Emphasis([Str("valid")]), Str(" Markdown")])]"#);

Of course, you probably want to do something else with this AST than display it. Let's assume you want to count the number of links in a document.

use crowbook::{Parser,Token};
fn count(ast: &[Token]) -> u32 {
   let mut n = 0;
   for token in ast {
       match *token {
           // It's a link, increase counter
           Token::Link(_,_,_) => n += 1,
           // It's not a link, let's count the number of links
           // inside of the inner element (if there is one)
          _ => {
               if let Some(sub_ast) = token.inner() {
                   n += count(sub_ast);

let md = "# Here's a [link]( #\n And *another [one](* !";

let mut parser = Parser::new();
let ast = parser.parse(md).unwrap();
assert_eq!(count(&ast), 2);



A Book.


Contains the options of a book.


Represents the content of a chapter.


Crowbook Error type.


A parser that reads markdown and convert it to AST (a vector of Tokens)


Resource Handler.


Source of an error.




Structure for storing a book option


The inner type for an annotation.


Numbering for a given chapter or part


A single token representing a Markdown element.



Thait that must be implemented by the various renderers to render a whole book.


Renderer trait, implemented by various renderer to render a list of Tokens.

Type Definitions


Crowbook's Result type, used by many methods that can fail