# What is rustdoc?

The standard Rust distribution ships with a tool called `rustdoc`. Its job is to generate documentation for Rust projects. On a fundamental level, Rustdoc takes as an argument either a crate root or a Markdown file, and produces HTML, CSS, and JavaScript.

## Basic usage

Let's give it a try! Let's create a new project with Cargo:

    $ cargo new docs
    $ cd docs

In `src/lib.rs`, you'll find that Cargo has generated some sample code. Delete it and replace it with this:

    #![allow(unused_variables)]
    fn main() {
    /// foo is a function
    fn foo() {}
    }

Let's run `rustdoc` on our code. To do so, we can call it with the path to our crate root like this:

    $ rustdoc src/lib.rs

This will create a new directory, `doc`, with a website inside! In our case, the main page is located in `doc/lib/index.html`. If you open that up in a web browser, you'll see a page with a search bar, and "Crate lib" at the top, with no contents. There's two problems with this: first, why does it think that our package is named "lib"? Second, why does it not have any contents?

The first problem is due to `rustdoc` trying to be helpful; like `rustc`, it assumes that our crate's name is the name of the file for the crate root. To fix this, we can pass in a command-line flag:

    $ rustdoc src/lib.rs --crate-name docs

Now, `doc/docs/index.html` will be generated, and the page says "Crate docs."

For the second issue, it's because our function `foo` is not public; `rustdoc` defaults to generating documentation for only public functions. If we change our code...

    #![allow(unused_variables)]
    fn main() {
    /// foo is a function
    pub fn foo() {}
    }

... and then re-run `rustdoc`:

    $ rustdoc src/lib.rs --crate-name docs

We'll have some generated documentation. Open up `doc/docs/index.html` and check it out! It should show a link to the `foo` function's page, which is located at `doc/docs/fn.foo.html`. On that page, you'll see the "foo is a function" we put inside the documentation comment in our crate.

## Using rustdoc with Cargo

Cargo also has integration with `rustdoc` to make it easier to generate docs. Instead of the `rustdoc` command, we could have done this:

    $ cargo doc

Internally, this calls out to `rustdoc` like this:

    $ rustdoc --crate-name docs srclib.rs -o <path>\docs\target\doc -L
    dependency=<path>docs\target\debug\deps

You can see this with `cargo doc --verbose`.

It generates the correct `--crate-name` for us, as well as pointing to `src/lib.rs` But what about those other arguments? `-o` controls the output of our docs. Instead of a top-level `doc` directory, you'll notice that Cargo puts generated documentation under `target`. That's the idiomatic place for generated files in Cargo projects. Also, it passes `-L`, a flag that helps rustdoc find the dependencies your code relies on. If our project used dependencies, we'd get documentation for them as well!

## Using standalone Markdown files

`rustdoc` can also generate HTML from standalone Markdown files. Let's give it a try: create a `README.md` file with these contents:

    # Docs

    This is a project to test out `rustdoc`.

    [Here is a link!](https://www.rust-lang.org)

    ## Subheading

    ```rust
    fn foo() -> i32 {
        1 + 1
    }
    ```

And call `rustdoc` on it:

    $ rustdoc README.md

You'll find an HTML file in `docs/doc/README.html` generated from its Markdown contents.

Cargo currently does not understand standalone Markdown files, unfortunately.

## Summary

This covers the simplest use-cases of `rustdoc`. The rest of this book will explain all of the options that `rustdoc` has, and how to use them.