Struct mdbook::book::MDBook

pub struct MDBook {
    pub root: PathBuf,
    pub config: Config,
    pub book: Book,
    // some fields omitted
}

The object used to manage and build a book.

Fields

root: PathBuf

The book's root directory.

config: Config

The configuration used to tweak now a book is built.

book: Book

A representation of the book's contents in memory.

Methods

impl MDBook

pub fn load<P: Into<PathBuf>>(book_root: P) -> Result<MDBook>

Load a book from its root directory on disk.

pub fn load_with_config<P: Into<PathBuf>>(
    book_root: P,
    config: Config
) -> Result<MDBook>

Load a book from its root directory using a custom config.

Important traits for BookItems<'a>

impl<'a> Iterator for BookItems<'a> type Item = &'a BookItem;

pub fn iter(&self) -> BookItems

Returns a flat depth-first iterator over the elements of the book, it returns an BookItem enum: (section: String, bookitem: &BookItem)

for item in book.iter() {
    match *item {
        BookItem::Chapter(ref chapter) => {},
        BookItem::Separator => {},
    }
}

// would print something like this:
// 1. Chapter 1
// 1.1 Sub Chapter
// 1.2 Sub Chapter
// 2. Chapter 2
//
// etc.

pub fn init<P: Into<PathBuf>>(book_root: P) -> BookBuilder

init() gives you a BookBuilder which you can use to setup a new book and its accompanying directory structure.

The BookBuilder creates some boilerplate files and directories to get you started with your book.

book-test/
├── book
└── src
    ├── chapter_1.md
    └── SUMMARY.md

It uses the path provided as the root directory for your book, then adds in a src/ directory containing a SUMMARY.md and chapter_1.md file to get you started.

pub fn build(&self) -> Result<()>

Tells the renderer to build our book and put it in the build directory.

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn with_renderer<R: Renderer + 'static>(&mut self, renderer: R) -> &mut Self

You can change the default renderer to another one by using this method. The only requirement is for your renderer to implement the Renderer trait

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn with_preprecessor<P: Preprocessor + 'static>(
    &mut self,
    preprocessor: P
) -> &mut Self

Register a Preprocessor to be used when rendering the book.

pub fn test(&mut self, library_paths: Vec<&str>) -> Result<()>

Run rustdoc tests on the book, linking against the provided libraries.

pub fn build_dir_for(&self, backend_name: &str) -> PathBuf

The logic for determining where a backend should put its build artefacts.

If there is only 1 renderer, put it in the directory pointed to by the build.build_dir key in Config. If there is more than one then the renderer gets its own directory within the main build dir.

i.e. If there were only one renderer (in this case, the HTML renderer):

• build/
  • index.html
  • ...

Otherwise if there are multiple:

• build/
  • epub/
    • my_awesome_book.epub
  • html/
    • index.html
    • ...
  • latex/
    • my_awesome_book.tex

pub fn source_dir(&self) -> PathBuf

Get the directory containing this book's source files.

pub fn theme_dir(&self) -> PathBuf

Get the directory containing the theme resources for the book.

Trait Implementations