Merge pull request #1661 from ehuss/bump-version

Update to 0.4.13

.github/workflows/main.yml

@@ -31,7 +31,7 @@ jobs:
             rust: stable
           - build: msrv
             os: ubuntu-latest
-            rust: 1.39.0
+            rust: 1.46.0
     steps:
     - uses: actions/checkout@master
     - name: Install Rust

CHANGELOG.md

@@ -1,5 +1,124 @@
 # Changelog
 
+## mdBook 0.4.13
+[e6629cd...f55028b](https://github.com/rust-lang/mdBook/compare/e6629cd...f55028b)
+
+### Added
+
+- Added the ability to specify the preprocessor order.
+  [#1607](https://github.com/rust-lang/mdBook/pull/1607)
+
+### Fixed
+
+- Include chapters with no headers in the search index
+  [#1637](https://github.com/rust-lang/mdBook/pull/1637)
+- Switched to the `opener` crate for opening a web browser, which should fix
+  some issues with blocking.
+  [#1656](https://github.com/rust-lang/mdBook/pull/1656)
+- Fixed clicking the border of the theme switcher breaking the theme selection.
+  [#1651](https://github.com/rust-lang/mdBook/pull/1651)
+
+## mdBook 0.4.12
+[14add9c...8b4e488](https://github.com/rust-lang/mdBook/compare/14add9c...8b4e488)
+
+### Changed
+- Reverted the change to update to highlight.js 11, as it broke hidden code lines.
+  [#1597](https://github.com/rust-lang/mdBook/pull/1621)
+ 
+## mdBook 0.4.11
+[e440094...2cf00d0](https://github.com/rust-lang/mdBook/compare/e440094...2cf00d0)
+
+### Added
+- Added support for Rust 2021 edition.
+  [#1596](https://github.com/rust-lang/mdBook/pull/1596)
+- Added `mdbook completions` subcommand which provides shell completions.
+  [#1425](https://github.com/rust-lang/mdBook/pull/1425)
+- Added `--title` and `--ignore` flags to `mdbook init` to avoid the
+  interactive input.
+  [#1559](https://github.com/rust-lang/mdBook/pull/1559)
+
+### Changed
+- If running a Rust example does not have any output, it now displays the text
+  "No output" instead of not showing anything.
+  [#1599](https://github.com/rust-lang/mdBook/pull/1599)
+- Code block language tags can now be separated by space or tab (along with
+  commas) to match the behavior of other sites like GitHub and rustdoc.
+  [#1469](https://github.com/rust-lang/mdBook/pull/1469)
+- Updated `warp` (the web server) to the latest version.
+  This also updates the minimum supported Rust version to 1.46.
+  [#1612](https://github.com/rust-lang/mdBook/pull/1612)
+- Updated to highlight.js 11. This has various highlighting improvements.
+  [#1597](https://github.com/rust-lang/mdBook/pull/1597)
+
+### Fixed
+- Inline code blocks inside a header are no longer highlighted when
+  `output.html.playground.editable` is `true`.
+  [#1613](https://github.com/rust-lang/mdBook/pull/1613)
+
+## mdBook 0.4.10
+[2f7293a...dc2062a](https://github.com/rust-lang/mdBook/compare/2f7293a...dc2062a)
+
+### Changed
+- Reverted breaking change in 0.4.9 that removed the `__non_exhaustive` marker
+  on the `Book` struct.
+  [#1572](https://github.com/rust-lang/mdBook/pull/1572)
+- Updated handlebars to 4.0.
+  [#1550](https://github.com/rust-lang/mdBook/pull/1550)
+- Removed the `chapter_begin` id on the print page's chapter separators.
+  [#1541](https://github.com/rust-lang/mdBook/pull/1541)
+
+## mdBook 0.4.9
+[7e01cf9...d325c60](https://github.com/rust-lang/mdBook/compare/7e01cf9...d325c60)
+
+### Changed
+- Updated all dependencies and raised the minimum Rust version to 1.42.
+  [#1528](https://github.com/rust-lang/mdBook/pull/1528)
+- Added more detail to error message when a preprocessor fails.
+  [#1526](https://github.com/rust-lang/mdBook/pull/1526)
+- Set max-width of HTML video tags to 100% to match img tags.
+  [#1542](https://github.com/rust-lang/mdBook/pull/1542)
+
+### Fixed
+- Type errors when parsing `book.toml` are no longer ignored.
+  [#1539](https://github.com/rust-lang/mdBook/pull/1539)
+- Better handling if `mdbook serve` fails to start the http server.
+  [#1555](https://github.com/rust-lang/mdBook/pull/1555)
+- Fixed the path for `edit-url-template` if the book used a source directory
+  other than `src`.
+  [#1554](https://github.com/rust-lang/mdBook/pull/1554)
+
+## mdBook 0.4.8
+[fcceee4...b592b10](https://github.com/rust-lang/mdBook/compare/fcceee4...b592b10)
+
+### Added
+- Added the option `output.html.edit-url-template` which can be a URL which is
+  linked on each page to direct the user to a site (such as GitHub) where the
+  user can directly suggest an edit for the page they are currently reading.
+  [#1506](https://github.com/rust-lang/mdBook/pull/1506)
+
+### Changed
+- Printed output now includes a page break between chapters.
+  [#1485](https://github.com/rust-lang/mdBook/pull/1485)
+
+### Fixed
+- HTML, such as HTML comments, is now ignored if it appears above the title line
+  in `SUMMARY.md`.
+  [#1437](https://github.com/rust-lang/mdBook/pull/1437)
+
+## mdBook 0.4.7
+[9a9eb01...c83bbd6](https://github.com/rust-lang/mdBook/compare/9a9eb01...c83bbd6)
+
+### Changed
+- Updated shlex parser to fix a minor parsing issue (used by the
+  preprocessor/backend custom command config).
+  [#1471](https://github.com/rust-lang/mdBook/pull/1471)
+- Enhanced text contrast of `light` theme to improve accessibility.
+  [#1470](https://github.com/rust-lang/mdBook/pull/1470)
+
+### Fixed
+- Fixed some issues with fragment scrolling and linking.
+  [#1463](https://github.com/rust-lang/mdBook/pull/1463)
+
 ## mdBook 0.4.6
 [eaa6914...1a0c296](https://github.com/rust-lang/mdBook/compare/eaa6914...1a0c296)
 

CODE_OF_CONDUCT.md

@@ -0,0 +1,3 @@
+# The Rust Code of Conduct
+
+The Code of Conduct for this repository [can be found online](https://www.rust-lang.org/conduct.html).

CONTRIBUTING.md

@@ -6,7 +6,6 @@ If you have come here to learn how to contribute to mdBook, we have some tips fo
 
 First of all, don't hesitate to ask questions!
 Use the [issue tracker](https://github.com/rust-lang/mdBook/issues), no question is too simple.
-If we don't respond in a couple of days, ping us @Michael-F-Bryan, @budziq, @steveklabnik, @frewsxcv it might just be that we forgot. :wink:
 
 ### Issues to work on
 
@@ -46,7 +45,7 @@ mdBook builds on stable Rust, if you want to build mdBook from source, here are
 0. Navigate into the newly created `mdBook` directory
 0. Run `cargo build`
 
-The resulting binary can be found in `mdBook/target/debug/` under the name `mdBook` or `mdBook.exe`.
+The resulting binary can be found in `mdBook/target/debug/` under the name `mdbook` or `mdbook.exe`.
 
 ### Code Quality
 
@@ -79,7 +78,7 @@ For more information, such as running it from your favourite editor, please see
 
 #### Finding Issues with Clippy
 
-Clippy is a code analyser/linter detecting mistakes, and therfore helps to improve your code.
+Clippy is a code analyser/linter detecting mistakes, and therefore helps to improve your code.
 Like formatting your code with `rustfmt`, running clippy regularly and before your Pull Request will
 help us maintain awesome code.
 
@@ -106,3 +105,26 @@ and [rustfmt](https://github.com/rust-lang/rustfmt) on the code first.
 This is not a requirement though and will never block a pull-request from being merged.
 
 That's it, happy contributions! :tada: :tada: :tada:
+
+## Browser compatibility and testing
+
+Currently we don't have a strict browser compatibility matrix due to our limited resources.
+We generally strive to keep mdBook compatible with a relatively recent browser on all of the most major platforms.
+That is, supporting Chrome, Safari, Firefox, Edge on Windows, macOS, Linux, iOS, and Android.
+If possible, do your best to avoid breaking older browser releases.
+
+Any change to the HTML or styling is encouraged to manually check on as many browsers and platforms that you can.
+Unfortunately at this time we don't have any automated UI or browser testing, so your assistance in testing is appreciated.
+
+## Updating higlight.js
+
+The following are instructions for updating [highlight.js](https://highlightjs.org/).
+
+1. Clone the repository at <https://github.com/highlightjs/highlight.js>
+1. Check out a tagged release (like `10.1.1`).
+1. Run `npm install`
+1. Run `node tools/build.js :common apache armasm coffeescript d handlebars haskell http julia nginx properties r scala x86asm yaml`
+1. Compare the language list that it spits out to the one in [`syntax-highlighting.md`](https://github.com/camelid/mdBook/blob/master/guide/src/format/theme/syntax-highlighting.md). If any are missing, add them to the list and rebuild (and update these docs). If any are added to the common set, add them to `syntax-highlighting.md`.
+1. Copy `build/highlight.min.js` to mdbook's directory [`highlight.js`](https://github.com/rust-lang/mdBook/blob/master/src/theme/highlight.js).
+1. Be sure to check the highlight.js [CHANGES](https://github.com/highlightjs/highlight.js/blob/main/CHANGES.md) for any breaking changes. Breaking changes that would affect users will need to wait until the next major release.
+1. Build mdbook with the new file and build some books with the new version and compare the output with a variety of languages to see if anything changes. (TODO: It would be nice to have a demo file in the repo to help with this.)

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mdbook"
-version = "0.4.6"
+version = "0.4.13"
 authors = [
     "Mathieu David <mathieudavid@mathieudavid.org>",
     "Michael-F-Bryan <michaelfbryan@gmail.com>",
@@ -20,19 +20,20 @@ anyhow = "1.0.28"
 chrono = "0.4"
 clap = "2.24"
 env_logger = "0.7.1"
-handlebars = "3.0"
+handlebars = "4.0"
 lazy_static = "1.0"
 log = "0.4"
 memchr = "2.0"
-open = "1.1"
+opener = "0.5"
 pulldown-cmark = "0.7.0"
 regex = "1.0.0"
 serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
-shlex = "0.1"
+shlex = "1"
 tempfile = "3.0"
 toml = "0.5.1"
+topological-sort = "0.1.0"
 
 # Watch feature
 notify = { version = "4.0", optional = true }
@@ -40,15 +41,18 @@ gitignore = { version = "1.0", optional = true }
 
 # Serve feature
 futures-util = { version = "0.3.4", optional = true }
-tokio = { version = "0.2.18", features = ["macros"], optional = true }
-warp = { version = "0.2.2", default-features = false, features = ["websocket"], optional = true }
+tokio = { version = "1", features = ["macros", "rt-multi-thread"], optional = true }
+warp = { version = "0.3.1", default-features = false, features = ["websocket"], optional = true }
 
 # Search feature
 elasticlunr-rs = { version = "2.3", optional = true, default-features = false }
 ammonia = { version = "3", optional = true }
 
 [dev-dependencies]
+assert_cmd = "1"
+predicates = "2"
 select = "0.5"
+semver = "0.11.0"
 pretty_assertions = "0.6"
 walkdir = "2.0"
 

README.md

@@ -163,6 +163,7 @@ of a book in order to validate links or run tests. Some existing renderers are:
   preprocessors.
 - [`linkcheck`] - a backend which will check that all links are valid
 - [`epub`] - an experimental EPUB generator
+- [`man`] - a backend that generates manual pages from the book
 
 > **Note for Developers:** Feel free to send us a PR if you've developed your
 > own plugin and want it mentioned here.
@@ -234,3 +235,4 @@ All the code in this repository is released under the ***Mozilla Public License
 [master-docs]: http://rust-lang.github.io/mdBook/
 [`linkcheck`]: https://crates.io/crates/mdbook-linkcheck
 [`epub`]: https://crates.io/crates/mdbook-epub
+[`man`]: https://crates.io/crates/mdbook-man

examples/nop-preprocessor.rs

@@ -3,6 +3,7 @@ use clap::{App, Arg, ArgMatches, SubCommand};
 use mdbook::book::Book;
 use mdbook::errors::Error;
 use mdbook::preprocess::{CmdPreprocessor, Preprocessor, PreprocessorContext};
+use semver::{Version, VersionReq};
 use std::io;
 use std::process;
 
@@ -33,9 +34,10 @@ fn main() {
 fn handle_preprocessing(pre: &dyn Preprocessor) -> Result<(), Error> {
     let (ctx, book) = CmdPreprocessor::parse_input(io::stdin())?;
 
-    if ctx.mdbook_version != mdbook::MDBOOK_VERSION {
-        // We should probably use the `semver` crate to check compatibility
-        // here...
+    let book_version = Version::parse(&ctx.mdbook_version)?;
+    let version_req = VersionReq::parse(mdbook::MDBOOK_VERSION)?;
+
+    if !version_req.matches(&book_version) {
         eprintln!(
             "Warning: The {} plugin was built against version {} of mdbook, \
              but we're being called from version {}",
@@ -53,7 +55,7 @@ fn handle_preprocessing(pre: &dyn Preprocessor) -> Result<(), Error> {
 
 fn handle_supports(pre: &dyn Preprocessor, sub_args: &ArgMatches) -> ! {
     let renderer = sub_args.value_of("renderer").expect("Required argument");
-    let supported = pre.supports_renderer(&renderer);
+    let supported = pre.supports_renderer(renderer);
 
     // Signal whether the renderer is supported by exiting with 1 or 0.
     if supported {

guide/book.toml

@@ -10,6 +10,8 @@ edition = "2018"
 [output.html]
 mathjax-support = true
 site-url = "/mdBook/"
+git-repository-url = "https://github.com/rust-lang/mdBook/tree/master/guide"
+edit-url-template = "https://github.com/rust-lang/mdBook/edit/master/guide/{path}"
 
 [output.html.playground]
 editable = true
@@ -23,3 +25,6 @@ boost-hierarchy = 2
 boost-paragraph = 1
 expand = true
 heading-split-level = 2
+
+[output.html.redirect]
+"/format/config.html" = "configuration/index.html"

guide/src/README.md

@@ -1,25 +1,40 @@
-# mdBook
+# Introduction
 
-**mdBook** is a command line tool and Rust crate to create books using Markdown
-(as by the [CommonMark](https://commonmark.org/) specification) files. It's very
-similar to Gitbook but written in [Rust](http://www.rust-lang.org).
+**mdBook** is a command line tool and Rust crate to create books with Markdown. The output resembles tools like Gitbook,
+and is ideal for creating product or API documentation, tutorials, course materials or anything that requires a clean,
+easily navigable and customizable presentation. mdBook is written in [Rust](https://www.rust-lang.org); its performance
+and simplicity made it ideal for use as a tool to publish directly to hosted websites such
+as [GitHub Pages](https://pages.github.com) via automation. This guide, in fact, serves as both the mdBook documentation
+and a fine example of what mdBook produces.
 
-What you are reading serves as an example of the output of mdBook and at the
-same time as a high-level documentation.
+mdBook includes built in support for both preprocessing your Markdown and alternative renderers for producing formats
+other than HTML. These facilities also enable other functionality such as
+validation. [Searching](https://crates.io/search?q=mdbook&sort=relevance) Rust's [crates.io](https://crates.io) is a
+great way to discover more extensions.
 
-mdBook is free and open source, you can find the source code on
-[GitHub](https://github.com/rust-lang/mdBook). Issues and feature
-requests can be posted on the [GitHub issue
-tracker](https://github.com/rust-lang/mdBook/issues).
+## API Documentation
 
-## API docs
+In addition to the above features, mdBook also has a Rust [API](https://docs.rs/mdbook/*/mdbook/). This allows you to
+write your own preprocessor or renderer, as well as incorporate mdBook features into other applications.
+The [For Developers](for_developers) section of this guide contains more information and some examples.
 
-Alongside this book you can also read the [API
-docs](https://docs.rs/mdbook/*/mdbook/) generated by Rustdoc if you would like
-to use mdBook as a crate or write a new renderer and need a more low-level
-overview.
+## Markdown
+
+mdBook's [parser](https://github.com/raphlinus/pulldown-cmark) adheres to the [CommonMark](https://commonmark.org/)
+specification. You can take a quick [tutorial](https://commonmark.org/help/tutorial/),
+or [try out](https://spec.commonmark.org/dingus/) CommonMark in real time. For a more in-depth experience, check out the
+[Markdown Guide](https://www.markdownguide.org).
+
+## Contributing
+
+mdBook is free and open source. You can find the source code on
+[GitHub](https://github.com/rust-lang/mdBook) and issues and feature requests can be posted on
+the [GitHub issue tracker](https://github.com/rust-lang/mdBook/issues). mdBook relies on the community to fix bugs and
+add features: if you'd like to contribute, please read
+the [CONTRIBUTING](https://github.com/rust-lang/mdBook/blob/master/CONTRIBUTING.md) guide and consider opening
+a [pull request](https://github.com/rust-lang/mdBook/pulls).
 
 ## License
 
-mdBook, all the source code, is released under the [Mozilla Public License
-v2.0](https://www.mozilla.org/MPL/2.0/).
+The mdBook source and documentation are released under
+the [Mozilla Public License v2.0](https://www.mozilla.org/MPL/2.0/).

guide/src/SUMMARY.md

@@ -1,6 +1,6 @@
 # Summary
 
-- [mdBook](README.md)
+- [Introduction](README.md)
 - [Command Line Tool](cli/README.md)
     - [init](cli/init.md)
     - [build](cli/build.md)
@@ -11,7 +11,11 @@
 - [Format](format/README.md)
     - [SUMMARY.md](format/summary.md)
         - [Draft chapter]()
-    - [Configuration](format/config.md)
+    - [Configuration](format/configuration/README.md)
+        - [General](format/configuration/general.md)
+        - [Preprocessors](format/configuration/preprocessors.md)
+        - [Renderers](format/configuration/renderers.md)
+        - [Environment Variables](format/configuration/environment-variables.md)
     - [Theme](format/theme/README.md)
         - [index.hbs](format/theme/index-hbs.md)
         - [Syntax highlighting](format/theme/syntax-highlighting.md)

guide/src/cli/README.md

@@ -12,7 +12,7 @@ to download the appropriate version for your platform.
 
 ## Install From Source
 
-mdBook can also be installed from source
+mdBook can also be installed by compiling the source code on your local machine.
 
 ### Pre-requisite
 

guide/src/cli/build.md

@@ -7,7 +7,8 @@ mdbook build
 ```
 
 It will try to parse your `SUMMARY.md` file to understand the structure of your
-book and fetch the corresponding files.
+book and fetch the corresponding files. Note that files mentioned in `SUMMARY.md`
+but not present will be created.
 
 The rendered output will maintain the same directory structure as the source for
 convenience. Large books will therefore remain structured when rendered.

guide/src/cli/init.md

@@ -25,9 +25,9 @@ book-test/
 - The `book` directory is where your book is rendered. All the output is ready
   to be uploaded to a server to be seen by your audience.
 
-- The `SUMMARY.md` file is the most important file, it's the skeleton of your
-  book and is discussed in more detail [in another
-  chapter](../format/summary.md)
+- The `SUMMARY.md` is the skeleton of your
+  book, and is discussed in more detail [in another
+  chapter](../format/summary.md).
 
 #### Tip: Generate chapters from SUMMARY.md
 
@@ -52,3 +52,19 @@ directory called `theme` in your source directory so that you can modify it.
 
 The theme is selectively overwritten, this means that if you don't want to
 overwrite a specific file, just delete it and the default file will be used.
+
+#### --title
+
+Specify a title for the book. If not supplied, an interactive prompt will ask for 
+a title. 
+
+```bash
+mdbook init --title="my amazing book"
+```
+
+#### --ignore
+
+Create a `.gitignore` file configured to ignore the `book` directory created when [building] a book. 
+If not supplied, an interactive prompt will ask whether it should be created.
+
+[building]: build.md

guide/src/cli/serve.md

@@ -1,8 +1,15 @@
 # The serve command
 
-The serve command is used to preview a book by serving it over HTTP at
-`localhost:3000` by default. Additionally it watches the book's directory for
-changes, rebuilding the book and refreshing clients for each change. A websocket
+The serve command is used to preview a book by serving it via HTTP at
+`localhost:3000` by default: 
+
+```bash
+mdbook serve
+```
+
+The `serve` command  watches the book's `src` directory for
+changes, rebuilding the book and refreshing clients for each change; this includes
+re-creating deleted files still mentioned in `SUMMARY.md`! A websocket
 connection is used to trigger the client-side refresh.
 
 ***Note:*** *The `serve` command is for testing a book's HTML output, and is not
@@ -17,24 +24,14 @@ root instead of the current working directory.
 mdbook serve path/to/book
 ```
 
-#### Server options
+### Server options
 
-`serve` has four options: the HTTP port, the WebSocket port, the HTTP hostname
-to listen on, and the hostname for the browser to connect to for WebSockets.
-
-For example: suppose you have an nginx server for SSL termination which has a
-public address of 192.168.1.100 on port 80 and proxied that to 127.0.0.1 on port
-8000\. To run use the nginx proxy do:
+The `serve` hostname defaults to `localhost`, and the port defaults to `3000`. Either option can be specified on the command line:
 
 ```bash
-mdbook serve path/to/book -p 8000 -n 127.0.0.1 --websocket-hostname 192.168.1.100
+mdbook serve path/to/book -p 8000 -n 127.0.0.1 
 ```
 
-If you were to want live reloading for this you would need to proxy the
-websocket calls through nginx as well from `192.168.1.100:<WS_PORT>` to
-`127.0.0.1:<WS_PORT>`. The `-w` flag allows for the websocket port to be
-configured.
-
 #### --open
 
 When you use the `--open` (`-o`) flag, mdbook will open the book in your
@@ -55,5 +52,5 @@ contain file patterns described in the [gitignore
 documentation](https://git-scm.com/docs/gitignore). This can be useful for
 ignoring temporary files created by some editors.
 
-_Note: Only `.gitignore` from book root directory is used. Global
-`$HOME/.gitignore` or `.gitignore` files in parent directories are not used._
+***Note:*** *Only the `.gitignore` from the book root directory is used. Global
+`$HOME/.gitignore` or `.gitignore` files in parent directories are not used.*

guide/src/cli/test.md

@@ -43,7 +43,17 @@ mdbook test path/to/book
 The `--library-path` (`-L`) option allows you to add directories to the library
 search path used by `rustdoc` when it builds and tests the examples. Multiple
 directories can be specified with multiple options (`-L foo -L bar`) or with a
-comma-delimited list (`-L foo,bar`).
+comma-delimited list (`-L foo,bar`). The path should point to the Cargo 
+[build cache](https://doc.rust-lang.org/cargo/guide/build-cache.html) `deps` directory that
+contains the build output of your project. For example, if your Rust project's book is in a directory
+named `my-book`, the following command would include the crate's dependencies when running `test`:
+
+```shell
+mdbook test my-book -L target/debug/deps/
+```
+
+See the `rustdoc` command-line [documentation](https://doc.rust-lang.org/rustdoc/command-line-arguments.html#-l--library-path-where-to-look-for-dependencies)
+for more information.
 
 #### --dest-dir
 

guide/src/cli/watch.md

@@ -3,7 +3,8 @@
 The `watch` command is useful when you want your book to be rendered on every
 file change. You could repeatedly issue `mdbook build` every time a file is
 changed. But using `mdbook watch` once will watch your files and will trigger a
-build automatically whenever you modify a file.
+build automatically whenever you modify a file; this includes re-creating
+deleted files still mentioned in `SUMMARY.md`!
 
 #### Specify a directory
 

guide/src/continuous-integration.md

@@ -26,7 +26,7 @@ before_script:
   - cargo install-update -a
 
 script:
-  - mdbook build path/to/mybook && mdbook test path/to/mybook
+  - mdbook build && mdbook test # In case of custom book path: mdbook build path/to/mybook && mdbook test path/to/mybook
 ```
 
 ## Deploying Your Book to GitHub Pages
@@ -50,10 +50,10 @@ deploy:
   provider: pages
   skip-cleanup: true
   github-token: $GITHUB_TOKEN
-  local-dir: path/to/mybook/book
+  local-dir: book # In case of custom book path: path/to/mybook/book
   keep-history: false
   on:
-    branch: master
+    branch: main
 ```
 
 That's it!
@@ -77,7 +77,7 @@ before_script:
   - cargo install-update -a
 
 script:
-  - mdbook build path/to/mybook && mdbook test path/to/mybook
+  - mdbook build && mdbook test # In case of custom book path: mdbook build path/to/mybook && mdbook test path/to/mybook
   
 deploy:
   provider: pages
@@ -85,10 +85,10 @@ deploy:
   edge: true
   cleanup: false
   github-token: $GITHUB_TOKEN
-  local-dir: path/to/mybook/book
+  local-dir: book # In case of custom book path: path/to/mybook/book
   keep-history: false
   on:
-    branch: master
+    branch: main
   target_branch: gh-pages
 ```
 
@@ -133,22 +133,22 @@ stages:
 
 pages:
   stage: deploy
-  image: rust:alpine
+  image: rust
   variables:
     CARGO_HOME: $CI_PROJECT_DIR/cargo
   before_script:
     - export PATH="$PATH:$CARGO_HOME/bin"
     - mdbook --version || cargo install mdbook
   script:
-        - mdbook build -d public
-  only:
-      - master 
+    - mdbook build -d public
+  rules:
+    - if: '$CI_COMMIT_REF_NAME == "master"'
   artifacts:
-      paths:
-          - public
+    paths:
+      - public
   cache:
     paths:
-    - $CARGO_HOME/bin
+      - $CARGO_HOME/bin
 ```
 
 After you commit and push this new file, GitLab CI will run and your book will be available!

guide/src/for_developers/backends.md

@@ -13,6 +13,7 @@ rough example of how this is accomplished in practice.
 - [mdbook-epub] - an EPUB renderer
 - [mdbook-test] - a program to run the book's contents through [rust-skeptic] to
   verify everything compiles and runs correctly (similar to `rustdoc --test`)
+- [mdbook-man] - generate manual pages from the book
 
 This page will step you through creating your own alternative backend in the form
 of a simple word counting program. Although it will be written in Rust, there's
@@ -377,6 +378,7 @@ the source code or ask questions.
 [mdbook-linkcheck]: https://github.com/Michael-F-Bryan/mdbook-linkcheck
 [mdbook-epub]: https://github.com/Michael-F-Bryan/mdbook-epub
 [mdbook-test]: https://github.com/Michael-F-Bryan/mdbook-test
+[mdbook-man]: https://github.com/vv9k/mdbook-man
 [rust-skeptic]: https://github.com/budziq/rust-skeptic
 [`RenderContext`]: https://docs.rs/mdbook/*/mdbook/renderer/struct.RenderContext.html
 [`RenderContext::from_json()`]: https://docs.rs/mdbook/*/mdbook/renderer/struct.RenderContext.html#method.from_json

guide/src/for_developers/preprocessors.md

@@ -18,9 +18,9 @@ A new table is added to `book.toml` (e.g. `preprocessor.foo` for the `foo`
 preprocessor) and then `mdbook` will try to invoke the `mdbook-foo` program as
 part of the build process.
 
-While preprocessors can be hard-coded to specify which backend it should be run
-for (e.g. it doesn't make sense for MathJax to be used for non-HTML renderers)
-with the `preprocessor.foo.renderer` key.
+A preprocessor can be hard-coded to specify which backend(s) it should be run
+for with the `preprocessor.foo.renderer` key. For example, it doesn't make sense for 
+[MathJax](../format/mathjax.md) to be used for non-HTML renderers.
 
 ```toml
 [book]
@@ -34,8 +34,15 @@ command = "python3 /path/to/foo.py"
 renderer = ["html", "epub"]
 ```
 
-In typical unix style, all inputs to the plugin will be written to `stdin` as
-JSON and `mdbook` will read from `stdout` if it is expecting output.
+Once the preprocessor has been defined and the build process starts, mdBook executes the command defined in the `preprocessor.foo.command` key twice.
+The first time it runs the preprocessor to determine if it supports the given renderer.
+mdBook passes two arguments to the process: the first argument is the string `supports` and the second argument is the renderer name.
+The preprocessor should exit with a status code 0 if it supports the given renderer, or return a non-zero exit code if it does not.
+
+If the preprocessor supports the renderer, then mdbook runs it a second time, passing JSON data into stdin.
+The JSON consists of an array of `[context, book]` where `context` is the serialized object [`PreprocessorContext`] and `book` is a [`Book`] object containing the content of the book.
+
+The preprocessor should return the JSON format of the [`Book`] object to stdout, with any modifications it wishes to perform.
 
 The easiest way to get started is by creating your own implementation of the
 `Preprocessor` trait (e.g. in `lib.rs`) and then creating a shell binary which
@@ -106,6 +113,33 @@ fn remove_emphasis(
 
 For everything else, have a look [at the complete example][example].
 
+## Implementing a preprocessor with a different language
+
+The fact that mdBook utilizes stdin and stdout to communicate with the preprocessors makes it easy to implement them in a language other than Rust.
+The following code shows how to implement a simple preprocessor in Python, which will modify the content of the first chapter.
+The example below follows the configuration shown above with `preprocessor.foo.command` actually pointing to a Python script.
+
+```python
+import json
+import sys
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1: # we check if we received any argument
+        if sys.argv[1] == "supports": 
+            # then we are good to return an exit status code of 0, since the other argument will just be the renderer's name
+            sys.exit(0)
+
+    # load both the context and the book representations from stdin
+    context, book = json.load(sys.stdin)
+    # and now, we can just modify the content of the first chapter
+    book['sections'][0]['Chapter']['content'] = '# Hello'
+    # we are done with the book's modification, we can just print it to stdout, 
+    print(json.dumps(book))
+```
+
+
+
 [preprocessor-docs]: https://docs.rs/mdbook/latest/mdbook/preprocess/trait.Preprocessor.html
 [pc]: https://crates.io/crates/pulldown-cmark
 [pctc]: https://crates.io/crates/pulldown-cmark-to-cmark
@@ -113,3 +147,5 @@ For everything else, have a look [at the complete example][example].
 [an example no-op preprocessor]: https://github.com/rust-lang/mdBook/blob/master/examples/nop-preprocessor.rs
 [`CmdPreprocessor::parse_input()`]: https://docs.rs/mdbook/latest/mdbook/preprocess/trait.Preprocessor.html#method.parse_input
 [`Book::for_each_mut()`]: https://docs.rs/mdbook/latest/mdbook/book/struct.Book.html#method.for_each_mut
+[`PreprocessorContext`]: https://docs.rs/mdbook/latest/mdbook/preprocess/struct.PreprocessorContext.html
+[`Book`]: https://docs.rs/mdbook/latest/mdbook/book/struct.Book.html

guide/src/format/configuration/README.md

@@ -0,0 +1,12 @@
+# Configuration
+
+This section details the configuration options available in the ***book.toml***:
+- **[General]** configuration including the `book`, `rust`, `build` sections
+- **[Preprocessor]** configuration for default and custom book preprocessors
+- **[Renderer]** configuration for the HTML, Markdown and custom renderers
+- **[Environment Variable]** configuration for overriding configuration options in your environment
+
+[General]: general.md
+[Preprocessor]: preprocessors.md
+[Renderer]: renderers.md
+[Environment Variable]: environment-variables.md

guide/src/format/configuration/environment-variables.md

@@ -0,0 +1,38 @@
+# Environment Variables
+
+All configuration values can be overridden from the command line by setting the
+corresponding environment variable. Because many operating systems restrict
+environment variables to be alphanumeric characters or `_`, the configuration
+key needs to be formatted slightly differently to the normal `foo.bar.baz` form.
+
+Variables starting with `MDBOOK_` are used for configuration. The key is created
+by removing the `MDBOOK_` prefix and turning the resulting string into
+`kebab-case`. Double underscores (`__`) separate nested keys, while a single
+underscore (`_`) is replaced with a dash (`-`).
+
+For example:
+
+- `MDBOOK_foo` -> `foo`
+- `MDBOOK_FOO` -> `foo`
+- `MDBOOK_FOO__BAR` -> `foo.bar`
+- `MDBOOK_FOO_BAR` -> `foo-bar`
+- `MDBOOK_FOO_bar__baz` -> `foo-bar.baz`
+
+So by setting the `MDBOOK_BOOK__TITLE` environment variable you can override the
+book's title without needing to touch your `book.toml`.
+
+> **Note:** To facilitate setting more complex config items, the value of an
+> environment variable is first parsed as JSON, falling back to a string if the
+> parse fails.
+>
+> This means, if you so desired, you could override all book metadata when
+> building the book with something like
+>
+> ```shell
+> $ export MDBOOK_BOOK="{'title': 'My Awesome Book', authors: ['Michael-F-Bryan']}"
+> $ mdbook build
+> ```
+
+The latter case may be useful in situations where `mdbook` is invoked from a
+script or CI, where it sometimes isn't possible to update the `book.toml` before
+building.

guide/src/format/configuration/general.md

@@ -0,0 +1,97 @@
+# General Configuration
+
+You can configure the parameters for your book in the ***book.toml*** file.
+
+Here is an example of what a ***book.toml*** file might look like:
+
+```toml
+[book]
+title = "Example book"
+author = "John Doe"
+description = "The example book covers examples."
+
+[rust]
+edition = "2018"
+
+[build]
+build-dir = "my-example-book"
+create-missing = false
+
+[preprocessor.index]
+
+[preprocessor.links]
+
+[output.html]
+additional-css = ["custom.css"]
+
+[output.html.search]
+limit-results = 15
+```
+
+## Supported configuration options
+
+It is important to note that **any** relative path specified in the
+configuration will always be taken relative from the root of the book where the
+configuration file is located.
+
+### General metadata
+
+This is general information about your book.
+
+- **title:** The title of the book
+- **authors:** The author(s) of the book
+- **description:** A description for the book, which is added as meta
+  information in the html `<head>` of each page
+- **src:** By default, the source directory is found in the directory named
+  `src` directly under the root folder. But this is configurable with the `src`
+  key in the configuration file.
+- **language:** The main language of the book, which is used as a language attribute `<html lang="en">` for example.
+
+**book.toml**
+```toml
+[book]
+title = "Example book"
+authors = ["John Doe", "Jane Doe"]
+description = "The example book covers examples."
+src = "my-src"  # the source files will be found in `root/my-src` instead of `root/src`
+language = "en"
+```
+
+### Rust options
+
+Options for the Rust language, relevant to running tests and playground
+integration.
+
+- **edition**: Rust edition to use by default for the code snippets. Default
+  is "2015". Individual code blocks can be controlled with the `edition2015`, 
+  `edition2018` or `edition2021` annotations, such as:
+
+  ~~~text
+  ```rust,edition2015
+  // This only works in 2015.
+  let try = true;
+  ```
+  ~~~
+
+### Build options
+
+This controls the build process of your book.
+
+- **build-dir:** The directory to put the rendered book in. By default this is
+  `book/` in the book's root directory.
+- **create-missing:** By default, any missing files specified in `SUMMARY.md`
+  will be created when the book is built (i.e. `create-missing = true`). If this
+  is `false` then the build process will instead exit with an error if any files
+  do not exist.
+- **use-default-preprocessors:** Disable the default preprocessors of (`links` &
+  `index`) by setting this option to `false`.
+
+  If you have the same, and/or other preprocessors declared via their table
+  of configuration, they will run instead.
+
+  - For clarity, with no preprocessor configuration, the default `links` and
+    `index` will run.
+  - Setting `use-default-preprocessors = false` will disable these
+    default preprocessors from running.
+  - Adding `[preprocessor.links]`, for example, will ensure, regardless of
+    `use-default-preprocessors` that `links` it will run.

guide/src/format/configuration/preprocessors.md

@@ -0,0 +1,80 @@
+# Configuring Preprocessors
+
+The following preprocessors are available and included by default:
+
+- `links`: Expand the `{{ #playground }}`, `{{ #include }}`, and `{{ #rustdoc_include }}` handlebars
+  helpers in a chapter to include the contents of a file.
+- `index`: Convert all chapter files named `README.md` into `index.md`. That is
+  to say, all `README.md` would be rendered to an index file `index.html` in the
+  rendered book.
+
+
+**book.toml**
+```toml
+[build]
+build-dir = "build"
+create-missing = false
+
+[preprocessor.links]
+
+[preprocessor.index]
+```
+
+### Custom Preprocessor Configuration
+
+Like renderers, preprocessor will need to be given its own table (e.g.
+`[preprocessor.mathjax]`). In the section, you may then pass extra
+configuration to the preprocessor by adding key-value pairs to the table.
+
+For example
+
+```toml
+[preprocessor.links]
+# set the renderers this preprocessor will run for
+renderers = ["html"]
+some_extra_feature = true
+```
+
+#### Locking a Preprocessor dependency to a renderer
+
+You can explicitly specify that a preprocessor should run for a renderer by
+binding the two together.
+
+```toml
+[preprocessor.mathjax]
+renderers = ["html"]  # mathjax only makes sense with the HTML renderer
+```
+
+### Provide Your Own Command
+
+By default when you add a `[preprocessor.foo]` table to your `book.toml` file,
+`mdbook` will try to invoke the `mdbook-foo` executable. If you want to use a
+different program name or pass in command-line arguments, this behaviour can
+be overridden by adding a `command` field.
+
+```toml
+[preprocessor.random]
+command = "python random.py"
+```
+
+### Require A Certain Order
+
+The order in which preprocessors are run can be controlled with the `before` and `after` fields.
+For example, suppose you want your `linenos` preprocessor to process lines that may have been `{{#include}}`d; then you want it to run after the built-in `links` preprocessor, which you can require using either the `before` or `after` field:
+
+```toml
+[preprocessor.linenos]
+after = [ "links" ]
+```
+
+or
+
+```toml
+[preprocessor.links]
+before = [ "linenos" ]
+```
+
+It would also be possible, though redundant, to specify both of the above in the same config file.
+
+Preprocessors having the same priority specified through `before` and `after` are sorted by name.
+Any infinite loops will be detected and produce an error.

guide/src/format/configuration/renderers.md

@@ -1,161 +1,4 @@
-# Configuration
-
-You can configure the parameters for your book in the ***book.toml*** file.
-
-Here is an example of what a ***book.toml*** file might look like:
-
-```toml
-[book]
-title = "Example book"
-author = "John Doe"
-description = "The example book covers examples."
-
-[rust]
-edition = "2018"
-
-[build]
-build-dir = "my-example-book"
-create-missing = false
-
-[preprocessor.index]
-
-[preprocessor.links]
-
-[output.html]
-additional-css = ["custom.css"]
-
-[output.html.search]
-limit-results = 15
-```
-
-## Supported configuration options
-
-It is important to note that **any** relative path specified in the
-configuration will always be taken relative from the root of the book where the
-configuration file is located.
-
-### General metadata
-
-This is general information about your book.
-
-- **title:** The title of the book
-- **authors:** The author(s) of the book
-- **description:** A description for the book, which is added as meta
-  information in the html `<head>` of each page
-- **src:** By default, the source directory is found in the directory named
-  `src` directly under the root folder. But this is configurable with the `src`
-  key in the configuration file.
-- **language:** The main language of the book, which is used as a language attribute `<html lang="en">` for example.
-
-**book.toml**
-```toml
-[book]
-title = "Example book"
-authors = ["John Doe", "Jane Doe"]
-description = "The example book covers examples."
-src = "my-src"  # the source files will be found in `root/my-src` instead of `root/src`
-language = "en"
-```
-
-### Rust options
-
-Options for the Rust language, relevant to running tests and playground
-integration.
-
-- **edition**: Rust edition to use by default for the code snippets. Default
-  is "2015". Individual code blocks can be controlled with the `edition2015`
-  or `edition2018` annotations, such as:
-
-  ~~~text
-  ```rust,edition2015
-  // This only works in 2015.
-  let try = true;
-  ```
-  ~~~
-
-### Build options
-
-This controls the build process of your book.
-
-- **build-dir:** The directory to put the rendered book in. By default this is
-  `book/` in the book's root directory.
-- **create-missing:** By default, any missing files specified in `SUMMARY.md`
-  will be created when the book is built (i.e. `create-missing = true`). If this
-  is `false` then the build process will instead exit with an error if any files
-  do not exist.
-- **use-default-preprocessors:** Disable the default preprocessors of (`links` &
-  `index`) by setting this option to `false`.
-
-  If you have the same, and/or other preprocessors declared via their table
-  of configuration, they will run instead.
-
-  - For clarity, with no preprocessor configuration, the default `links` and
-    `index` will run.
-  - Setting `use-default-preprocessors = false` will disable these
-    default preprocessors from running.
-  - Adding `[preprocessor.links]`, for example, will ensure, regardless of
-    `use-default-preprocessors` that `links` it will run.
-
-## Configuring Preprocessors
-
-The following preprocessors are available and included by default:
-
-- `links`: Expand the `{{ #playground }}`, `{{ #include }}`, and `{{ #rustdoc_include }}` handlebars
-  helpers in a chapter to include the contents of a file.
-- `index`: Convert all chapter files named `README.md` into `index.md`. That is
-  to say, all `README.md` would be rendered to an index file `index.html` in the
-  rendered book.
-
-
-**book.toml**
-```toml
-[build]
-build-dir = "build"
-create-missing = false
-
-[preprocessor.links]
-
-[preprocessor.index]
-```
-
-### Custom Preprocessor Configuration
-
-Like renderers, preprocessor will need to be given its own table (e.g.
-`[preprocessor.mathjax]`). In the section, you may then pass extra
-configuration to the preprocessor by adding key-value pairs to the table.
-
-For example
-
-```toml
-[preprocessor.links]
-# set the renderers this preprocessor will run for
-renderers = ["html"]
-some_extra_feature = true
-```
-
-#### Locking a Preprocessor dependency to a renderer
-
-You can explicitly specify that a preprocessor should run for a renderer by
-binding the two together.
-
-```toml
-[preprocessor.mathjax]
-renderers = ["html"]  # mathjax only makes sense with the HTML renderer
-```
-
-### Provide Your Own Command
-
-By default when you add a `[preprocessor.foo]` table to your `book.toml` file,
-`mdbook` will try to invoke the `mdbook-foo` executable. If you want to use a
-different program name or pass in command-line arguments, this behaviour can
-be overridden by adding a `command` field.
-
-```toml
-[preprocessor.random]
-command = "python random.py"
-```
-
-## Configuring Renderers
+# Configuring Renderers
 
 ### HTML renderer options
 
@@ -175,7 +18,7 @@ The following configuration options are available:
   CSS media query. Defaults to `navy`.
 - **curly-quotes:** Convert straight quotes to curly quotes, except for those
   that occur in code blocks and code spans. Defaults to `false`.
-- **mathjax-support:** Adds support for [MathJax](mathjax.md). Defaults to
+- **mathjax-support:** Adds support for [MathJax](../mathjax.md). Defaults to
   `false`.
 - **copy-fonts:** Copies fonts.css and respective font files to the output directory and use them in the default theme. Defaults to `true`.
 - **google-analytics:** If you use Google Analytics, this option lets you enable
@@ -201,13 +44,21 @@ The following configuration options are available:
   an icon link will be output in the menu bar of the book.
 - **git-repository-icon:** The FontAwesome icon class to use for the git
   repository link. Defaults to `fa-github`.
+- **edit-url-template:** Edit url template, when provided shows a
+  "Suggest an edit" button for directly jumping to editing the currently
+  viewed page. For e.g. GitHub projects set this to
+  `https://github.com/<owner>/<repo>/edit/master/{path}` or for
+  Bitbucket projects set it to
+  `https://bitbucket.org/<owner>/<repo>/src/master/{path}?mode=edit`
+  where {path} will be replaced with the full path of the file in the
+  repository.
 - **redirect:** A subtable used for generating redirects when a page is moved.
   The table contains key-value pairs where the key is where the redirect file
   needs to be created, as an absolute path from the build directory, (e.g.
   `/appendices/bibliography.html`). The value can be any valid URI the
   browser should navigate to (e.g. `https://rust-lang.org/`,
   `/overview.html`, or `../bibliography.html`).
-- **input-404:** The name of the markdown file used for misssing files.
+- **input-404:** The name of the markdown file used for missing files.
   The corresponding output file will be the same, with the extension replaced with `html`.
   Defaults to `404.md`.
 - **site-url:** The url where the book will be hosted. This is required to ensure
@@ -286,6 +137,7 @@ additional-js = ["custom.js"]
 no-section-label = false
 git-repository-url = "https://github.com/rust-lang/mdBook"
 git-repository-icon = "fa-github"
+edit-url-template = "https://github.com/rust-lang/mdBook/edit/master/guide/{path}"
 site-url = "/example-book/"
 cname = "myproject.rs"
 input-404 = "not-found.md"
@@ -336,13 +188,13 @@ Enable it by adding an empty table to your `book.toml` as follows:
 There are no configuration options for the Markdown renderer at this time;
 only whether it is enabled or disabled.
 
-See [the preprocessors documentation](#configuring-preprocessors) for how to
+See [the preprocessors documentation](preprocessors.md) for how to
 specify which preprocessors should run before the Markdown renderer.
 
 ### Custom Renderers
 
 A custom renderer can be enabled by adding a `[output.foo]` table to your
-`book.toml`. Similar to [preprocessors](#configuring-preprocessors) this will
+`book.toml`. Similar to [preprocessors](preprocessors.md) this will
 instruct `mdbook` to pass a representation of the book to `mdbook-foo` for
 rendering. See the [alternative backends] chapter for more detail.
 
@@ -354,43 +206,4 @@ anything under `[output.foo]`). mdBook checks for two common fields:
 - **optional:** If `true`, then the command will be ignored if it is not
   installed, otherwise mdBook will fail with an error. Defaults to `false`.
 
-[alternative backends]: ../for_developers/backends.md
-
-## Environment Variables
-
-All configuration values can be overridden from the command line by setting the
-corresponding environment variable. Because many operating systems restrict
-environment variables to be alphanumeric characters or `_`, the configuration
-key needs to be formatted slightly differently to the normal `foo.bar.baz` form.
-
-Variables starting with `MDBOOK_` are used for configuration. The key is created
-by removing the `MDBOOK_` prefix and turning the resulting string into
-`kebab-case`. Double underscores (`__`) separate nested keys, while a single
-underscore (`_`) is replaced with a dash (`-`).
-
-For example:
-
-- `MDBOOK_foo` -> `foo`
-- `MDBOOK_FOO` -> `foo`
-- `MDBOOK_FOO__BAR` -> `foo.bar`
-- `MDBOOK_FOO_BAR` -> `foo-bar`
-- `MDBOOK_FOO_bar__baz` -> `foo-bar.baz`
-
-So by setting the `MDBOOK_BOOK__TITLE` environment variable you can override the
-book's title without needing to touch your `book.toml`.
-
-> **Note:** To facilitate setting more complex config items, the value of an
-> environment variable is first parsed as JSON, falling back to a string if the
-> parse fails.
->
-> This means, if you so desired, you could override all book metadata when
-> building the book with something like
->
-> ```shell
-> $ export MDBOOK_BOOK="{'title': 'My Awesome Book', authors: ['Michael-F-Bryan']}"
-> $ mdbook build
-> ```
-
-The latter case may be useful in situations where `mdbook` is invoked from a
-script or CI, where it sometimes isn't possible to update the `book.toml` before
-building.
+[alternative backends]: ../../for_developers/backends.md

guide/src/format/example.rs

@@ -1,6 +1,6 @@
 fn main() {
     println!("Hello World!");
 #
-#    // You can even hide lines! :D
-#   println!("I am hidden! Expand the code snippet to see me");
+#     // You can even hide lines! :D
+#     println!("I am hidden! Expand the code snippet to see me");
 }

guide/src/format/mdbook.md

@@ -21,7 +21,7 @@ Will render as
 ```rust
 # fn main() {
     let x = 5;
-    let y = 7;
+    let y = 6;
 
     println!("{}", x + y);
 # }
@@ -40,7 +40,7 @@ The path to the file has to be relative from the current source file.
 mdBook will interpret included files as Markdown. Since the include command
 is usually used for inserting code snippets and examples, you will often
 wrap the command with ```` ``` ```` to display the file contents without
-interpretting them.
+interpreting them.
 
 ````hbs
 ```
@@ -49,7 +49,7 @@ interpretting them.
 ````
 
 ## Including portions of a file
-Often you only need a specific part of the file e.g. relevant lines for an
+Often you only need a specific part of the file, e.g. relevant lines for an
 example. We support four different modes of partial includes:
 
 ```hbs
@@ -68,8 +68,8 @@ consisting of lines 2 to 10.
 To avoid breaking your book when modifying included files, you can also
 include a specific section using anchors instead of line numbers.
 An anchor is a pair of matching lines. The line beginning an anchor must
-match the regex "ANCHOR:\s*[\w_-]+" and similarly the ending line must match
-the regex "ANCHOR_END:\s*[\w_-]+". This allows you to put anchors in
+match the regex `ANCHOR:\s*[\w_-]+` and similarly the ending line must match
+the regex `ANCHOR_END:\s*[\w_-]+`. This allows you to put anchors in
 any kind of commented line.
 
 Consider the following file to include:
@@ -156,7 +156,7 @@ To call the `add_one` function, we pass it an `i32` and bind the returned value
 #
 # fn add_one(num: i32) -> i32 {
 #     num + 1
-#}
+# }
 ```
 ````
 
@@ -170,7 +170,7 @@ That is, it looks like this (click the "expand" icon to see the rest of the file
 #
 # fn add_one(num: i32) -> i32 {
 #     num + 1
-#}
+# }
 ```
 
 ## Inserting runnable Rust files
@@ -192,3 +192,12 @@ Here is what a rendered code snippet looks like:
 {{#playground example.rs}}
 
 [Rust Playground]: https://play.rust-lang.org/
+
+## Controlling page \<title\>
+
+A chapter can set a \<title\> that is different from its entry in the table of
+contents (sidebar) by including a `\{{#title ...}}` near the top of the page.
+
+```hbs
+\{{#title My Title}}
+```

guide/src/format/summary.md

@@ -4,63 +4,96 @@ The summary file is used by mdBook to know what chapters to include, in what
 order they should appear, what their hierarchy is and where the source files
 are. Without this file, there is no book.
 
-Even though `SUMMARY.md` is a markdown file, the formatting is very strict to
-allow for easy parsing. Let's see how you should format your `SUMMARY.md` file.
+This markdown file must be named `SUMMARY.md`. Its formatting
+is very strict and must follow the structure outlined below to allow for easy
+parsing. Any element not specified below, be it formatting or textual, is likely
+to be ignored at best, or may cause an error when attempting to build the book.
 
-#### Structure
+### Structure
 
-1. ***Title*** It's common practice to begin with a title, generally <code
-   class="language-markdown"># Summary</code>. But it is not mandatory, the
-   parser just ignores it. So you can too if you feel like it.
-
-2. ***Prefix Chapter*** Before the main numbered chapters you can add a couple
-   of elements that will not be numbered. This is useful for forewords,
-   introductions, etc. There are however some constraints. You can not nest
-   prefix chapters, they should all be on the root level. And you can not add
-   prefix chapters once you have added numbered chapters.
+1. ***Title*** - While optional, it's common practice to begin with a title, generally <code
+   class="language-markdown"># Summary</code>. This is ignored by the parser however, and
+   can be omitted.
    ```markdown
-   [Title of prefix element](relative/path/to/markdown.md)
+   # Summary
    ```
 
-3. ***Part Title:*** Headers can be used as a title for the following numbered
+1. ***Prefix Chapter*** - Before the main numbered chapters, prefix chapters can be added
+   that will not be numbered. This is useful for forewords,
+   introductions, etc. There are, however, some constraints. Prefix chapters cannot be
+   nested; they should all be on the root level. And you can not add
+   prefix chapters once you have added numbered chapters.
+   ```markdown
+   [A Prefix Chapter](relative/path/to/markdown.md)
+
+   - [First Chapter](relative/path/to/markdown2.md)
+   ```
+
+1. ***Part Title*** - Headers can be used as a title for the following numbered
    chapters. This can be used to logically separate different sections
-   of book. The title is rendered as unclickable text.
+   of the book. The title is rendered as unclickable text.
    Titles are optional, and the numbered chapters can be broken into as many
    parts as desired.
+   ```markdown
+   # My Part Tile
 
-4. ***Numbered Chapter*** Numbered chapters are the main content of the book,
-   they will be numbered and can be nested, resulting in a nice hierarchy
-   (chapters, sub-chapters, etc.)
+   - [First Chapter](relative/path/to/markdown.md)
+   ```
+
+1. ***Numbered Chapter*** - Numbered chapters outline the main content of the book
+   and can be nested, resulting in a nice hierarchy
+   (chapters, sub-chapters, etc.).
    ```markdown
    # Title of Part
 
-   - [Title of the Chapter](relative/path/to/markdown.md)
+   - [First Chapter](relative/path/to/markdown.md)
+   - [Second Chapter](relative/path/to/markdown2.md)
+      - [Sub Chapter](relative/path/to/markdown3.md)
 
    # Title of Another Part
 
-   - [More Chapters](relative/path/to/markdown2.md)
+   - [Another Chapter](relative/path/to/markdown4.md)
    ```
-   You can either use `-` or `*` to indicate a numbered chapter.
+   Numbered chapters can be denoted with either `-` or `*` (do not mix delimiters). 
+   
+1. ***Suffix Chapter*** - Like prefix chapters, suffix chapters are unnumbered, but they come after 
+   numbered chapters.
+   ```markdown
+   - [Last Chapter](relative/path/to/markdown.md)
 
-5. ***Suffix Chapter*** After the numbered chapters you can add a couple of
-   non-numbered chapters. They are the same as prefix chapters but come after
-   the numbered chapters instead of before.
+   [Title of Suffix Chapter](relative/path/to/markdown2.md)
+   ```
 
-All other elements are unsupported and will be ignored at best or result in an
-error.
+1. ***Draft chapters*** - Draft chapters are chapters without a file and thus content.
+   The purpose of a draft chapter is to signal future chapters still to be written.
+   Or when still laying out the structure of the book to avoid creating the files
+   while you are still changing the structure of the book a lot.
+   Draft chapters will be rendered in the HTML renderer as disabled links in the table
+   of contents, as you can see for the next chapter in the table of contents on the left.
+   Draft chapters are written like normal chapters but without writing the path to the file.
+   ```markdown
+   - [Draft Chapter]()
+   ```
 
-#### Other elements
+1. ***Separators*** - Separators can be added before, in between, and after any other element. They result
+   in an HTML rendered line in the built table of contents.  A separator is
+   a line containing exclusively dashes and at least three of them: `---`.
+   ```markdown
+   # My Part Title
+   
+   [A Prefix Chapter](relative/path/to/markdown.md)
 
-- ***Separators*** In between chapters you can add a separator. In the HTML renderer
-  this will result in a line being rendered in the table of contents. A separator is
-  a line containing exclusively dashes and at least three of them: `---`.
-- ***Draft chapters*** Draft chapters are chapters without a file and thus content.
-  The purpose of a draft chapter is to signal future chapters still to be written.
-  Or when still laying out the structure of the book to avoid creating the files
-  while you are still changing the structure of the book a lot.
-  Draft chapters will be rendered in the HTML renderer as disabled links in the table
-  of contents, as you can see for the next chapter in the table of contents on the left.
-  Draft chapters are written like normal chapters but without writing the path to the file
-  ```markdown
-  - [Draft chapter]()
-  ```
+   ---
+
+   - [First Chapter](relative/path/to/markdown2.md)
+   ```
+  
+
+### Example
+
+Below is the markdown source for the `SUMMARY.md` for this guide, with the resulting table
+of contents as rendered to the left.
+
+```markdown
+{{#include ../SUMMARY.md}}
+```

guide/src/format/theme/README.md

@@ -42,5 +42,5 @@ If you completely replace all built-in themes, be sure to also set
 [`output.html.preferred-dark-theme`] in the config, which defaults to the
 built-in `navy` theme.
 
-[`output.html.preferred-dark-theme`]: ../config.md#html-renderer-options
+[`output.html.preferred-dark-theme`]: ../configuration/renderers.md#html-renderer-options
 [newer browsers]: https://caniuse.com/#feat=link-icon-svg

guide/src/format/theme/editor.md

@@ -33,7 +33,7 @@ Note the new `Undo Changes` button in the editable playgrounds.
 ## Customizing the Editor
 
 By default, the editor is the [Ace](https://ace.c9.io/) editor, but, if desired,
-the functionality may be overriden by providing a different folder:
+the functionality may be overridden by providing a different folder:
 
 ```toml
 [output.html.playground]
@@ -42,5 +42,5 @@ editor = "/path/to/editor"
 ```
 
 Note that for the editor changes to function correctly, the `book.js` inside of
-the `theme` folder will need to be overriden as it has some couplings with the
+the `theme` folder will need to be overridden as it has some couplings with the
 default Ace editor.

guide/src/format/theme/syntax-highlighting.md

@@ -112,10 +112,10 @@ everyone can benefit from it.**
 ## Improve default theme
 
 If you think the default theme doesn't look quite right for a specific language,
-or could be improved. Feel free to [submit a new
+or could be improved, feel free to [submit a new
 issue](https://github.com/rust-lang/mdBook/issues) explaining what you
 have in mind and I will take a look at it.
 
 You could also create a pull-request with the proposed improvements.
 
-Overall the theme should be light and sober, without to many flashy colors.
+Overall the theme should be light and sober, without too many flashy colors.

guide/src/misc/contributors.md

@@ -15,7 +15,10 @@ shout-out to them!
 - [projektir](https://github.com/projektir)
 - [Phaiax](https://github.com/Phaiax)
 - Matt Ickstadt ([mattico](https://github.com/mattico))
-- Weihang Lo ([@weihanglo](https://github.com/weihanglo))
-- Avision Ho ([@avisionh](https://github.com/avisionh))
+- Weihang Lo ([weihanglo](https://github.com/weihanglo))
+- Avision Ho ([avisionh](https://github.com/avisionh))
+- Vivek Akupatni ([apatniv](https://github.com/apatniv))
+- Eric Huss ([ehuss](https://github.com/ehuss))
+- Josh Rotenberg ([joshrotenberg](https://github.com/joshrotenberg))
 
 If you feel you're missing from this list, feel free to add yourself in a PR.

src/book/book.rs

@@ -22,7 +22,7 @@ pub fn load_book<P: AsRef<Path>>(src_dir: P, cfg: &BuildConfig) -> Result<Book>
         .with_context(|| format!("Summary parsing failed for file={:?}", summary_md))?;
 
     if cfg.create_missing {
-        create_missing(&src_dir, &summary).with_context(|| "Unable to create missing chapters")?;
+        create_missing(src_dir, &summary).with_context(|| "Unable to create missing chapters")?;
     }
 
     load_book_from_disk(&summary, src_dir)
@@ -160,6 +160,8 @@ pub struct Chapter {
     pub sub_items: Vec<BookItem>,
     /// The chapter's location, relative to the `SUMMARY.md` file.
     pub path: Option<PathBuf>,
+    /// The chapter's source file, relative to the `SUMMARY.md` file.
+    pub source_path: Option<PathBuf>,
     /// An ordered list of the names of each chapter above this one in the hierarchy.
     pub parent_names: Vec<String>,
 }
@@ -169,13 +171,15 @@ impl Chapter {
     pub fn new<P: Into<PathBuf>>(
         name: &str,
         content: String,
-        path: P,
+        p: P,
         parent_names: Vec<String>,
     ) -> Chapter {
+        let path: PathBuf = p.into();
         Chapter {
             name: name.to_string(),
             content,
-            path: Some(path.into()),
+            path: Some(path.clone()),
+            source_path: Some(path),
             parent_names,
             ..Default::default()
         }
@@ -188,6 +192,7 @@ impl Chapter {
             name: name.to_string(),
             content: String::new(),
             path: None,
+            source_path: None,
             parent_names,
             ..Default::default()
         }
@@ -195,10 +200,7 @@ impl Chapter {
 
     /// Check if the chapter is a draft chapter, meaning it has no path to a source markdown file.
     pub fn is_draft_chapter(&self) -> bool {
-        match self.path {
-            Some(_) => false,
-            None => true,
-        }
+        self.path.is_none()
     }
 }
 
@@ -379,7 +381,7 @@ And here is some \
 
         root.nested_items.push(second.clone().into());
         root.nested_items.push(SummaryItem::Separator);
-        root.nested_items.push(second.clone().into());
+        root.nested_items.push(second.into());
 
         (root, temp_dir)
     }
@@ -438,6 +440,7 @@ And here is some \
             content: String::from("Hello World!"),
             number: Some(SectionNumber(vec![1, 2])),
             path: Some(PathBuf::from("second.md")),
+            source_path: Some(PathBuf::from("second.md")),
             parent_names: vec![String::from("Chapter 1")],
             sub_items: Vec::new(),
         };
@@ -446,11 +449,12 @@ And here is some \
             content: String::from(DUMMY_SRC),
             number: None,
             path: Some(PathBuf::from("chapter_1.md")),
+            source_path: Some(PathBuf::from("chapter_1.md")),
             parent_names: Vec::new(),
             sub_items: vec![
                 BookItem::Chapter(nested.clone()),
                 BookItem::Separator,
-                BookItem::Chapter(nested.clone()),
+                BookItem::Chapter(nested),
             ],
         });
 
@@ -470,6 +474,7 @@ And here is some \
                 name: String::from("Chapter 1"),
                 content: String::from(DUMMY_SRC),
                 path: Some(PathBuf::from("chapter_1.md")),
+                source_path: Some(PathBuf::from("chapter_1.md")),
                 ..Default::default()
             })],
             ..Default::default()
@@ -510,6 +515,7 @@ And here is some \
                     content: String::from(DUMMY_SRC),
                     number: None,
                     path: Some(PathBuf::from("Chapter_1/index.md")),
+                    source_path: Some(PathBuf::from("Chapter_1/index.md")),
                     parent_names: Vec::new(),
                     sub_items: vec![
                         BookItem::Chapter(Chapter::new(
@@ -562,6 +568,7 @@ And here is some \
                     content: String::from(DUMMY_SRC),
                     number: None,
                     path: Some(PathBuf::from("Chapter_1/index.md")),
+                    source_path: Some(PathBuf::from("Chapter_1/index.md")),
                     parent_names: Vec::new(),
                     sub_items: vec![
                         BookItem::Chapter(Chapter::new(

src/book/mod.rs

@@ -20,6 +20,7 @@ use std::process::Command;
 use std::string::ToString;
 use tempfile::Builder as TempFileBuilder;
 use toml::Value;
+use topological_sort::TopologicalSort;
 
 use crate::errors::*;
 use crate::preprocess::{
@@ -196,23 +197,20 @@ impl MDBook {
             }
         }
 
-        info!("Running the {} backend", renderer.name());
-        self.render(&preprocessed_book, renderer)?;
-
-        Ok(())
-    }
-
-    fn render(&self, preprocessed_book: &Book, renderer: &dyn Renderer) -> Result<()> {
         let name = renderer.name();
         let build_dir = self.build_dir_for(name);
 
-        let render_context = RenderContext::new(
+        let mut render_context = RenderContext::new(
             self.root.clone(),
-            preprocessed_book.clone(),
+            preprocessed_book,
             self.config.clone(),
             build_dir,
         );
+        render_context
+            .chapter_titles
+            .extend(preprocess_ctx.chapter_titles.borrow_mut().drain());
 
+        info!("Running the {} backend", renderer.name());
         renderer
             .render(&render_context)
             .with_context(|| "Rendering failed")
@@ -277,6 +275,10 @@ impl MDBook {
                         RustEdition::E2018 => {
                             cmd.args(&["--edition", "2018"]);
                         }
+                        RustEdition::E2021 => {
+                            cmd.args(&["--edition", "2021"])
+                                .args(&["-Z", "unstable-options"]);
+                        }
                     }
                 }
 
@@ -371,12 +373,7 @@ fn determine_renderers(config: &Config) -> Vec<Box<dyn Renderer>> {
     renderers
 }
 
-fn default_preprocessors() -> Vec<Box<dyn Preprocessor>> {
-    vec![
-        Box::new(LinkPreprocessor::new()),
-        Box::new(IndexPreprocessor::new()),
-    ]
-}
+const DEFAULT_PREPROCESSORS: &[&'static str] = &["links", "index"];
 
 fn is_default_preprocessor(pre: &dyn Preprocessor) -> bool {
     let name = pre.name();
@@ -385,36 +382,127 @@ fn is_default_preprocessor(pre: &dyn Preprocessor) -> bool {
 
 /// Look at the `MDBook` and try to figure out what preprocessors to run.
 fn determine_preprocessors(config: &Config) -> Result<Vec<Box<dyn Preprocessor>>> {
-    let mut preprocessors = Vec::new();
+    // Collect the names of all preprocessors intended to be run, and the order
+    // in which they should be run.
+    let mut preprocessor_names = TopologicalSort::<String>::new();
 
     if config.build.use_default_preprocessors {
-        preprocessors.extend(default_preprocessors());
+        for name in DEFAULT_PREPROCESSORS {
+            preprocessor_names.insert(name.to_string());
+        }
     }
 
     if let Some(preprocessor_table) = config.get("preprocessor").and_then(Value::as_table) {
-        for key in preprocessor_table.keys() {
-            match key.as_ref() {
-                "links" => preprocessors.push(Box::new(LinkPreprocessor::new())),
-                "index" => preprocessors.push(Box::new(IndexPreprocessor::new())),
-                name => preprocessors.push(interpret_custom_preprocessor(
-                    name,
-                    &preprocessor_table[name],
-                )),
+        for (name, table) in preprocessor_table.iter() {
+            preprocessor_names.insert(name.to_string());
+
+            let exists = |name| {
+                (config.build.use_default_preprocessors && DEFAULT_PREPROCESSORS.contains(&name))
+                    || preprocessor_table.contains_key(name)
+            };
+
+            if let Some(before) = table.get("before") {
+                let before = before.as_array().ok_or_else(|| {
+                    Error::msg(format!(
+                        "Expected preprocessor.{}.before to be an array",
+                        name
+                    ))
+                })?;
+                for after in before {
+                    let after = after.as_str().ok_or_else(|| {
+                        Error::msg(format!(
+                            "Expected preprocessor.{}.before to contain strings",
+                            name
+                        ))
+                    })?;
+
+                    if !exists(after) {
+                        // Only warn so that preprocessors can be toggled on and off (e.g. for
+                        // troubleshooting) without having to worry about order too much.
+                        warn!(
+                            "preprocessor.{}.after contains \"{}\", which was not found",
+                            name, after
+                        );
+                    } else {
+                        preprocessor_names.add_dependency(name, after);
+                    }
+                }
+            }
+
+            if let Some(after) = table.get("after") {
+                let after = after.as_array().ok_or_else(|| {
+                    Error::msg(format!(
+                        "Expected preprocessor.{}.after to be an array",
+                        name
+                    ))
+                })?;
+                for before in after {
+                    let before = before.as_str().ok_or_else(|| {
+                        Error::msg(format!(
+                            "Expected preprocessor.{}.after to contain strings",
+                            name
+                        ))
+                    })?;
+
+                    if !exists(before) {
+                        // See equivalent warning above for rationale
+                        warn!(
+                            "preprocessor.{}.before contains \"{}\", which was not found",
+                            name, before
+                        );
+                    } else {
+                        preprocessor_names.add_dependency(before, name);
+                    }
+                }
             }
         }
     }
 
-    Ok(preprocessors)
+    // Now that all links have been established, queue preprocessors in a suitable order
+    let mut preprocessors = Vec::with_capacity(preprocessor_names.len());
+    // `pop_all()` returns an empty vector when no more items are not being depended upon
+    for mut names in std::iter::repeat_with(|| preprocessor_names.pop_all())
+        .take_while(|names| !names.is_empty())
+    {
+        // The `topological_sort` crate does not guarantee a stable order for ties, even across
+        // runs of the same program. Thus, we break ties manually by sorting.
+        // Careful: `str`'s default sorting, which we are implicitly invoking here, uses code point
+        // values ([1]), which may not be an alphabetical sort.
+        // As mentioned in [1], doing so depends on locale, which is not desirable for deciding
+        // preprocessor execution order.
+        // [1]: https://doc.rust-lang.org/stable/std/cmp/trait.Ord.html#impl-Ord-14
+        names.sort();
+        for name in names {
+            let preprocessor: Box<dyn Preprocessor> = match name.as_str() {
+                "links" => Box::new(LinkPreprocessor::new()),
+                "index" => Box::new(IndexPreprocessor::new()),
+                _ => {
+                    // The only way to request a custom preprocessor is through the `preprocessor`
+                    // table, so it must exist, be a table, and contain the key.
+                    let table = &config.get("preprocessor").unwrap().as_table().unwrap()[&name];
+                    let command = get_custom_preprocessor_cmd(&name, table);
+                    Box::new(CmdPreprocessor::new(name, command))
+                }
+            };
+            preprocessors.push(preprocessor);
+        }
+    }
+
+    // "If `pop_all` returns an empty vector and `len` is not 0, there are cyclic dependencies."
+    // Normally, `len() == 0` is equivalent to `is_empty()`, so we'll use that.
+    if preprocessor_names.is_empty() {
+        Ok(preprocessors)
+    } else {
+        Err(Error::msg("Cyclic dependency detected in preprocessors"))
+    }
 }
 
-fn interpret_custom_preprocessor(key: &str, table: &Value) -> Box<CmdPreprocessor> {
-    let command = table
+fn get_custom_preprocessor_cmd(key: &str, table: &Value) -> String {
+    table
         .get("command")
         .and_then(Value::as_str)
         .map(ToString::to_string)
-        .unwrap_or_else(|| format!("mdbook-{}", key));
-
-    Box::new(CmdPreprocessor::new(key.to_string(), command))
+        .unwrap_or_else(|| format!("mdbook-{}", key))
 }
 
 fn interpret_custom_renderer(key: &str, table: &Value) -> Box<CmdRenderer> {
@@ -514,8 +602,8 @@ mod tests {
 
         assert!(got.is_ok());
         assert_eq!(got.as_ref().unwrap().len(), 2);
-        assert_eq!(got.as_ref().unwrap()[0].name(), "links");
-        assert_eq!(got.as_ref().unwrap()[1].name(), "index");
+        assert_eq!(got.as_ref().unwrap()[0].name(), "index");
+        assert_eq!(got.as_ref().unwrap()[1].name(), "links");
     }
 
     #[test]
@@ -562,9 +650,123 @@ mod tests {
 
         // make sure the `preprocessor.random` table exists
         let random = cfg.get_preprocessor("random").unwrap();
-        let random = interpret_custom_preprocessor("random", &Value::Table(random.clone()));
+        let random = get_custom_preprocessor_cmd("random", &Value::Table(random.clone()));
 
-        assert_eq!(random.cmd(), "python random.py");
+        assert_eq!(random, "python random.py");
+    }
+
+    #[test]
+    fn preprocessor_before_must_be_array() {
+        let cfg_str = r#"
+        [preprocessor.random]
+        before = 0
+        "#;
+
+        let cfg = Config::from_str(cfg_str).unwrap();
+
+        assert!(determine_preprocessors(&cfg).is_err());
+    }
+
+    #[test]
+    fn preprocessor_after_must_be_array() {
+        let cfg_str = r#"
+        [preprocessor.random]
+        after = 0
+        "#;
+
+        let cfg = Config::from_str(cfg_str).unwrap();
+
+        assert!(determine_preprocessors(&cfg).is_err());
+    }
+
+    #[test]
+    fn preprocessor_order_is_honored() {
+        let cfg_str = r#"
+        [preprocessor.random]
+        before = [ "last" ]
+        after = [ "index" ]
+
+        [preprocessor.last]
+        after = [ "links", "index" ]
+        "#;
+
+        let cfg = Config::from_str(cfg_str).unwrap();
+
+        let preprocessors = determine_preprocessors(&cfg).unwrap();
+        let index = |name| {
+            preprocessors
+                .iter()
+                .enumerate()
+                .find(|(_, preprocessor)| preprocessor.name() == name)
+                .unwrap()
+                .0
+        };
+        let assert_before = |before, after| {
+            if index(before) >= index(after) {
+                eprintln!("Preprocessor order:");
+                for preprocessor in &preprocessors {
+                    eprintln!("  {}", preprocessor.name());
+                }
+                panic!("{} should come before {}", before, after);
+            }
+        };
+
+        assert_before("index", "random");
+        assert_before("index", "last");
+        assert_before("random", "last");
+        assert_before("links", "last");
+    }
+
+    #[test]
+    fn cyclic_dependencies_are_detected() {
+        let cfg_str = r#"
+        [preprocessor.links]
+        before = [ "index" ]
+
+        [preprocessor.index]
+        before = [ "links" ]
+        "#;
+
+        let cfg = Config::from_str(cfg_str).unwrap();
+
+        assert!(determine_preprocessors(&cfg).is_err());
+    }
+
+    #[test]
+    fn dependencies_dont_register_undefined_preprocessors() {
+        let cfg_str = r#"
+        [preprocessor.links]
+        before = [ "random" ]
+        "#;
+
+        let cfg = Config::from_str(cfg_str).unwrap();
+
+        let preprocessors = determine_preprocessors(&cfg).unwrap();
+
+        assert!(preprocessors
+            .iter()
+            .find(|preprocessor| preprocessor.name() == "random")
+            .is_none());
+    }
+
+    #[test]
+    fn dependencies_dont_register_builtin_preprocessors_if_disabled() {
+        let cfg_str = r#"
+        [preprocessor.random]
+        before = [ "links" ]
+
+        [build]
+        use-default-preprocessors = false
+        "#;
+
+        let cfg = Config::from_str(cfg_str).unwrap();
+
+        let preprocessors = determine_preprocessors(&cfg).unwrap();
+
+        assert!(preprocessors
+            .iter()
+            .find(|preprocessor| preprocessor.name() == "links")
+            .is_none());
     }
 
     #[test]

src/book/summary.rs

@@ -173,7 +173,7 @@ struct SummaryParser<'a> {
 /// `Event::End` is encountered which matches the `$delimiter` pattern.
 ///
 /// This is the equivalent of doing
-/// `$stream.take_while(|e| e != $delimeter).collect()` but it allows you to
+/// `$stream.take_while(|e| e != $delimiter).collect()` but it allows you to
 /// use pattern matching and you won't get errors because `take_while()`
 /// moves `$stream` out of self.
 macro_rules! collect_events {
@@ -382,7 +382,7 @@ impl<'a> SummaryParser<'a> {
                 }
                 Some(ev @ Event::Start(Tag::List(..))) => {
                     self.back(ev);
-                    let mut bunch_of_items = self.parse_nested_numbered(&root_number)?;
+                    let mut bunch_of_items = self.parse_nested_numbered(root_number)?;
 
                     // if we've resumed after something like a rule the root sections
                     // will be numbered from 1. We need to manually go back and update
@@ -525,14 +525,19 @@ impl<'a> SummaryParser<'a> {
 
     /// Try to parse the title line.
     fn parse_title(&mut self) -> Option<String> {
-        match self.next_event() {
-            Some(Event::Start(Tag::Heading(1))) => {
-                debug!("Found a h1 in the SUMMARY");
+        loop {
+            match self.next_event() {
+                Some(Event::Start(Tag::Heading(1))) => {
+                    debug!("Found a h1 in the SUMMARY");
 
-                let tags = collect_events!(self.stream, end Tag::Heading(1));
-                Some(stringify_events(tags))
+                    let tags = collect_events!(self.stream, end Tag::Heading(1));
+                    return Some(stringify_events(tags));
+                }
+                // Skip a HTML element such as a comment line.
+                Some(Event::Html(_)) => {}
+                // Otherwise, no title.
+                _ => return None,
             }
-            _ => None,
         }
     }
 }
@@ -973,4 +978,103 @@ mod tests {
 
         assert_eq!(got, should_be);
     }
+
+    #[test]
+    fn skip_html_comments() {
+        let src = r#"<!--
+# Title - En
+-->
+# Title - Local
+
+<!--
+[Prefix 00-01 - En](ch00-01.md)
+[Prefix 00-02 - En](ch00-02.md)
+-->
+[Prefix 00-01 - Local](ch00-01.md)
+[Prefix 00-02 - Local](ch00-02.md)
+
+<!--
+## Section Title - En
+-->
+## Section Title - Localized
+
+<!--
+- [Ch 01-00 - En](ch01-00.md)
+    - [Ch 01-01 - En](ch01-01.md)
+    - [Ch 01-02 - En](ch01-02.md)
+-->
+- [Ch 01-00 - Local](ch01-00.md)
+    - [Ch 01-01 - Local](ch01-01.md)
+    - [Ch 01-02 - Local](ch01-02.md)
+
+<!--
+- [Ch 02-00 - En](ch02-00.md)
+-->
+- [Ch 02-00 - Local](ch02-00.md)
+
+<!--
+[Appendix A - En](appendix-01.md)
+[Appendix B - En](appendix-02.md)
+-->`
+[Appendix A - Local](appendix-01.md)
+[Appendix B - Local](appendix-02.md)
+"#;
+
+        let mut parser = SummaryParser::new(src);
+
+        // ---- Title ----
+        let title = parser.parse_title();
+        assert_eq!(title, Some(String::from("Title - Local")));
+
+        // ---- Prefix Chapters ----
+
+        let new_affix_item = |name, location| {
+            SummaryItem::Link(Link {
+                name: String::from(name),
+                location: Some(PathBuf::from(location)),
+                ..Default::default()
+            })
+        };
+
+        let should_be = vec![
+            new_affix_item("Prefix 00-01 - Local", "ch00-01.md"),
+            new_affix_item("Prefix 00-02 - Local", "ch00-02.md"),
+        ];
+
+        let got = parser.parse_affix(true).unwrap();
+        assert_eq!(got, should_be);
+
+        // ---- Numbered Chapters ----
+
+        let new_numbered_item = |name, location, numbers: &[u32], nested_items| {
+            SummaryItem::Link(Link {
+                name: String::from(name),
+                location: Some(PathBuf::from(location)),
+                number: Some(SectionNumber(numbers.to_vec())),
+                nested_items,
+            })
+        };
+
+        let ch01_nested = vec![
+            new_numbered_item("Ch 01-01 - Local", "ch01-01.md", &[1, 1], vec![]),
+            new_numbered_item("Ch 01-02 - Local", "ch01-02.md", &[1, 2], vec![]),
+        ];
+
+        let should_be = vec![
+            new_numbered_item("Ch 01-00 - Local", "ch01-00.md", &[1], ch01_nested),
+            new_numbered_item("Ch 02-00 - Local", "ch02-00.md", &[2], vec![]),
+        ];
+        let got = parser.parse_parts().unwrap();
+        assert_eq!(got, should_be);
+
+        // ---- Suffix Chapters ----
+
+        let should_be = vec![
+            new_affix_item("Appendix A - Local", "appendix-01.md"),
+            new_affix_item("Appendix B - Local", "appendix-02.md"),
+        ];
+
+        let got = parser.parse_affix(false).unwrap();
+        assert_eq!(got, should_be);
+    }
 }

src/cmd/init.rs

@@ -1,5 +1,5 @@
 use crate::get_book_dir;
-use clap::{App, ArgMatches, SubCommand};
+use clap::{App, Arg, ArgMatches, SubCommand};
 use mdbook::config;
 use mdbook::errors::Result;
 use mdbook::MDBook;
@@ -18,6 +18,21 @@ pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
         )
         .arg_from_usage("--theme 'Copies the default theme into your source folder'")
         .arg_from_usage("--force 'Skips confirmation prompts'")
+        .arg(
+            Arg::with_name("title")
+                .long("title")
+                .takes_value(true)
+                .help("Sets the book title")
+                .required(false),
+        )
+        .arg(
+            Arg::with_name("ignore")
+                .long("ignore")
+                .takes_value(true)
+                .possible_values(&["none", "git"])
+                .help("Creates a VCS ignore file (i.e. .gitignore)")
+                .required(false),
+        )
 }
 
 // Init command implementation
@@ -25,7 +40,6 @@ pub fn execute(args: &ArgMatches) -> Result<()> {
     let book_dir = get_book_dir(args);
     let mut builder = MDBook::init(&book_dir);
     let mut config = config::Config::default();
-
     // If flag `--theme` is present, copy theme to src
     if args.is_present("theme") {
         let theme_dir = book_dir.join("theme");
@@ -45,13 +59,23 @@ pub fn execute(args: &ArgMatches) -> Result<()> {
         }
     }
 
-    println!("\nDo you want a .gitignore to be created? (y/n)");
-
-    if confirm() {
-        builder.create_gitignore(true);
+    if let Some(ignore) = args.value_of("ignore") {
+        match ignore {
+            "git" => builder.create_gitignore(true),
+            _ => builder.create_gitignore(false),
+        };
+    } else {
+        println!("\nDo you want a .gitignore to be created? (y/n)");
+        if confirm() {
+            builder.create_gitignore(true);
+        }
     }
 
-    config.book.title = request_book_title();
+    config.book.title = if args.is_present("title") {
+        args.value_of("title").map(String::from)
+    } else {
+        request_book_title()
+    };
 
     if let Some(author) = get_author_name() {
         debug!("Obtained user name from gitconfig: {:?}", author);

src/cmd/serve.rs

@@ -161,5 +161,12 @@ async fn serve(
     let fallback_route = warp::fs::file(build_dir.join(file_404))
         .map(|reply| warp::reply::with_status(reply, warp::http::StatusCode::NOT_FOUND));
     let routes = livereload.or(book_route).or(fallback_route);
+
+    std::panic::set_hook(Box::new(move |panic_info| {
+        // exit if serve panics
+        error!("Unable to serve: {}", panic_info);
+        std::process::exit(1);
+    }));
+
     warp::serve(routes).run(address).await;
 }

src/cmd/watch.rs

@@ -58,7 +58,7 @@ pub fn execute(args: &ArgMatches) -> Result<()> {
     Ok(())
 }
 
-fn remove_ignored_files(book_root: &PathBuf, paths: &[PathBuf]) -> Vec<PathBuf> {
+fn remove_ignored_files(book_root: &Path, paths: &[PathBuf]) -> Vec<PathBuf> {
     if paths.is_empty() {
         return vec![];
     }
@@ -81,7 +81,7 @@ fn remove_ignored_files(book_root: &PathBuf, paths: &[PathBuf]) -> Vec<PathBuf>
     }
 }
 
-fn find_gitignore(book_root: &PathBuf) -> Option<PathBuf> {
+fn find_gitignore(book_root: &Path) -> Option<PathBuf> {
     book_root
         .ancestors()
         .map(|p| p.join(".gitignore"))

src/config.rs

@@ -294,6 +294,7 @@ impl Default for Config {
         }
     }
 }
+
 impl<'de> Deserialize<'de> for Config {
     fn deserialize<D: Deserializer<'de>>(de: D) -> std::result::Result<Self, D::Error> {
         let raw = Value::deserialize(de)?;
@@ -310,10 +311,10 @@ impl<'de> Deserialize<'de> for Config {
             return Ok(Config::from_legacy(raw));
         }
 
+        use serde::de::Error;
         let mut table = match raw {
             Value::Table(t) => t,
             _ => {
-                use serde::de::Error;
                 return Err(D::Error::custom(
                     "A config file should always be a toml table",
                 ));
@@ -322,17 +323,20 @@ impl<'de> Deserialize<'de> for Config {
 
         let book: BookConfig = table
             .remove("book")
-            .and_then(|value| value.try_into().ok())
+            .map(|book| book.try_into().map_err(D::Error::custom))
+            .transpose()?
             .unwrap_or_default();
 
         let build: BuildConfig = table
             .remove("build")
-            .and_then(|value| value.try_into().ok())
+            .map(|build| build.try_into().map_err(D::Error::custom))
+            .transpose()?
             .unwrap_or_default();
 
         let rust: RustConfig = table
             .remove("rust")
-            .and_then(|value| value.try_into().ok())
+            .map(|rust| rust.try_into().map_err(D::Error::custom))
+            .transpose()?
             .unwrap_or_default();
 
         Ok(Config {
@@ -463,6 +467,9 @@ pub struct RustConfig {
 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 /// Rust edition to use for the code.
 pub enum RustEdition {
+    /// The 2021 edition of Rust
+    #[serde(rename = "2021")]
+    E2021,
     /// The 2018 edition of Rust
     #[serde(rename = "2018")]
     E2018,
@@ -522,6 +529,10 @@ pub struct HtmlConfig {
     ///
     /// [custom domain]: https://docs.github.com/en/github/working-with-github-pages/managing-a-custom-domain-for-your-github-pages-site
     pub cname: Option<String>,
+    /// Edit url template, when set shows a "Suggest an edit" button for
+    /// directly jumping to editing the currently viewed page.
+    /// Contains {path} that is replaced with chapter source file path
+    pub edit_url_template: Option<String>,
     /// This is used as a bit of a workaround for the `mdbook serve` command.
     /// Basically, because you set the websocket port from the command line, the
     /// `mdbook serve` command needs a way to let the HTML renderer know where
@@ -554,6 +565,7 @@ impl Default for HtmlConfig {
             search: None,
             git_repository_url: None,
             git_repository_icon: None,
+            edit_url_template: None,
             input_404: None,
             site_url: None,
             cname: None,
@@ -566,7 +578,7 @@ impl Default for HtmlConfig {
 impl HtmlConfig {
     /// Returns the directory of theme from the provided root directory. If the
     /// directory is not present it will append the default directory of "theme"
-    pub fn theme_dir(&self, root: &PathBuf) -> PathBuf {
+    pub fn theme_dir(&self, root: &Path) -> PathBuf {
         match self.theme {
             Some(ref d) => root.join(d),
             None => root.join("theme"),
@@ -651,7 +663,7 @@ pub struct Search {
     pub boost_paragraph: u8,
     /// True if the searchword `micro` should match `microwave`. Default: `true`.
     pub expand: bool,
-    /// Documents are split into smaller parts, seperated by headings. This defines, until which
+    /// Documents are split into smaller parts, separated by headings. This defines, until which
     /// level of heading documents should be split. Default: `3`. (`### This is a level 3 heading`)
     pub heading_split_level: u8,
     /// Copy JavaScript files for the search functionality to the output directory?
@@ -846,6 +858,26 @@ mod tests {
         assert_eq!(got.rust, rust_should_be);
     }
 
+    #[test]
+    fn edition_2021() {
+        let src = r#"
+        [book]
+        title = "mdBook Documentation"
+        description = "Create book from markdown files. Like Gitbook but implemented in Rust"
+        authors = ["Mathieu David"]
+        src = "./source"
+        [rust]
+        edition = "2021"
+        "#;
+
+        let rust_should_be = RustConfig {
+            edition: Some(RustEdition::E2021),
+        };
+
+        let got = Config::from_str(src).unwrap();
+        assert_eq!(got.rust, rust_should_be);
+    }
+
     #[test]
     fn load_arbitrary_output_type() {
         #[derive(Debug, Deserialize, PartialEq)]
@@ -1065,4 +1097,57 @@ mod tests {
         assert_eq!(html_config.input_404, Some("missing.md".to_string()));
         assert_eq!(&get_404_output_file(&html_config.input_404), "missing.html");
     }
+
+    #[test]
+    #[should_panic(expected = "Invalid configuration file")]
+    fn invalid_language_type_error() {
+        let src = r#"
+        [book]
+        title = "mdBook Documentation"
+        language = ["en", "pt-br"]
+        description = "Create book from markdown files. Like Gitbook but implemented in Rust"
+        authors = ["Mathieu David"]
+        src = "./source"
+        "#;
+
+        Config::from_str(src).unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "Invalid configuration file")]
+    fn invalid_title_type() {
+        let src = r#"
+        [book]
+        title = 20
+        language = "en"
+        description = "Create book from markdown files. Like Gitbook but implemented in Rust"
+        authors = ["Mathieu David"]
+        src = "./source"
+        "#;
+
+        Config::from_str(src).unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "Invalid configuration file")]
+    fn invalid_build_dir_type() {
+        let src = r#"
+        [build]
+        build-dir = 99
+        create-missing = false
+        "#;
+
+        Config::from_str(src).unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "Invalid configuration file")]
+    fn invalid_rust_edition() {
+        let src = r#"
+        [rust]
+        edition = "1999"
+        "#;
+
+        Config::from_str(src).unwrap();
+    }
 }

src/main.rs

@@ -3,8 +3,9 @@ extern crate clap;
 #[macro_use]
 extern crate log;
 
+use anyhow::anyhow;
 use chrono::Local;
-use clap::{App, AppSettings, ArgMatches};
+use clap::{App, AppSettings, Arg, ArgMatches, Shell, SubCommand};
 use env_logger::Builder;
 use log::LevelFilter;
 use mdbook::utils;
@@ -20,7 +21,40 @@ const VERSION: &str = concat!("v", crate_version!());
 fn main() {
     init_logger();
 
-    // Create a list of valid arguments and sub-commands
+    let app = create_clap_app();
+
+    // Check which subcomamnd the user ran...
+    let res = match app.get_matches().subcommand() {
+        ("init", Some(sub_matches)) => cmd::init::execute(sub_matches),
+        ("build", Some(sub_matches)) => cmd::build::execute(sub_matches),
+        ("clean", Some(sub_matches)) => cmd::clean::execute(sub_matches),
+        #[cfg(feature = "watch")]
+        ("watch", Some(sub_matches)) => cmd::watch::execute(sub_matches),
+        #[cfg(feature = "serve")]
+        ("serve", Some(sub_matches)) => cmd::serve::execute(sub_matches),
+        ("test", Some(sub_matches)) => cmd::test::execute(sub_matches),
+        ("completions", Some(sub_matches)) => (|| {
+            let shell: Shell = sub_matches
+                .value_of("shell")
+                .ok_or_else(|| anyhow!("Shell name missing."))?
+                .parse()
+                .map_err(|s| anyhow!("Invalid shell: {}", s))?;
+
+            create_clap_app().gen_completions_to("mdbook", shell, &mut std::io::stdout().lock());
+            Ok(())
+        })(),
+        (_, _) => unreachable!(),
+    };
+
+    if let Err(e) = res {
+        utils::log_backtrace(&e);
+
+        std::process::exit(101);
+    }
+}
+
+/// Create a list of valid arguments and sub-commands
+fn create_clap_app<'a, 'b>() -> App<'a, 'b> {
     let app = App::new(crate_name!())
         .about(crate_description!())
         .author("Mathieu David <mathieudavid@mathieudavid.org>")
@@ -35,31 +69,26 @@ fn main() {
         .subcommand(cmd::init::make_subcommand())
         .subcommand(cmd::build::make_subcommand())
         .subcommand(cmd::test::make_subcommand())
-        .subcommand(cmd::clean::make_subcommand());
+        .subcommand(cmd::clean::make_subcommand())
+        .subcommand(
+            SubCommand::with_name("completions")
+                .about("Generate shell completions for your shell to stdout")
+                .arg(
+                    Arg::with_name("shell")
+                        .takes_value(true)
+                        .possible_values(&Shell::variants())
+                        .help("the shell to generate completions for")
+                        .value_name("SHELL")
+                        .required(true),
+                ),
+        );
 
     #[cfg(feature = "watch")]
     let app = app.subcommand(cmd::watch::make_subcommand());
     #[cfg(feature = "serve")]
     let app = app.subcommand(cmd::serve::make_subcommand());
 
-    // Check which subcomamnd the user ran...
-    let res = match app.get_matches().subcommand() {
-        ("init", Some(sub_matches)) => cmd::init::execute(sub_matches),
-        ("build", Some(sub_matches)) => cmd::build::execute(sub_matches),
-        ("clean", Some(sub_matches)) => cmd::clean::execute(sub_matches),
-        #[cfg(feature = "watch")]
-        ("watch", Some(sub_matches)) => cmd::watch::execute(sub_matches),
-        #[cfg(feature = "serve")]
-        ("serve", Some(sub_matches)) => cmd::serve::execute(sub_matches),
-        ("test", Some(sub_matches)) => cmd::test::execute(sub_matches),
-        (_, _) => unreachable!(),
-    };
-
-    if let Err(e) = res {
-        utils::log_backtrace(&e);
-
-        std::process::exit(101);
-    }
+    app
 }
 
 fn init_logger() {
@@ -103,7 +132,8 @@ fn get_book_dir(args: &ArgMatches) -> PathBuf {
 }
 
 fn open<P: AsRef<OsStr>>(path: P) {
-    if let Err(e) = open::that(path) {
+    info!("Opening web browser");
+    if let Err(e) = opener::open(path) {
         error!("Error opening web browser: {}", e);
     }
 }

src/preprocess/cmd.rs

@@ -49,7 +49,7 @@ impl CmdPreprocessor {
     fn write_input_to_child(&self, child: &mut Child, book: &Book, ctx: &PreprocessorContext) {
         let stdin = child.stdin.take().expect("Child has stdin");
 
-        if let Err(e) = self.write_input(stdin, &book, &ctx) {
+        if let Err(e) = self.write_input(stdin, book, ctx) {
             // Looks like the backend hung up before we could finish
             // sending it the render context. Log the error and keep going
             warn!("Error writing the RenderContext to the backend, {}", e);
@@ -109,18 +109,28 @@ impl Preprocessor for CmdPreprocessor {
 
         self.write_input_to_child(&mut child, &book, ctx);
 
-        let output = child
-            .wait_with_output()
-            .with_context(|| "Error waiting for the preprocessor to complete")?;
+        let output = child.wait_with_output().with_context(|| {
+            format!(
+                "Error waiting for the \"{}\" preprocessor to complete",
+                self.name
+            )
+        })?;
 
         trace!("{} exited with output: {:?}", self.cmd, output);
         ensure!(
             output.status.success(),
-            "The preprocessor exited unsuccessfully"
+            format!(
+                "The \"{}\" preprocessor exited unsuccessfully with {} status",
+                self.name, output.status
+            )
         );
 
-        serde_json::from_slice(&output.stdout)
-            .with_context(|| "Unable to parse the preprocessed book")
+        serde_json::from_slice(&output.stdout).with_context(|| {
+            format!(
+                "Unable to parse the preprocessed book from \"{}\" processor",
+                self.name
+            )
+        })
     }
 
     fn supports_renderer(&self, renderer: &str) -> bool {

src/preprocess/links.rs

@@ -23,6 +23,7 @@ const MAX_LINK_NESTED_DEPTH: usize = 10;
 ///   This hides the lines from initial display but shows them when the reader expands the code
 ///   block and provides them to Rustdoc for testing.
 /// - `{{# playground}}` - Insert runnable Rust files
+/// - `{{# title}}` - Override \<title\> of a webpage.
 #[derive(Default)]
 pub struct LinkPreprocessor;
 
@@ -51,8 +52,15 @@ impl Preprocessor for LinkPreprocessor {
                         .map(|dir| src_dir.join(dir))
                         .expect("All book items have a parent");
 
-                    let content = replace_all(&ch.content, base, chapter_path, 0);
+                    let mut chapter_title = ch.name.clone();
+                    let content =
+                        replace_all(&ch.content, base, chapter_path, 0, &mut chapter_title);
                     ch.content = content;
+                    if chapter_title != ch.name {
+                        ctx.chapter_titles
+                            .borrow_mut()
+                            .insert(chapter_path.clone(), chapter_title);
+                    }
                 }
             }
         });
@@ -61,7 +69,13 @@ impl Preprocessor for LinkPreprocessor {
     }
 }
 
-fn replace_all<P1, P2>(s: &str, path: P1, source: P2, depth: usize) -> String
+fn replace_all<P1, P2>(
+    s: &str,
+    path: P1,
+    source: P2,
+    depth: usize,
+    chapter_title: &mut String,
+) -> String
 where
     P1: AsRef<Path>,
     P2: AsRef<Path>,
@@ -77,11 +91,17 @@ where
     for link in find_links(s) {
         replaced.push_str(&s[previous_end_index..link.start_index]);
 
-        match link.render_with_path(&path) {
+        match link.render_with_path(&path, chapter_title) {
             Ok(new_content) => {
                 if depth < MAX_LINK_NESTED_DEPTH {
                     if let Some(rel_path) = link.link_type.relative_path(path) {
-                        replaced.push_str(&replace_all(&new_content, rel_path, source, depth + 1));
+                        replaced.push_str(&replace_all(
+                            &new_content,
+                            rel_path,
+                            source,
+                            depth + 1,
+                            chapter_title,
+                        ));
                     } else {
                         replaced.push_str(&new_content);
                     }
@@ -116,6 +136,7 @@ enum LinkType<'a> {
     Include(PathBuf, RangeOrAnchor),
     Playground(PathBuf, Vec<&'a str>),
     RustdocInclude(PathBuf, RangeOrAnchor),
+    Title(&'a str),
 }
 
 #[derive(PartialEq, Debug, Clone)]
@@ -185,6 +206,7 @@ impl<'a> LinkType<'a> {
             LinkType::Include(p, _) => Some(return_relative_path(base, &p)),
             LinkType::Playground(p, _) => Some(return_relative_path(base, &p)),
             LinkType::RustdocInclude(p, _) => Some(return_relative_path(base, &p)),
+            LinkType::Title(_) => None,
         }
     }
 }
@@ -255,6 +277,9 @@ struct Link<'a> {
 impl<'a> Link<'a> {
     fn from_capture(cap: Captures<'a>) -> Option<Link<'a>> {
         let link_type = match (cap.get(0), cap.get(1), cap.get(2)) {
+            (_, Some(typ), Some(title)) if typ.as_str() == "title" => {
+                Some(LinkType::Title(title.as_str()))
+            }
             (_, Some(typ), Some(rest)) => {
                 let mut path_props = rest.as_str().split_whitespace();
                 let file_arg = path_props.next();
@@ -291,7 +316,11 @@ impl<'a> Link<'a> {
         })
     }
 
-    fn render_with_path<P: AsRef<Path>>(&self, base: P) -> Result<String> {
+    fn render_with_path<P: AsRef<Path>>(
+        &self,
+        base: P,
+        chapter_title: &mut String,
+    ) -> Result<String> {
         let base = base.as_ref();
         match self.link_type {
             // omit the escape char
@@ -353,6 +382,10 @@ impl<'a> Link<'a> {
                     contents
                 ))
             }
+            LinkType::Title(title) => {
+                *chapter_title = title.to_owned();
+                Ok(String::new())
+            }
         }
     }
 }
@@ -373,17 +406,17 @@ impl<'a> Iterator for LinkIter<'a> {
 
 fn find_links(contents: &str) -> LinkIter<'_> {
     // lazily compute following regex
-    // r"\\\{\{#.*\}\}|\{\{#([a-zA-Z0-9]+)\s*([a-zA-Z0-9_.\-:/\\\s]+)\}\}")?;
+    // r"\\\{\{#.*\}\}|\{\{#([a-zA-Z0-9]+)\s*([^}]+)\}\}")?;
     lazy_static! {
         static ref RE: Regex = Regex::new(
-            r"(?x)                       # insignificant whitespace mode
-            \\\{\{\#.*\}\}               # match escaped link
-            |                            # or
-            \{\{\s*                      # link opening parens and whitespace
-            \#([a-zA-Z0-9_]+)            # link type
-            \s+                          # separating whitespace
-            ([a-zA-Z0-9\s_.\-:/\\\+]+)   # link target path and space separated properties
-            \s*\}\}                      # whitespace and link closing parens"
+            r"(?x)              # insignificant whitespace mode
+            \\\{\{\#.*\}\}      # match escaped link
+            |                   # or
+            \{\{\s*             # link opening parens and whitespace
+            \#([a-zA-Z0-9_]+)   # link type
+            \s+                 # separating whitespace
+            ([^}]+)             # link target path and space separated properties
+            \}\}                # link closing parens"
         )
         .unwrap();
     }
@@ -406,7 +439,21 @@ mod tests {
         ```hbs
         {{#include file.rs}} << an escaped link!
         ```";
-        assert_eq!(replace_all(start, "", "", 0), end);
+        let mut chapter_title = "test_replace_all_escaped".to_owned();
+        assert_eq!(replace_all(start, "", "", 0, &mut chapter_title), end);
+    }
+
+    #[test]
+    fn test_set_chapter_title() {
+        let start = r"{{#title My Title}}
+        # My Chapter
+        ";
+        let end = r"
+        # My Chapter
+        ";
+        let mut chapter_title = "test_set_chapter_title".to_owned();
+        assert_eq!(replace_all(start, "", "", 0, &mut chapter_title), end);
+        assert_eq!(chapter_title, "My Title");
     }
 
     #[test]

src/preprocess/mod.rs

@@ -12,6 +12,8 @@ use crate::book::Book;
 use crate::config::Config;
 use crate::errors::*;
 
+use std::cell::RefCell;
+use std::collections::HashMap;
 use std::path::PathBuf;
 
 /// Extra information for a `Preprocessor` to give them more context when
@@ -27,6 +29,8 @@ pub struct PreprocessorContext {
     /// The calling `mdbook` version.
     pub mdbook_version: String,
     #[serde(skip)]
+    pub(crate) chapter_titles: RefCell<HashMap<PathBuf, String>>,
+    #[serde(skip)]
     __non_exhaustive: (),
 }
 
@@ -38,6 +42,7 @@ impl PreprocessorContext {
             config,
             renderer,
             mdbook_version: crate::MDBOOK_VERSION.to_string(),
+            chapter_titles: RefCell::new(HashMap::new()),
             __non_exhaustive: (),
         }
     }

src/renderer/html_handlebars/hbs_renderer.rs

@@ -1,5 +1,5 @@
 use crate::book::{Book, BookItem};
-use crate::config::{Config, HtmlConfig, Playground, RustEdition};
+use crate::config::{BookConfig, Config, HtmlConfig, Playground, RustEdition};
 use crate::errors::*;
 use crate::renderer::html_handlebars::helpers;
 use crate::renderer::{RenderContext, Renderer};
@@ -37,14 +37,32 @@ impl HtmlHandlebars {
             _ => return Ok(()),
         };
 
+        if let Some(ref edit_url_template) = ctx.html_config.edit_url_template {
+            let full_path = ctx.book_config.src.to_str().unwrap_or_default().to_owned()
+                + "/"
+                + ch.source_path
+                    .clone()
+                    .unwrap_or_default()
+                    .to_str()
+                    .unwrap_or_default();
+
+            let edit_url = edit_url_template.replace("{path}", &full_path);
+            ctx.data
+                .insert("git_repository_edit_url".to_owned(), json!(edit_url));
+        }
+
         let content = ch.content.clone();
         let content = utils::render_markdown(&content, ctx.html_config.curly_quotes);
 
-        let fixed_content = utils::render_markdown_with_path(
-            &ch.content,
-            ctx.html_config.curly_quotes,
-            Some(&path),
-        );
+        let fixed_content =
+            utils::render_markdown_with_path(&ch.content, ctx.html_config.curly_quotes, Some(path));
+        if !ctx.is_index {
+            // Add page break between chapters
+            // See https://developer.mozilla.org/en-US/docs/Web/CSS/break-before and https://developer.mozilla.org/en-US/docs/Web/CSS/page-break-before
+            // Add both two CSS properties because of the compatibility issue
+            print_content
+                .push_str(r#"<div style="break-before: page; page-break-before: always;"></div>"#);
+        }
         print_content.push_str(&fixed_content);
 
         // Update the context with data for this file
@@ -64,9 +82,12 @@ impl HtmlHandlebars {
             .and_then(serde_json::Value::as_str)
             .unwrap_or("");
 
-        let title = match book_title {
-            "" => ch.name.clone(),
-            _ => ch.name.clone() + " - " + book_title,
+        let title = if let Some(title) = ctx.chapter_titles.get(path) {
+            title.clone()
+        } else if book_title.is_empty() {
+            ch.name.clone()
+        } else {
+            ch.name.clone() + " - " + book_title
         };
 
         ctx.data.insert("path".to_owned(), json!(path));
@@ -110,7 +131,7 @@ impl HtmlHandlebars {
         &self,
         ctx: &RenderContext,
         html_config: &HtmlConfig,
-        src_dir: &PathBuf,
+        src_dir: &Path,
         handlebars: &mut Handlebars<'_>,
         data: &mut serde_json::Map<String, serde_json::Value>,
     ) -> Result<()> {
@@ -154,7 +175,7 @@ impl HtmlHandlebars {
         let rendered =
             self.post_process(rendered, &html_config.playground, ctx.config.rust.edition);
         let output_file = get_404_output_file(&html_config.input_404);
-        utils::fs::write_file(&destination, output_file, rendered.as_bytes())?;
+        utils::fs::write_file(destination, output_file, rendered.as_bytes())?;
         debug!("Creating 404.html ✓");
         Ok(())
     }
@@ -199,10 +220,10 @@ impl HtmlHandlebars {
         }
         write_file(destination, "css/variables.css", &theme.variables_css)?;
         if let Some(contents) = &theme.favicon_png {
-            write_file(destination, "favicon.png", &contents)?;
+            write_file(destination, "favicon.png", contents)?;
         }
         if let Some(contents) = &theme.favicon_svg {
-            write_file(destination, "favicon.svg", &contents)?;
+            write_file(destination, "favicon.svg", contents)?;
         }
         write_file(destination, "highlight.css", &theme.highlight_css)?;
         write_file(destination, "tomorrow-night.css", &theme.tomorrow_night_css)?;
@@ -437,6 +458,7 @@ impl Renderer for HtmlHandlebars {
     }
 
     fn render(&self, ctx: &RenderContext) -> Result<()> {
+        let book_config = &ctx.config.book;
         let html_config = ctx.config.html_config().unwrap_or_default();
         let src_dir = ctx.root.join(&ctx.config.book.src);
         let destination = &ctx.destination;
@@ -484,7 +506,7 @@ impl Renderer for HtmlHandlebars {
         debug!("Register handlebars helpers");
         self.register_hbs_helpers(&mut handlebars, &html_config);
 
-        let mut data = make_data(&ctx.root, &book, &ctx.config, &html_config, &theme)?;
+        let mut data = make_data(&ctx.root, book, &ctx.config, &html_config, &theme)?;
 
         // Print version
         let mut print_content = String::new();
@@ -499,8 +521,10 @@ impl Renderer for HtmlHandlebars {
                 destination: destination.to_path_buf(),
                 data: data.clone(),
                 is_index,
+                book_config: book_config.clone(),
                 html_config: html_config.clone(),
                 edition: ctx.config.rust.edition,
+                chapter_titles: &ctx.chapter_titles,
             };
             self.render_item(item, ctx, &mut print_content)?;
             is_index = false;
@@ -525,14 +549,14 @@ impl Renderer for HtmlHandlebars {
             let rendered =
                 self.post_process(rendered, &html_config.playground, ctx.config.rust.edition);
 
-            utils::fs::write_file(&destination, "print.html", rendered.as_bytes())?;
+            utils::fs::write_file(destination, "print.html", rendered.as_bytes())?;
             debug!("Creating print.html ✓");
         }
 
         debug!("Copy static files");
-        self.copy_static_files(&destination, &theme, &html_config)
+        self.copy_static_files(destination, &theme, &html_config)
             .with_context(|| "Unable to copy across static files")?;
-        self.copy_additional_css_and_js(&html_config, &ctx.root, &destination)
+        self.copy_additional_css_and_js(&html_config, &ctx.root, destination)
             .with_context(|| "Unable to copy across additional CSS and JS")?;
 
         // Render search index
@@ -540,7 +564,7 @@ impl Renderer for HtmlHandlebars {
         {
             let search = html_config.search.unwrap_or_default();
             if search.enable {
-                super::search::create_files(&search, &destination, &book)?;
+                super::search::create_files(&search, destination, book)?;
             }
         }
 
@@ -548,7 +572,7 @@ impl Renderer for HtmlHandlebars {
             .context("Unable to emit redirects")?;
 
         // Copy all remaining files, avoid a recursive copy from/to the book build dir
-        utils::fs::copy_files_except_ext(&src_dir, &destination, true, Some(&build_dir), &["md"])?;
+        utils::fs::copy_files_except_ext(&src_dir, destination, true, Some(&build_dir), &["md"])?;
 
         Ok(())
     }
@@ -756,7 +780,7 @@ fn insert_link_into_header(
     *id_count += 1;
 
     format!(
-        r##"<h{level}><a class="header" href="#{id}" id="{id}">{text}</a></h{level}>"##,
+        r##"<h{level} id="{id}"><a class="header" href="#{id}">{text}</a></h{level}>"##,
         level = level,
         id = id,
         text = content
@@ -809,13 +833,15 @@ fn add_playground_pre(
                 {
                     let contains_e2015 = classes.contains("edition2015");
                     let contains_e2018 = classes.contains("edition2018");
-                    let edition_class = if contains_e2015 || contains_e2018 {
+                    let contains_e2021 = classes.contains("edition2021");
+                    let edition_class = if contains_e2015 || contains_e2018 || contains_e2021 {
                         // the user forced edition, we should not overwrite it
                         ""
                     } else {
                         match edition {
                             Some(RustEdition::E2015) => " edition2015",
                             Some(RustEdition::E2018) => " edition2018",
+                            Some(RustEdition::E2021) => " edition2021",
                             None => "",
                         }
                     };
@@ -914,8 +940,10 @@ struct RenderItemContext<'a> {
     destination: PathBuf,
     data: serde_json::Map<String, serde_json::Value>,
     is_index: bool,
+    book_config: BookConfig,
     html_config: HtmlConfig,
     edition: Option<RustEdition>,
+    chapter_titles: &'a HashMap<PathBuf, String>,
 }
 
 #[cfg(test)]
@@ -927,32 +955,32 @@ mod tests {
         let inputs = vec![
             (
                 "blah blah <h1>Foo</h1>",
-                r##"blah blah <h1><a class="header" href="#foo" id="foo">Foo</a></h1>"##,
+                r##"blah blah <h1 id="foo"><a class="header" href="#foo">Foo</a></h1>"##,
             ),
             (
                 "<h1>Foo</h1>",
-                r##"<h1><a class="header" href="#foo" id="foo">Foo</a></h1>"##,
+                r##"<h1 id="foo"><a class="header" href="#foo">Foo</a></h1>"##,
             ),
             (
                 "<h3>Foo^bar</h3>",
-                r##"<h3><a class="header" href="#foobar" id="foobar">Foo^bar</a></h3>"##,
+                r##"<h3 id="foobar"><a class="header" href="#foobar">Foo^bar</a></h3>"##,
             ),
             (
                 "<h4></h4>",
-                r##"<h4><a class="header" href="#" id=""></a></h4>"##,
+                r##"<h4 id=""><a class="header" href="#"></a></h4>"##,
             ),
             (
                 "<h4><em>Hï</em></h4>",
-                r##"<h4><a class="header" href="#hï" id="hï"><em>Hï</em></a></h4>"##,
+                r##"<h4 id="hï"><a class="header" href="#hï"><em>Hï</em></a></h4>"##,
             ),
             (
                 "<h1>Foo</h1><h3>Foo</h3>",
-                r##"<h1><a class="header" href="#foo" id="foo">Foo</a></h1><h3><a class="header" href="#foo-1" id="foo-1">Foo</a></h3>"##,
+                r##"<h1 id="foo"><a class="header" href="#foo">Foo</a></h1><h3 id="foo-1"><a class="header" href="#foo-1">Foo</a></h3>"##,
             ),
         ];
 
         for (src, should_be) in inputs {
-            let got = build_header_links(&src);
+            let got = build_header_links(src);
             assert_eq!(got, should_be);
         }
     }
@@ -1035,4 +1063,28 @@ mod tests {
             assert_eq!(&*got, *should_be);
         }
     }
+    #[test]
+    fn add_playground_edition2021() {
+        let inputs = [
+            ("<code class=\"language-rust\">x()</code>",
+             "<pre class=\"playground\"><code class=\"language-rust edition2021\">\n<span class=\"boring\">#![allow(unused)]\n</span><span class=\"boring\">fn main() {\n</span>x()\n<span class=\"boring\">}\n</span></code></pre>"),
+            ("<code class=\"language-rust\">fn main() {}</code>",
+             "<pre class=\"playground\"><code class=\"language-rust edition2021\">fn main() {}\n</code></pre>"),
+            ("<code class=\"language-rust edition2015\">fn main() {}</code>",
+             "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}\n</code></pre>"),
+            ("<code class=\"language-rust edition2018\">fn main() {}</code>",
+             "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}\n</code></pre>"),
+        ];
+        for (src, should_be) in &inputs {
+            let got = add_playground_pre(
+                src,
+                &Playground {
+                    editable: true,
+                    ..Playground::default()
+                },
+                Some(RustEdition::E2021),
+            );
+            assert_eq!(&*got, *should_be);
+        }
+    }
 }

src/renderer/html_handlebars/helpers/navigation.rs

@@ -91,7 +91,7 @@ fn find_chapter(
         match item.get("path") {
             Some(path) if !path.is_empty() => {
                 if let Some(previous) = previous {
-                    if let Some(item) = target.find(&base_path, &path, &item, &previous)? {
+                    if let Some(item) = target.find(&base_path, path, &item, &previous)? {
                         return Ok(Some(item));
                     }
                 }

src/renderer/html_handlebars/helpers/toc.rs

@@ -142,7 +142,7 @@ impl HelperDef for RenderToc {
                 // Section does not necessarily exist
                 if let Some(section) = item.get("section") {
                     out.write("<strong aria-hidden=\"true\">")?;
-                    out.write(&section)?;
+                    out.write(section)?;
                     out.write("</strong> ")?;
                 }
             }

src/renderer/html_handlebars/search.rs

@@ -17,10 +17,10 @@ pub fn create_files(search_config: &Search, destination: &Path, book: &Book) ->
     let mut doc_urls = Vec::with_capacity(book.sections.len());
 
     for item in book.iter() {
-        render_item(&mut index, &search_config, &mut doc_urls, item)?;
+        render_item(&mut index, search_config, &mut doc_urls, item)?;
     }
 
-    let index = write_to_json(index, &search_config, doc_urls)?;
+    let index = write_to_json(index, search_config, doc_urls)?;
     debug!("Writing search index ✓");
     if index.len() > 10_000_000 {
         warn!("searchindex.json is very large ({} bytes)", index.len());
@@ -134,14 +134,14 @@ fn render_item(
                 // in an HtmlBlock tag. We must collect consecutive Html events
                 // into a block ourselves.
                 while let Some(Event::Html(html)) = p.peek() {
-                    html_block.push_str(&html);
+                    html_block.push_str(html);
                     p.next();
                 }
 
                 body.push_str(&clean_html(&html_block));
             }
             Event::Start(_) | Event::End(_) | Event::Rule | Event::SoftBreak | Event::HardBreak => {
-                // Insert spaces where HTML output would usually seperate text
+                // Insert spaces where HTML output would usually separate text
                 // to ensure words don't get merged together
                 if in_heading {
                     heading.push(' ');
@@ -165,7 +165,12 @@ fn render_item(
         }
     }
 
-    if !heading.is_empty() {
+    if !body.is_empty() || !heading.is_empty() {
+        if heading.is_empty() {
+            if let Some(chapter) = breadcrumbs.first() {
+                heading = chapter.clone();
+            }
+        }
         // Make sure the last section is added to the index
         add_doc(
             index,

src/renderer/mod.rs

@@ -18,6 +18,7 @@ mod html_handlebars;
 mod markdown_renderer;
 
 use shlex::Shlex;
+use std::collections::HashMap;
 use std::fs;
 use std::io::{self, ErrorKind, Read};
 use std::path::{Path, PathBuf};
@@ -64,6 +65,8 @@ pub struct RenderContext {
     /// guaranteed to be empty or even exist.
     pub destination: PathBuf,
     #[serde(skip)]
+    pub(crate) chapter_titles: HashMap<PathBuf, String>,
+    #[serde(skip)]
     __non_exhaustive: (),
 }
 
@@ -80,6 +83,7 @@ impl RenderContext {
             version: crate::MDBOOK_VERSION.to_string(),
             root: root.into(),
             destination: destination.into(),
+            chapter_titles: HashMap::new(),
             __non_exhaustive: (),
         }
     }
@@ -162,7 +166,7 @@ impl CmdRenderer {
                 } else {
                     // Let this bubble through to later be handled by
                     // handle_render_command_error.
-                    abs_exe.to_path_buf()
+                    abs_exe
                 }
             }
         };

src/theme/book.js

@@ -108,9 +108,12 @@ function playground_text(playground) {
 
         let text = playground_text(code_block);
         let classes = code_block.querySelector('code').classList;
-        let has_2018 = classes.contains("edition2018");
-        let edition = has_2018 ? "2018" : "2015";
-
+        let edition = "2015";
+        if(classes.contains("edition2018")) {
+            edition = "2018";
+        } else if(classes.contains("edition2021")) {
+            edition = "2021";
+        }
         var params = {
             version: "stable",
             optimize: "0",
@@ -133,7 +136,15 @@ function playground_text(playground) {
             body: JSON.stringify(params)
         })
         .then(response => response.json())
-        .then(response => result_block.innerText = response.result)
+        .then(response => {
+            if (response.result.trim() === '') {
+                result_block.innerText = "No output";
+                result_block.classList.add("result-no-output");
+            } else {
+                result_block.innerText = response.result;
+                result_block.classList.remove("result-no-output");
+            }
+        })
         .catch(error => result_block.innerText = "Playground Communication: " + error.message);
     }
 
@@ -151,12 +162,13 @@ function playground_text(playground) {
     if (window.ace) {
         // language-rust class needs to be removed for editable
         // blocks or highlightjs will capture events
-        Array
-            .from(document.querySelectorAll('code.editable'))
+        code_nodes
+            .filter(function (node) {return node.classList.contains("editable"); })
             .forEach(function (block) { block.classList.remove('language-rust'); });
 
         Array
-            .from(document.querySelectorAll('code:not(.editable)'))
+        code_nodes
+            .filter(function (node) {return !node.classList.contains("editable"); })
             .forEach(function (block) { hljs.highlightBlock(block); });
     } else {
         code_nodes.forEach(function (block) { hljs.highlightBlock(block); });
@@ -359,7 +371,14 @@ function playground_text(playground) {
     });
 
     themePopup.addEventListener('click', function (e) {
-        var theme = e.target.id || e.target.parentElement.id;
+        var theme;
+        if (e.target.className === "theme") {
+            theme = e.target.id;
+        } else if (e.target.parentElement.className === "theme") {
+            theme = e.target.parentElement.id;
+        } else {
+            return;
+        }
         set_theme(theme);
     });
 

src/theme/css/chrome.css

@@ -93,7 +93,7 @@ a > .hljs {
 .menu-title {
     display: inline-block;
     font-weight: 200;
-    font-size: 2rem;
+    font-size: 2.4rem;
     line-height: var(--menu-bar-height);
     text-align: center;
     margin: 0;

src/theme/css/general.css

@@ -45,20 +45,23 @@ h4, h5 { margin-top: 2em; }
     margin-top: 1em;
 }
 
-h1 a.header:target::before,
-h2 a.header:target::before,
-h3 a.header:target::before,
-h4 a.header:target::before {
+h1:target::before,
+h2:target::before,
+h3:target::before,
+h4:target::before,
+h5:target::before,
+h6:target::before {
     display: inline-block;
     content: "»";
     margin-left: -30px;
     width: 30px;
 }
 
-h1 a.header:target,
-h2 a.header:target,
-h3 a.header:target,
-h4 a.header:target {
+/* This is broken on Safari as of version 14, but is fixed
+   in Safari Technology Preview 117 which I think will be Safari 14.2.
+   https://bugs.webkit.org/show_bug.cgi?id=218076
+*/
+:target {
     scroll-margin-top: calc(var(--menu-bar-height) + 0.5em);
 }
 
@@ -89,7 +92,7 @@ h4 a.header:target {
 .content ul { line-height: 1.45em; }
 .content a { text-decoration: none; }
 .content a:hover { text-decoration: underline; }
-.content img { max-width: 100%; }
+.content img, .content video { max-width: 100%; }
 .content .header:link,
 .content .header:visited {
     color: var(--fg);
@@ -172,3 +175,7 @@ blockquote {
     margin: 5px 0px;
     font-weight: bold;
 }
+
+.result-no-output {
+    font-style: italic;
+}

src/theme/css/variables.css

@@ -67,7 +67,7 @@
 
     --links: #2b79a2;
 
-    --inline-code-color: #c5c8c6;;
+    --inline-code-color: #c5c8c6;
 
     --theme-popup-bg: #141617;
     --theme-popup-border: #43484d;
@@ -92,22 +92,22 @@
 
 .light {
     --bg: hsl(0, 0%, 100%);
-    --fg: #333333;
+    --fg: hsl(0, 0%, 0%);
 
     --sidebar-bg: #fafafa;
-    --sidebar-fg: #364149;
+    --sidebar-fg: hsl(0, 0%, 0%);
     --sidebar-non-existant: #aaaaaa;
-    --sidebar-active: #008cff;
+    --sidebar-active: #1f1fff;
     --sidebar-spacer: #f4f4f4;
 
-    --scrollbar: #cccccc;
+    --scrollbar: #8F8F8F;
 
-    --icons: #cccccc;
-    --icons-hover: #333333;
+    --icons: #747474;
+    --icons-hover: #000000;
 
-    --links: #4183c4;
+    --links: #20609f;
 
-    --inline-code-color: #6e6b5e;
+    --inline-code-color: #301900;
 
     --theme-popup-bg: #fafafa;
     --theme-popup-border: #cccccc;
@@ -147,7 +147,7 @@
 
     --links: #2b79a2;
 
-    --inline-code-color: #c5c8c6;;
+    --inline-code-color: #c5c8c6;
 
     --theme-popup-bg: #161923;
     --theme-popup-border: #737480;
@@ -228,7 +228,7 @@
 
         --links: #2b79a2;
 
-        --inline-code-color: #c5c8c6;;
+        --inline-code-color: #c5c8c6;
 
         --theme-popup-bg: #141617;
         --theme-popup-border: #43484d;

src/theme/highlight.css

@@ -1,14 +1,18 @@
-/* Base16 Atelier Dune Light - Theme */
-/* by Bram de Haan (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/dune) */
-/* Original Base16 color scheme by Chris Kempson (https://github.com/chriskempson/base16) */
+/*
+ * An increased contrast highlighting scheme loosely based on the
+ * "Base16 Atelier Dune Light" theme by Bram de Haan
+ * (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/dune)
+ * Original Base16 color scheme by Chris Kempson
+ * (https://github.com/chriskempson/base16)
+ */
 
-/* Atelier-Dune Comment */
+/* Comment */
 .hljs-comment,
 .hljs-quote {
-  color: #AAA;
+  color: #575757;
 }
 
-/* Atelier-Dune Red */
+/* Red */
 .hljs-variable,
 .hljs-template-variable,
 .hljs-attribute,
@@ -19,10 +23,10 @@
 .hljs-name,
 .hljs-selector-id,
 .hljs-selector-class {
-  color: #d73737;
+  color: #d70025;
 }
 
-/* Atelier-Dune Orange */
+/* Orange */
 .hljs-number,
 .hljs-meta,
 .hljs-built_in,
@@ -30,33 +34,33 @@
 .hljs-literal,
 .hljs-type,
 .hljs-params {
-  color: #b65611;
+  color: #b21e00;
 }
 
-/* Atelier-Dune Green */
+/* Green */
 .hljs-string,
 .hljs-symbol,
 .hljs-bullet {
-  color: #60ac39;
+  color: #008200;
 }
 
-/* Atelier-Dune Blue */
+/* Blue */
 .hljs-title,
 .hljs-section {
-  color: #6684e1;
+  color: #0030f2;
 }
 
-/* Atelier-Dune Purple */
+/* Purple */
 .hljs-keyword,
 .hljs-selector-tag {
-  color: #b854d4;
+  color: #9d00ec;
 }
 
 .hljs {
   display: block;
   overflow-x: auto;
-  background: #f1f1f1;
-  color: #6e6b5e;
+  background: #f6f7f6;
+  color: #000;
   padding: 0.5em;
 }
 

src/theme/index.hbs

@@ -148,13 +148,19 @@
                             <i id="git-repository-button" class="fa {{git_repository_icon}}"></i>
                         </a>
                         {{/if}}
+                        {{#if git_repository_edit_url}}
+                        <a href="{{git_repository_edit_url}}" title="Suggest an edit" aria-label="Suggest an edit">
+                            <i id="git-edit-button" class="fa fa-edit"></i>
+                        </a>
+                        {{/if}}
+
                     </div>
                 </div>
 
                 {{#if search_enabled}}
                 <div id="search-wrapper" class="hidden">
                     <form id="searchbar-outer" class="searchbar-outer">
-                        <input type="search" name="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
+                        <input type="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
                     </form>
                     <div id="searchresults-outer" class="searchresults-outer hidden">
                         <div id="searchresults-header" class="searchresults-header"></div>

src/utils/fs.rs

@@ -4,7 +4,7 @@ use std::fs::{self, File};
 use std::io::Write;
 use std::path::{Component, Path, PathBuf};
 
-/// Naively replaces any path seperator with a forward-slash '/'
+/// Naively replaces any path separator with a forward-slash '/'
 pub fn normalize_path(path: &str) -> String {
     use std::path::is_separator;
     path.chars()
@@ -247,7 +247,7 @@ mod tests {
         }
 
         if let Err(e) =
-            copy_files_except_ext(&tmp.path(), &tmp.path().join("output"), true, None, &["md"])
+            copy_files_except_ext(tmp.path(), &tmp.path().join("output"), true, None, &["md"])
         {
             panic!("Error while executing the function:\n{:?}", e);
         }

src/utils/mod.rs

@@ -228,7 +228,14 @@ impl EventQuoteConverter {
 fn clean_codeblock_headers(event: Event<'_>) -> Event<'_> {
     match event {
         Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(ref info))) => {
-            let info: String = info.chars().filter(|ch| !ch.is_whitespace()).collect();
+            let info: String = info
+                .chars()
+                .map(|x| match x {
+                    ' ' | '\t' => ',',
+                    _ => x,
+                })
+                .filter(|ch| !ch.is_whitespace())
+                .collect();
 
             Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(CowStr::from(info))))
         }
@@ -372,7 +379,7 @@ more text with spaces
 ```
 "#;
 
-            let expected = r#"<pre><code class="language-rust,no_run,,,should_panic,,property_3"></code></pre>
+            let expected = r#"<pre><code class="language-rust,,,,,no_run,,,should_panic,,,,property_3"></code></pre>
 "#;
             assert_eq!(render_markdown(input, false), expected);
             assert_eq!(render_markdown(input, true), expected);

tests/cli/build.rs

@@ -0,0 +1,29 @@
+use crate::dummy_book::DummyBook;
+
+use assert_cmd::Command;
+
+#[test]
+fn mdbook_cli_dummy_book_generates_index_html() {
+    let temp = DummyBook::new().build().unwrap();
+
+    // doesn't exist before
+    assert!(!temp.path().join("book").exists());
+
+    let mut cmd = Command::cargo_bin("mdbook").unwrap();
+    cmd.arg("build").current_dir(temp.path());
+    cmd.assert()
+        .success()
+        .stderr(
+            predicates::str::is_match(r##"Stack depth exceeded in first[\\/]recursive.md."##)
+                .unwrap(),
+        )
+        .stderr(predicates::str::contains(
+            r##"[INFO] (mdbook::book): Running the html backend"##,
+        ));
+
+    // exists afterward
+    assert!(temp.path().join("book").exists());
+
+    let index_file = temp.path().join("book/index.html");
+    assert!(index_file.exists());
+}

tests/cli/mod.rs

@@ -0,0 +1,2 @@
+mod build;
+mod test;

tests/cli/test.rs

@@ -0,0 +1,34 @@
+use crate::dummy_book::DummyBook;
+
+use assert_cmd::Command;
+use predicates::boolean::PredicateBooleanExt;
+
+#[test]
+fn mdbook_cli_can_correctly_test_a_passing_book() {
+    let temp = DummyBook::new().with_passing_test(true).build().unwrap();
+
+    let mut cmd = Command::cargo_bin("mdbook").unwrap();
+    cmd.arg("test").current_dir(temp.path());
+    cmd.assert().success()
+      .stderr(predicates::str::is_match(r##"Testing file: "([^"]+)[\\/]README.md""##).unwrap())
+      .stderr(predicates::str::is_match(r##"Testing file: "([^"]+)[\\/]intro.md""##).unwrap())
+      .stderr(predicates::str::is_match(r##"Testing file: "([^"]+)[\\/]first[\\/]index.md""##).unwrap())
+      .stderr(predicates::str::is_match(r##"Testing file: "([^"]+)[\\/]first[\\/]nested.md""##).unwrap())
+      .stderr(predicates::str::is_match(r##"rustdoc returned an error:\n\n"##).unwrap().not())
+      .stderr(predicates::str::is_match(r##"Nested_Chapter::Rustdoc_include_works_with_anchors_too \(line \d+\) ... FAILED"##).unwrap().not());
+}
+
+#[test]
+fn mdbook_cli_detects_book_with_failing_tests() {
+    let temp = DummyBook::new().with_passing_test(false).build().unwrap();
+
+    let mut cmd = Command::cargo_bin("mdbook").unwrap();
+    cmd.arg("test").current_dir(temp.path());
+    cmd.assert().failure()
+      .stderr(predicates::str::is_match(r##"Testing file: "([^"]+)[\\/]README.md""##).unwrap())
+      .stderr(predicates::str::is_match(r##"Testing file: "([^"]+)[\\/]intro.md""##).unwrap())
+      .stderr(predicates::str::is_match(r##"Testing file: "([^"]+)[\\/]first[\\/]index.md""##).unwrap())
+      .stderr(predicates::str::is_match(r##"Testing file: "([^"]+)[\\/]first[\\/]nested.md""##).unwrap())
+      .stderr(predicates::str::is_match(r##"rustdoc returned an error:\n\n"##).unwrap())
+      .stderr(predicates::str::is_match(r##"Nested_Chapter::Rustdoc_include_works_with_anchors_too \(line \d+\) ... FAILED"##).unwrap());
+}

tests/cli_tests.rs

@@ -0,0 +1,2 @@
+mod cli;
+mod dummy_book;

tests/dummy_book/src/SUMMARY.md

@@ -12,6 +12,7 @@
     - [Recursive](first/recursive.md)
     - [Markdown](first/markdown.md)
     - [Unicode](first/unicode.md)
+    - [No Headers](first/no-headers.md)
 - [Second Chapter](second.md)
     - [Nested Chapter](second/nested.md)
 

tests/dummy_book/src/first/no-headers.md

@@ -0,0 +1,3 @@
+Capybara capybara capybara.
+
+Capybara capybara capybara.

tests/rendered_output.rs

@@ -34,6 +34,7 @@ const TOC_SECOND_LEVEL: &[&str] = &[
     "1.3. Recursive",
     "1.4. Markdown",
     "1.5. Unicode",
+    "1.6. No Headers",
     "2.1. Nested Chapter",
 ];
 
@@ -104,12 +105,12 @@ fn check_correct_cross_links_in_nested_dir() {
 
     assert_contains_strings(
         first.join("index.html"),
-        &[r##"href="#some-section" id="some-section""##],
+        &[r##"<h2 id="some-section"><a class="header" href="#some-section">"##],
     );
 
     assert_contains_strings(
         first.join("nested.html"),
-        &[r##"href="#some-section" id="some-section""##],
+        &[r##"<h2 id="some-section"><a class="header" href="#some-section">"##],
     );
 }
 
@@ -264,7 +265,7 @@ fn root_index_html() -> Result<Document> {
 fn check_second_toc_level() {
     let doc = root_index_html().unwrap();
     let mut should_be = Vec::from(TOC_SECOND_LEVEL);
-    should_be.sort();
+    should_be.sort_unstable();
 
     let pred = descendants!(
         Class("chapter"),
@@ -288,7 +289,7 @@ fn check_first_toc_level() {
     let mut should_be = Vec::from(TOC_TOP_LEVEL);
 
     should_be.extend(TOC_SECOND_LEVEL);
-    should_be.sort();
+    should_be.sort_unstable();
 
     let pred = descendants!(
         Class("chapter"),
@@ -373,7 +374,7 @@ fn able_to_include_files_in_chapters() {
     let includes = temp.path().join("book/first/includes.html");
 
     let summary_strings = &[
-        r##"<h1><a class="header" href="#summary" id="summary">Summary</a></h1>"##,
+        r##"<h1 id="summary"><a class="header" href="#summary">Summary</a></h1>"##,
         ">First Chapter</a>",
     ];
     assert_contains_strings(&includes, summary_strings);
@@ -535,12 +536,63 @@ fn redirects_are_emitted_correctly() {
         let mut redirect_file = md.build_dir_for("html");
         // append everything except the bits that make it absolute
         // (e.g. "/" or "C:\")
-        redirect_file.extend(remove_absolute_components(&original));
+        redirect_file.extend(remove_absolute_components(original));
         let contents = fs::read_to_string(&redirect_file).unwrap();
         assert!(contents.contains(redirect));
     }
 }
 
+#[test]
+fn edit_url_has_default_src_dir_edit_url() {
+    let temp = DummyBook::new().build().unwrap();
+    let book_toml = r#"
+        [book]
+        title = "implicit"
+
+        [output.html]
+        edit-url-template = "https://github.com/rust-lang/mdBook/edit/master/guide/{path}"    
+        "#;
+
+    write_file(temp.path(), "book.toml", book_toml.as_bytes()).unwrap();
+
+    let md = MDBook::load(temp.path()).unwrap();
+    md.build().unwrap();
+
+    let index_html = temp.path().join("book").join("index.html");
+    assert_contains_strings(
+        index_html,
+        &[
+            r#"href="https://github.com/rust-lang/mdBook/edit/master/guide/src/README.md" title="Suggest an edit""#,
+        ],
+    );
+}
+
+#[test]
+fn edit_url_has_configured_src_dir_edit_url() {
+    let temp = DummyBook::new().build().unwrap();
+    let book_toml = r#"
+        [book]
+        title = "implicit"
+        src = "src2"
+
+        [output.html]
+        edit-url-template = "https://github.com/rust-lang/mdBook/edit/master/guide/{path}"    
+        "#;
+
+    write_file(temp.path(), "book.toml", book_toml.as_bytes()).unwrap();
+
+    let md = MDBook::load(temp.path()).unwrap();
+    md.build().unwrap();
+
+    let index_html = temp.path().join("book").join("index.html");
+    assert_contains_strings(
+        index_html,
+        &[
+            r#"href="https://github.com/rust-lang/mdBook/edit/master/guide/src2/README.md" title="Suggest an edit""#,
+        ],
+    );
+}
+
 fn remove_absolute_components(path: &Path) -> impl Iterator<Item = Component> + '_ {
     path.components().skip_while(|c| match c {
         Component::Prefix(_) | Component::RootDir => true,
@@ -560,7 +612,7 @@ mod search {
         let index = fs::read_to_string(index).unwrap();
         let index = index.trim_start_matches("Object.assign(window.search, ");
         let index = index.trim_end_matches(");");
-        serde_json::from_str(&index).unwrap()
+        serde_json::from_str(index).unwrap()
     }
 
     #[test]
@@ -580,6 +632,7 @@ mod search {
         let introduction = get_doc_ref("intro.html#introduction");
         let some_section = get_doc_ref("first/index.html#some-section");
         let summary = get_doc_ref("first/includes.html#summary");
+        let no_headers = get_doc_ref("first/no-headers.html");
         let conclusion = get_doc_ref("conclusion.html#conclusion");
 
         let bodyidx = &index["index"]["index"]["body"]["root"];
@@ -593,13 +646,21 @@ mod search {
         assert_eq!(docs[&some_section]["body"], "");
         assert_eq!(
             docs[&summary]["body"],
-            "Dummy Book Introduction First Chapter Nested Chapter Includes Recursive Markdown Unicode Second Chapter Nested Chapter Conclusion"
+            "Dummy Book Introduction First Chapter Nested Chapter Includes Recursive Markdown Unicode No Headers Second Chapter Nested Chapter Conclusion"
         );
         assert_eq!(
             docs[&summary]["breadcrumbs"],
             "First Chapter » Includes » Summary"
         );
         assert_eq!(docs[&conclusion]["body"], "I put &lt;HTML&gt; in here!");
+        assert_eq!(
+            docs[&no_headers]["breadcrumbs"],
+            "First Chapter » No Headers"
+        );
+        assert_eq!(
+            docs[&no_headers]["body"],
+            "Capybara capybara capybara. Capybara capybara capybara."
+        );
     }
 
     // Setting this to `true` may cause issues with `cargo watch`,