Release 0.3.5.

Upgrade pulldown_cmark to 0.6

.gitattributes

@@ -2,7 +2,7 @@
 
 * text=auto eol=lf
 *.rs rust
-*.woff -text
-*.ttf -text
-*.otf -text
-*.png -text
+*.woff binary
+*.ttf binary
+*.otf binary
+*.png binary

.github/workflows/deploy.yml

@@ -0,0 +1,45 @@
+name: Deploy
+on:
+  release:
+    types: [created]
+
+jobs:
+  release:
+    name: Deploy Release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+    - uses: actions/checkout@master
+    - name: Install hub
+      run: ci/install-hub.sh ${{ matrix.os }}
+      shell: bash
+    - name: Install Rustup
+      run: ci/install-rustup.sh stable
+      shell: bash
+    - name: Install Rust
+      run: ci/install-rust.sh stable
+      shell: bash
+    - name: Build and deploy artifacts
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: ci/make-release.sh ${{ matrix.os }}
+      shell: bash
+  pages:
+    name: GitHub Pages
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@master
+    - name: Install Rust (rustup)
+      run: rustup update stable --no-self-update && rustup default stable
+    - name: Build book
+      run: cargo run -- build book-example
+    - name: Deploy to GitHub
+      env:
+        GITHUB_DEPLOY_KEY: ${{ secrets.GITHUB_DEPLOY_KEY }}
+      run: |
+        touch book-example/book/.nojekyll
+        curl -LsSf https://raw.githubusercontent.com/rust-lang/simpleinfra/master/setup-deploy-keys/src/deploy.rs | rustc - -o /tmp/deploy
+        cd book-example/book
+        /tmp/deploy

.github/workflows/main.yml

@@ -0,0 +1,53 @@
+name: CI
+on:
+  # Only run when merging to master, or open/synchronize/reopen a PR.
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  test:
+    name: Test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        build: [stable, beta, nightly, macos, windows, msrv]
+        include:
+          - build: stable
+            os: ubuntu-latest
+            rust: stable
+          - build: beta
+            os: ubuntu-latest
+            rust: beta
+          - build: nightly
+            os: ubuntu-latest
+            rust: nightly
+          - build: macos
+            os: macos-latest
+            rust: stable
+          - build: windows
+            os: windows-latest
+            rust: stable
+          - build: msrv
+            os: ubuntu-latest
+            rust: 1.35.0
+    steps:
+    - uses: actions/checkout@master
+    - name: Install Rustup
+      run: bash ci/install-rustup.sh ${{ matrix.rust }}
+    - name: Install Rust
+      run: bash ci/install-rust.sh ${{ matrix.rust }}
+    - name: Build and run tests
+      run: cargo test
+    - name: Test no default
+      run: cargo test --no-default-features
+
+  rustfmt:
+    name: Rustfmt
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@master
+    - name: Install Rust
+      run: rustup update stable && rustup default stable && rustup component add rustfmt
+    - run: cargo fmt -- --check

.gitignore

@@ -9,3 +9,5 @@ book-example/book
 .vscode
 tests/dummy_book/book/
 
+# Ignore Jetbrains specific files.
+.idea/

.travis.yml

@@ -1,48 +0,0 @@
-language: rust
-
-rust:
-  - stable
-  - beta
-  - nightly
-
-os:
-  - linux
-  - osx
-
-cache: 
-  timeout: 360
-  cargo: true
-
-before_cache:
-  - chmod -R a+r $HOME/.cargo
-
-env:
-  global:
-    - CRATE_NAME=mdbook
-
-script:
-  - cargo test --all
-  - cargo test --all --no-default-features
-
-before_deploy:
-  - sh ci/before_deploy.sh
-
-deploy:
-  provider: releases
-  api_key:
-    - secure: cURRWBr034iqBz/ifD7uOunBfNR30YxIXfgLX0osWz+iafkVbhDGYYz9sBmRraqO2P7L2koEXMADVb/md1kI2+ykiq/ml+l9zuEAZPVmvSGUN7ZD+7s+lu3l5OBPG5z175T+b2q2q2m8XVR7TW20ra4QbE0bq06KAoOyjSgQVBTSCYsL9uTsGwiVRMEqqJT/BmKhKJNkpGsTKyBSKkOXvfeAAbE260vXUDEN9TYdJ3fvteRrpwLX56ee64gIZUq0RjDc4SKIEqilM6iUtNMvurqaewYNGkiXKRruV6BPCHxEHo6NNT46kOJLBJTf7gZw//dWhSoWpg9P0gdAnPWm407kSa3F7aJ1eRShAFQ4BLyfz9efTqm+jP3fOp7Mm7igSh9w6caSRuOnSsUf5+raRQ8E5Y9HsWGzzpZQk24Fx9EGZ04EeDSdpZAFz+jcbMpHf8t2p4CEx0CCNwYvKx6EydMKbMF5QteQ8SQkXNLhv7Rz2OgtXWYZPRVCMfQfOplsi2InsLCrQxTgwh+6u654SqVSgaHG+IncEAxBrdWy4rHcg7qereUcKfcY3k96vaDxdn/T2c00Ig0aNFR91YnixGMd6J6tQgDcRK9jh6fUm1CCBE9hT+pNUmtgYKuWBoLZexUZFFnfuBed0WciBot1bGDDamndqKq0jJiAzg+GMHk=
-  file_glob: true
-  file: "$CRATE_NAME-$TRAVIS_TAG-$TARGET.*"
-  on:
-    condition: "$TRAVIS_RUST_VERSION = stable"
-    tags: true
-  skip_cleanup: true
-
-branches:
-  only:
-    - master
-    - /^v\d+\.\d+\.\d+.*$/
-
-notifications:
-  email:
-    on_success: never

CHANGELOG.md

@@ -0,0 +1,321 @@
+# Changelog
+
+## mdBook 0.3.5
+[6e0d0fa...efdb832](https://github.com/rust-lang/mdBook/compare/6e0d0fa...efdb832)
+
+### Changed
+- The `default-theme` config setting is now case-insensitive.
+  [#1079](https://github.com/rust-lang/mdBook/pull/1079)
+
+### Fixed
+- Fixed `#` hidden Rust code lines not rendering properly.
+  [#1088](https://github.com/rust-lang/mdBook/pull/1088)
+- Updated pulldown-cmark to 0.6.1, fixing several issues.
+  [#1021](https://github.com/rust-lang/mdBook/pull/1021)
+
+## mdBook 0.3.4
+[e5f77aa...6e0d0fa](https://github.com/rust-lang/mdBook/compare/e5f77aa...6e0d0fa)
+
+### Changed
+- Switch to relative `rem` font sizes from `px`.
+  [#894](https://github.com/rust-lang/mdBook/pull/894)
+- Migrated repository to https://github.com/rust-lang/mdBook/
+  [#1083](https://github.com/rust-lang/mdBook/pull/1083)
+
+## mdBook 0.3.3
+[2b649fe...e5f77aa](https://github.com/rust-lang/mdBook/compare/2b649fe...e5f77aa)
+
+### Changed
+- Improvements to the automatic dark theme selection.
+  [#1069](https://github.com/rust-lang/mdBook/pull/1069)
+- Fragment links now prevent scrolling the header behind the menu bar.
+  [#1077](https://github.com/rust-lang/mdBook/pull/1077)
+
+### Fixed
+- Fixed error when building a book that has a spacer immediately after the
+  first chapter.
+  [#1075](https://github.com/rust-lang/mdBook/pull/1075)
+
+## mdBook 0.3.2
+[9cd47eb...2b649fe](https://github.com/rust-lang/mdBook/compare/9cd47eb...2b649fe)
+
+### Added
+- Added a markdown renderer, which is off by default. This may be useful for
+  debugging preprocessors.
+  [#1018](https://github.com/rust-lang/mdBook/pull/1018)
+- Code samples may now include line numbers with the
+  `output.html.playpen.line-numbers` configuration value.
+  [#1035](https://github.com/rust-lang/mdBook/pull/1035)
+- The `watch` and `serve` commands will now ignore files listed in
+  `.gitignore`.
+  [#1044](https://github.com/rust-lang/mdBook/pull/1044)
+- Added automatic dark-theme detection based on the CSS `prefers-color-scheme`
+  feature. This may be enabled by setting `output.html.preferred-dark-theme`
+  to your preferred dark theme.
+  [#1037](https://github.com/rust-lang/mdBook/pull/1037)
+- Added `rustdoc_include` preprocessor. This makes it easier to include
+  portions of an external Rust source file. The rest of the file is hidden,
+  but the user may expand it to see the entire file, and will continue to work
+  with `mdbook test`.
+  [#1003](https://github.com/rust-lang/mdBook/pull/1003)
+- Added Ctrl-Enter shortcut to the playpen editor to automatically run the
+  sample.
+  [#1066](https://github.com/rust-lang/mdBook/pull/1066)
+- Added `output.html.playpen.copyable` configuration option to disable
+  the copy button.
+  [#1050](https://github.com/rust-lang/mdBook/pull/1050)
+- Added ability to dynamically expand and fold sections within the sidebar.
+  See the `output.html.fold` configuration to enable this feature.
+  [#1027](https://github.com/rust-lang/mdBook/pull/1027)
+
+### Changed
+- Use standard `scrollbar-color` CSS along with webkit extension
+  [#816](https://github.com/rust-lang/mdBook/pull/816)
+- The renderer build directory is no longer deleted before the renderer is
+  run. This allows a backend to cache results between runs.
+  [#985](https://github.com/rust-lang/mdBook/pull/985)
+- Next/prev links now highlight on hover to indicate it is clickable.
+  [#994](https://github.com/rust-lang/mdBook/pull/994)
+- Increase padding of table headers.
+  [#824](https://github.com/rust-lang/mdBook/pull/824)
+- Errors in `[output.html]` config are no longer ignored.
+  [#1033](https://github.com/rust-lang/mdBook/pull/1033)
+- Updated highlight.js for syntax highlighting updates (primarily to add
+  async/await to Rust highlighting).
+  [#1041](https://github.com/rust-lang/mdBook/pull/1041)
+- Raised minimum supported rust version to 1.35.
+  [#1003](https://github.com/rust-lang/mdBook/pull/1003)
+- Hidden code lines are no longer dynamically removed via JavaScript, but
+  instead managed with CSS.
+  [#846](https://github.com/rust-lang/mdBook/pull/846)
+  [#1065](https://github.com/rust-lang/mdBook/pull/1065)
+- Changed the default font set for the ACE editor, giving preference to
+  "Source Code Pro".
+  [#1062](https://github.com/rust-lang/mdBook/pull/1062)
+- Windows 32-bit releases are no longer published.
+  [#1071](https://github.com/rust-lang/mdBook/pull/1071)
+
+### Fixed
+- Fixed sidebar auto-scrolling.
+  [#1052](https://github.com/rust-lang/mdBook/pull/1052)
+- Fixed error message when running `clean` multiple times.
+  [#1055](https://github.com/rust-lang/mdBook/pull/1055)
+- Actually fix the "next" link on index.html. The previous fix didn't work.
+  [#1005](https://github.com/rust-lang/mdBook/pull/1005)
+- Stop using `inline-block` for `inline code`, fixing selection highlighting
+  and some rendering issues.
+  [#1058](https://github.com/rust-lang/mdBook/pull/1058)
+- Fix header auto-hide on browsers with momentum scrolling that allows
+  negative `scrollTop`.
+  [#1070](https://github.com/rust-lang/mdBook/pull/1070)
+
+## mdBook 0.3.1
+[69a08ef...9cd47eb](https://github.com/rust-lang/mdBook/compare/69a08ef...9cd47eb)
+
+### Added
+- 🔥 Added ability to include files using anchor points instead of line numbers.
+  [#851](https://github.com/rust-lang/mdBook/pull/851)
+- Added `language` configuration value to set the language of the book, which
+  will affect things like the `<html lang="en">` tag.
+  [#941](https://github.com/rust-lang/mdBook/pull/941)
+
+### Changed
+- Updated to handlebars 2.0.
+  [#977](https://github.com/rust-lang/mdBook/pull/977)
+
+### Fixed
+- Fixed memory leak warning.
+  [#967](https://github.com/rust-lang/mdBook/pull/967)
+- Fix more print.html links.
+  [#963](https://github.com/rust-lang/mdBook/pull/963)
+- Fixed crash on some unicode input.
+  [#978](https://github.com/rust-lang/mdBook/pull/978)
+
+## mdBook 0.3.0
+[6cbc41d...69a08ef](https://github.com/rust-lang/mdBook/compare/6cbc41d...69a08ef)
+
+### Added
+- Added ability to resize the sidebar.
+  [#849](https://github.com/rust-lang/mdBook/pull/849)
+- Added `load_with_config_and_summary` function to `MDBook` to be able to
+  build a book with a custom `Summary`.
+  [#883](https://github.com/rust-lang/mdBook/pull/883)
+- Set `noindex` on `print.html` page to prevent robots from indexing it.
+  [#844](https://github.com/rust-lang/mdBook/pull/844)
+- Added support for ~~strikethrough~~ and GitHub-style tasklists.
+  [#952](https://github.com/rust-lang/mdBook/pull/952)
+
+### Changed
+- Command-line help output is now colored.
+  [#861](https://github.com/rust-lang/mdBook/pull/861)
+- The build directory is now deleted before rendering starts, instead of after
+  if finishes.
+  [#878](https://github.com/rust-lang/mdBook/pull/878)
+- Removed dependency on `same-file` crate.
+  [#903](https://github.com/rust-lang/mdBook/pull/903)
+- 💥 Renamed `with_preprecessor` to `with_preprocessor`.
+  [#906](https://github.com/rust-lang/mdBook/pull/906)
+- Updated ACE editor to 1.4.4, should remove a JavaScript console warning.
+  [#935](https://github.com/rust-lang/mdBook/pull/935)
+- Dependencies have been updated.
+  [#934](https://github.com/rust-lang/mdBook/pull/934)
+  [#945](https://github.com/rust-lang/mdBook/pull/945)
+- Highlight.js has been updated. This fixes some TOML highlighting, and adds
+  Julia support.
+  [#942](https://github.com/rust-lang/mdBook/pull/942)
+- 🔥 Updated to pulldown-cmark 0.5. This may have significant changes to the
+  formatting of existing books, as the newer version has more accurate
+  interpretation of the CommonMark spec and a large number of bug fixes and
+  changes.
+  [#898](https://github.com/rust-lang/mdBook/pull/898)
+- The `diff` language should now highlight correctly.
+  [#943](https://github.com/rust-lang/mdBook/pull/943)
+- Make the blank region of a header not clickable.
+  [#948](https://github.com/rust-lang/mdBook/pull/948)
+- Rustdoc tests now use the preprocessed content instead of the raw,
+  unpreprocessed content.
+  [#891](https://github.com/rust-lang/mdBook/pull/891)
+
+### Fixed
+- Fixed file change detection so that `mdbook serve` only reloads once when
+  multiple files are changed at once.
+  [#870](https://github.com/rust-lang/mdBook/pull/870)
+- Fixed on-hover color highlighting for links in sidebar.
+  [#834](https://github.com/rust-lang/mdBook/pull/834)
+- Fixed loss of focus when clicking the "Copy" button in code blocks.
+  [#867](https://github.com/rust-lang/mdBook/pull/867)
+- Fixed incorrectly stripping the path for `additional-js` files.
+  [#796](https://github.com/rust-lang/mdBook/pull/796)
+- Fixed color of `code spans` that are links.
+  [#905](https://github.com/rust-lang/mdBook/pull/905)
+- Fixed "next" navigation on index.html.
+  [#916](https://github.com/rust-lang/mdBook/pull/916)
+- Fixed keyboard chapter navigation for `file` urls.
+  [#915](https://github.com/rust-lang/mdBook/pull/915)
+- Fixed bad wrapping for inline code on some browsers.
+  [#818](https://github.com/rust-lang/mdBook/pull/818)
+- Properly load an existing `SUMMARY.md` in `mdbook init`.
+  [#841](https://github.com/rust-lang/mdBook/pull/841)
+- Fixed some broken links in `print.html`.
+  [#871](https://github.com/rust-lang/mdBook/pull/871)
+- The Rust Playground link now supports the 2018 edition.
+  [#946](https://github.com/rust-lang/mdBook/pull/946)
+
+## mdBook 0.2.3 (2018-01-18)
+[2c20c99...6cbc41d](https://github.com/rust-lang/mdBook/compare/2c20c99...6cbc41d)
+
+### Added
+- Added an optional button to the top of the page which will link to a git
+  repository. Use the `git-repository-url` and `git-repository-icon` options
+  in the `[output.html]` section to enable it and set its appearance.
+  [#802](https://github.com/rust-lang/mdBook/pull/802)
+- Added a `default-theme` option to the `[output.html]` section.
+  [#804](https://github.com/rust-lang/mdBook/pull/804)
+
+### Changed
+- 💥 Header ID anchors no longer add an arbitrary `a` character for headers
+  that start with a non-ascii-alphabetic character.
+  [#788](https://github.com/rust-lang/mdBook/pull/788)
+
+### Fixed
+- Fix websocket hostname usage
+  [#865](https://github.com/rust-lang/mdBook/pull/865)
+- Fixing links in print.html
+  [#866](https://github.com/rust-lang/mdBook/pull/866)
+
+## mdBook 0.2.2 (2018-10-19)
+[7e2e095...2c20c99](https://github.com/rust-lang/mdBook/compare/7e2e095...2c20c99)
+
+### Added
+- 🎉 Process-based custom preprocessors. See [the
+  docs](https://rust-lang.github.io/mdBook/for_developers/preprocessors.html)
+  for more.
+  [#792](https://github.com/rust-lang/mdBook/pull/792)
+
+- 🎉 Configurable preprocessors.
+
+  Added `build.use-default-preprocessors` boolean TOML key to allow disabling
+  the built-in `links` and `index` preprocessors.
+
+  Added `[preprocessor]` TOML tables to configure each preprocessor.
+
+  Specifying `[preprocessor.links]` or `[preprocessor.index]` will enable the
+  respective built-in preprocessor if `build.use-default-preprocessors` is
+  `false`.
+
+  Added `fn supports_renderer(&self, renderer: &str) -> bool` to the
+  `Preprocessor` trait to specify if the preprocessor supports the given
+  renderer. The default implementation always returns `true`.
+
+  `Preprocessor::run` now takes a book by value instead of a mutable
+  reference. It should return a `Book` value with the intended modifications.
+
+  Added `PreprocessorContext::renderer` to indicate the renderer being used.
+
+  [#658](https://github.com/rust-lang/mdBook/pull/658)
+  [#787](https://github.com/rust-lang/mdBook/pull/787)
+
+### Fixed
+- Fix paths to additional CSS and JavaScript files
+  [#777](https://github.com/rust-lang/mdBook/pull/777)
+- Ensure section numbers are correctly incremented after a horizontal
+  separator
+  [#790](https://github.com/rust-lang/mdBook/pull/790)
+
+## mdBook 0.2.1 (2018-08-22)
+[91ffca1...7e2e095](https://github.com/rust-lang/mdBook/compare/91ffca1...7e2e095)
+
+### Changed
+- Update to handlebars-rs 1.0
+  [#761](https://github.com/rust-lang/mdBook/pull/761)
+
+### Fixed
+- Fix table colors, broken by Stylus -> CSS transition
+  [#765](https://github.com/rust-lang/mdBook/pull/765)
+
+## mdBook 0.2.0 (2018-08-02)
+
+### Changed
+- 💥 This release changes how links are handled in mdBook. Previously, relative
+  links were interpreted relative to the book's root. In `0.2.0`+ links are
+  relative to the page they are in, and use the `.md` extension. This has [several
+  advantages](https://github.com/rust-lang/mdBook/pull/603#issue-166701447),
+  such as making links work in other markdown viewers like GitHub. You will
+  likely have to change links in your book to accommodate this change. For
+  example, a book with this layout:
+
+  ```
+  chapter_1/
+      section_1.md
+      section_2.md
+  SUMMARY.md
+  ```
+
+  Previously a link in `section_1.md` to `section_2.md` would look like this:
+  ```markdown
+  [section_2](chapter_1/section_2.html)
+  ```
+
+  Now it must be changed to this:
+  ```markdown
+  [section_2](section_2.md)
+  ```
+
+- 💥 `mdbook test --library-path` now accepts a comma-delimited list of
+  arguments rather than taking all following arguments. This makes it easier
+  to handle the trailing book directory argument without always needing to put
+  ` -- ` before it. Multiple instances of the option continue to be accepted:
+  `mdbook test -L foo -L bar`.
+
+- 💥 `mdbook serve` has some of its options renamed for clarity. See `mdbook
+  help serve` for details.
+
+- Embedded rust playpens now use the "stable" playground API.
+  [#754](https://github.com/rust-lang/mdBook/pull/754)
+
+### Fixed
+- Escaped includes (`\{{#include file.rs}}`) will now render correctly.
+  [f30ce01](https://github.com/rust-lang/mdBook/commit/f30ce0184d71e342141145472bf816419d30a2c5)
+- `index.html` will now render correctly when the book's first section is
+  inside a subdirectory.
+  [#756](https://github.com/rust-lang/mdBook/pull/756)

CONTRIBUTING.md

@@ -5,22 +5,22 @@ Welcome stranger!
 If you have come here to learn how to contribute to mdBook, we have some tips for you!
 
 First of all, don't hesitate to ask questions!
-Use the [issue tracker](https://github.com/rust-lang-nursery/mdBook/issues), no question is too simple.
+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
 
 Any issue is up for the grabbing, but if you are starting out, you might be interested in the
-[E-Easy issues](https://github.com/rust-lang-nursery/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AE-Easy).
+[E-Easy issues](https://github.com/rust-lang/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AE-Easy).
 Those are issues that are considered more straightforward for beginners to Rust or the codebase itself.
 These issues can be a good launching pad for more involved issues. Easy tasks for a first time contribution
 include documentation improvements, new tests, examples, updating dependencies, etc.
 
 If you come from a web development background, you might be interested in issues related to web technologies tagged
-[A-JavaScript](https://github.com/rust-lang-nursery/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AA-JavaScript),
-[A-Style](https://github.com/rust-lang-nursery/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AA-Style),
-[A-HTML](https://github.com/rust-lang-nursery/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AA-HTML) or
-[A-Mobile](https://github.com/rust-lang-nursery/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AA-Mobile).
+[A-JavaScript](https://github.com/rust-lang/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AA-JavaScript),
+[A-Style](https://github.com/rust-lang/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AA-Style),
+[A-HTML](https://github.com/rust-lang/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AA-HTML) or
+[A-Mobile](https://github.com/rust-lang/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AA-Mobile).
 
 When you decide you want to work on a specific issue, ping us on that issue so that we can assign it to you.
 Again, do not hesitate to ask questions. We will gladly mentor anyone that want to tackle an issue.
@@ -41,7 +41,7 @@ mdBook builds on stable Rust, if you want to build mdBook from source, here are
 0. Clone this repository with git.
 
    ```
-   git clone https://github.com/rust-lang-nursery/mdBook.git
+   git clone https://github.com/rust-lang/mdBook.git
    ```
 0. Navigate into the newly created `mdBook` directory
 0. Run `cargo build`
@@ -57,12 +57,12 @@ We love code quality and Rust has some excellent tools to assist you with contri
 Before you make your Pull Request to the project, please run it through the `rustfmt` utility.
 This will ensure we have good quality source code that is better for us all to maintain.
 
-[rustfmt](https://github.com/rust-lang-nursery/rustfmt) has a lot more information on the project.
+[rustfmt](https://github.com/rust-lang/rustfmt) has a lot more information on the project.
 The quick guide is
 
 1. Install it
     ```
-    rustup component add rustfmt-preview
+    rustup component add rustfmt
     ```
 1. You can now run `rustfmt` on a single file simply by...
     ```
@@ -74,7 +74,7 @@ The quick guide is
    ```
    When run through `cargo` it will format all bin and lib files in the current crate.
 
-For more information, such as running it from your favourite editor, please see the `rustfmt` project. [rustfmt](https://github.com/rust-lang-nursery/rustfmt)
+For more information, such as running it from your favourite editor, please see the `rustfmt` project. [rustfmt](https://github.com/rust-lang/rustfmt)
 
 
 #### Finding Issues with Clippy
@@ -83,21 +83,18 @@ Clippy is a code analyser/linter detecting mistakes, and therfore helps to impro
 Like formatting your code with `rustfmt`, running clippy regularly and before your Pull Request will
 help us maintain awesome code.
 
-The best documentation can be found over at [rust-clippy](https://github.com/rust-lang-nursery/rust-clippy)
+The best documentation can be found over at [rust-clippy](https://github.com/rust-lang/rust-clippy)
 
 1. To install
     ```
-    rustup update
-    rustup install nightly
-    rustup component add clippy-preview --toolchain=nightly
+    rustup component add clippy
     ```
 2. Running clippy
-    As you may notice from the previous step, Clippy is on the nightly branch, so running it is like
     ```
-    cargo +nightly clippy
+    cargo clippy
     ```
 
-Clippy has an ever growing list of checks, that are managed in [lint files](https://rust-lang-nursery.github.io/rust-clippy/master/index.html).
+Clippy has an ever growing list of checks, that are managed in [lint files](https://rust-lang.github.io/rust-clippy/master/index.html).
 
 ### Making a pull-request
 
@@ -105,7 +102,7 @@ When you feel comfortable that your changes could be integrated into mdBook, you
 One of the core maintainers will then approve the changes or request some changes before it gets merged.
 
 If you want to make your pull-request even better, you might want to run [Clippy](https://github.com/Manishearth/rust-clippy)
-and [rustfmt](https://github.com/rust-lang-nursery/rustfmt) on the code first.
+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:

Cargo.toml

@@ -1,63 +1,64 @@
 [package]
 name = "mdbook"
-version = "0.2.2-alpha.0"
+version = "0.3.5"
 authors = [
-    "Mathieu David <mathieudavid@mathieudavid.org>", 
+    "Mathieu David <mathieudavid@mathieudavid.org>",
     "Michael-F-Bryan <michaelfbryan@gmail.com>",
     "Matt Ickstadt <mattico8@gmail.com>"
 ]
-description = "Create books from markdown files"
-documentation = "http://rust-lang-nursery.github.io/mdBook/index.html"
-repository = "https://github.com/rust-lang-nursery/mdBook"
+documentation = "http://rust-lang.github.io/mdBook/index.html"
+edition = "2018"
+exclude = ["/book-example/*"]
 keywords = ["book", "gitbook", "rustbook", "markdown"]
 license = "MPL-2.0"
 readme = "README.md"
-exclude = ["book-example/*"]
+repository = "https://github.com/rust-lang/mdBook"
+description = "Creates a book from markdown files"
 
 [dependencies]
-clap = "2.24"
 chrono = "0.4"
-handlebars = "1.0"
-serde = "1.0"
-serde_derive = "1.0"
+clap = "2.24"
+env_logger = "0.6"
 error-chain = "0.12"
-serde_json = "1.0"
-pulldown-cmark = "0.1.2"
+handlebars = { version = "2.0", default-features = false, features = ["no_dir_source"] }
+itertools = "0.8"
 lazy_static = "1.0"
 log = "0.4"
-env_logger = "0.5"
-toml = "0.4"
 memchr = "2.0"
 open = "1.1"
+pulldown-cmark = "0.6.1"
 regex = "1.0.0"
-tempfile = "3.0"
-itertools = "0.7"
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"
 shlex = "0.1"
-toml-query = "0.7"
+tempfile = "3.0"
+toml = "0.5.1"
+toml-query = "0.9"
 
 # Watch feature
 notify = { version = "4.0", optional = true }
+gitignore = { version = "1.0", optional = true }
 
 # Serve feature
 iron = { version = "0.6", optional = true }
 staticfile = { version = "0.5", optional = true }
-ws = { version = "0.7", optional = true}
+ws = { version = "0.9", optional = true}
 
 # Search feature
 elasticlunr-rs = { version = "2.3", optional = true, default-features = false }
-ammonia = { version = "1.1", optional = true }
+ammonia = { version = "3", optional = true }
 
 [dev-dependencies]
 select = "0.4"
-pretty_assertions = "0.5"
+pretty_assertions = "0.6"
 walkdir = "2.0"
-pulldown-cmark-to-cmark = "1.1.0"
 
 [features]
 default = ["output", "watch", "serve", "search"]
 debug = []
 output = []
-watch = ["notify"]
+watch = ["notify", "gitignore"]
 serve = ["iron", "staticfile", "ws"]
 search = ["elasticlunr-rs", "ammonia"]
 

README.md

@@ -1,25 +1,8 @@
 # mdBook
 
-<table>
-    <tr>
-        <td><strong>Linux / OS X</strong></td>
-        <td>
-            <a href="https://travis-ci.org/rust-lang-nursery/mdBook"><img src="https://travis-ci.org/rust-lang-nursery/mdBook.svg?branch=master"></a>
-        </td>
-    </tr>
-    <tr>
-        <td><strong>Windows</strong></td>
-        <td>
-            <a href="https://ci.appveyor.com/project/rust-lang-libs/mdbook"><img src="https://ci.appveyor.com/api/projects/status/ysyke2rvo85sni55?svg=true"></a>
-        </td>
-    </tr>
-    <tr>
-        <td colspan="2">
-            <a href="https://crates.io/crates/mdbook"><img src="https://img.shields.io/crates/v/mdbook.svg"></a>
-            <a href="LICENSE"><img src="https://img.shields.io/github/license/rust-lang-nursery/mdBook.svg"></a>
-        </td>
-    </tr>
-</table>
+[![Build Status](https://github.com/rust-lang/mdBook/workflows/CI/badge.svg)](https://github.com/rust-lang/mdBook/actions?workflow=CI)
+[![crates.io](https://img.shields.io/crates/v/mdbook.svg)](https://crates.io/crates/mdbook)
+[![LICENSE](https://img.shields.io/github/license/rust-lang/mdBook.svg)](LICENSE)
 
 mdBook is a utility to create modern online books from Markdown files.
 
@@ -41,7 +24,7 @@ There are multiple ways to install mdBook.
 
 2. **From Crates.io**
 
-   This requires at least [Rust] 1.20 and Cargo to be installed. Once you have installed
+   This requires at least [Rust] 1.35 and Cargo to be installed. Once you have installed
    Rust, type the following in the terminal:
 
    ```
@@ -57,7 +40,7 @@ There are multiple ways to install mdBook.
    another CI server, we recommend that you specify a semver version range for
    mdBook when you install it through your script!
 
-   This will constrain the server to install the latests **non-breaking**
+   This will constrain the server to install the latest **non-breaking**
    version of mdBook and will prevent your books from failing to build because
    we released a new version. For example:
 
@@ -65,25 +48,25 @@ There are multiple ways to install mdBook.
    cargo install mdbook --vers "^0.1.0"
    ```
 
-3. **From Git**  
+3. **From Git**
 
    The version published to crates.io will ever so slightly be behind the
    version hosted here on GitHub. If you need the latest version you can build
    the git version of mdBook yourself. Cargo makes this ***super easy***!
 
    ```
-   cargo install --git https://github.com/rust-lang-nursery/mdBook.git mdbook
+   cargo install --git https://github.com/rust-lang/mdBook.git mdbook
    ```
 
    Again, make sure to add the Cargo bin directory to your `PATH`.
 
-4. **For Contributions**  
+4. **For Contributions**
 
    If you want to contribute to mdBook you will have to clone the repository on
    your local machine:
 
    ```
-   git clone https://github.com/rust-lang-nursery/mdBook.git
+   git clone https://github.com/rust-lang/mdBook.git
    ```
 
    `cd` into `mdBook/` and run
@@ -152,9 +135,9 @@ party plugins. These plugins are just programs which will be invoked during the
 build process and are split into roughly two categories, *preprocessors* and
 *renderers*.
 
-Preprocessors are used to transform a book before it is sent to a renderer. 
-One example would be to replace all occurrences of 
-`{{#include some_file.ext}}` with the contents of that file. Some existing 
+Preprocessors are used to transform a book before it is sent to a renderer.
+One example would be to replace all occurrences of
+`{{#include some_file.ext}}` with the contents of that file. Some existing
 preprocessors are:
 
 - `index` - a built-in preprocessor (enabled by default) which will transform
@@ -169,6 +152,9 @@ format, however there's nothing stopping a renderer from doing static analysis
 of a book in order to validate links or run tests. Some existing renderers are:
 
 - `html` - the built-in renderer which will generate a HTML version of the book
+- `markdown` - the built-in renderer (disabled by default) which will run
+  preprocessors then output the resulting Markdown. Useful for debugging
+  preprocessors.
 - [`linkcheck`] - a backend which will check that all links are valid
 - [`epub`] - an experimental EPUB generator
 
@@ -231,14 +217,14 @@ available, for those hacking on `master`.
 All the code in this repository is released under the ***Mozilla Public License v2.0***, for more information take a look at the [LICENSE] file.
 
 
-[User Guide]: https://rust-lang-nursery.github.io/mdBook/
+[User Guide]: https://rust-lang.github.io/mdBook/
 [API docs]: https://docs.rs/mdbook/*/mdbook/
-[E-Easy]: https://github.com/rust-lang-nursery/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AE-Easy
-[contribution guide]: https://github.com/rust-lang-nursery/mdBook/blob/master/CONTRIBUTING.md
-[LICENSE]: https://github.com/rust-lang-nursery/mdBook/blob/master/LICENSE
-[releases]: https://github.com/rust-lang-nursery/mdBook/releases
+[E-Easy]: https://github.com/rust-lang/mdBook/issues?q=is%3Aopen+is%3Aissue+label%3AE-Easy
+[contribution guide]: https://github.com/rust-lang/mdBook/blob/master/CONTRIBUTING.md
+[LICENSE]: https://github.com/rust-lang/mdBook/blob/master/LICENSE
+[releases]: https://github.com/rust-lang/mdBook/releases
 [Rust]: https://www.rust-lang.org/
-[CLI docs]: http://rust-lang-nursery.github.io/mdBook/cli/init.html
-[master-docs]: http://rust-lang-nursery.github.io/mdBook/mdbook/
+[CLI docs]: http://rust-lang.github.io/mdBook/cli/init.html
+[master-docs]: http://rust-lang.github.io/mdBook/
 [`linkcheck`]: https://crates.io/crates/mdbook-linkcheck
-[`epub`]: https://crates.io/crates/mdbook-epub
+[`epub`]: https://crates.io/crates/mdbook-epub

appveyor.yml

@@ -1,64 +0,0 @@
-environment:
-  global:
-    PROJECT_NAME: mdBook
-  matrix:
-    # Stable channel
-    - TARGET: i686-pc-windows-msvc
-      RUST_CHANNEL: stable
-    - TARGET: x86_64-pc-windows-msvc
-      RUST_CHANNEL: stable
-    # Beta channel
-    - TARGET: i686-pc-windows-msvc
-      RUST_CHANNEL: beta
-    - TARGET: x86_64-pc-windows-msvc
-      RUST_CHANNEL: beta
-    # Nightly channel
-    - TARGET: i686-pc-windows-msvc
-      RUST_CHANNEL: nightly
-    - TARGET: x86_64-pc-windows-msvc
-      RUST_CHANNEL: nightly
-
-# Install Rust and Cargo
-install:
-  - ps: >-
-      If ($Env:TARGET -eq 'x86_64-pc-windows-gnu') {
-        $Env:PATH += ';C:\msys64\mingw64\bin'
-      } ElseIf ($Env:TARGET -eq 'i686-pc-windows-gnu') {
-        $Env:PATH += ';C:\msys64\mingw32\bin'
-      }
-  - curl -sSf -o rustup-init.exe https://win.rustup.rs/
-  - rustup-init.exe -y --default-host %TARGET% --default-toolchain %RUST_CHANNEL%
-  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
-  - rustc -Vv
-  - cargo -V
-
-build: false
-
-# Equivalent to Travis' `script` phase
-test_script:
-  - cargo test --all
-  - cargo test --all --no-default-features
-
-before_deploy:
-  # Generate artifacts for release
-  - cargo rustc --bin mdbook --release -- -C lto
-  - mkdir staging
-  - copy target\release\mdbook.exe staging
-  - cd staging
-  - 7z a ../%PROJECT_NAME%-%APPVEYOR_REPO_TAG_NAME%-%TARGET%.zip *
-  - appveyor PushArtifact ../%PROJECT_NAME%-%APPVEYOR_REPO_TAG_NAME%-%TARGET%.zip
-
-deploy:
-  description: 'Windows release'
-  artifact: /.*\.zip/
-  auth_token:
-    secure: QQhjKVyz7mpjlyGhlXytbFQQfKFQWTahHkD+B0NzIUoEVqO7ZLWjnoWasvLqW4nE
-  provider: GitHub
-  on:
-    RUST_CHANNEL: stable
-    appveyor_repo_tag: true
-
-branches:
-  only:
-    - master
-    - /^v\d+\.\d+\.\d+.*$/

book-example/book.toml

@@ -2,12 +2,14 @@
 title = "mdBook Documentation"
 description = "Create book from markdown files. Like Gitbook but implemented in Rust"
 authors = ["Mathieu David", "Michael-F-Bryan"]
+language = "en"
 
 [output.html]
 mathjax-support = true
 
 [output.html.playpen]
 editable = true
+line-numbers = true
 
 [output.html.search]
 limit-results = 20

book-example/src/README.md

@@ -8,9 +8,9 @@ What you are reading serves as an example of the output of mdBook and at the
 same time as a high-level documentation.
 
 mdBook is free and open source, you can find the source code on
-[GitHub](https://github.com/rust-lang-nursery/mdBook). Issues and feature
+[GitHub](https://github.com/rust-lang/mdBook). Issues and feature
 requests can be posted on the [GitHub issue
-tracker](https://github.com/rust-lang-nursery/mdBook/issues).
+tracker](https://github.com/rust-lang/mdBook/issues).
 
 ## API docs
 

book-example/src/SUMMARY.md

@@ -20,7 +20,7 @@
 - [Continuous Integration](continuous-integration.md)
 - [For Developers](for_developers/README.md)
     - [Preprocessors](for_developers/preprocessors.md)
-    - [Alternate Backends](for_developers/backends.md)
+    - [Alternative Backends](for_developers/backends.md)
 
 -----------
 

book-example/src/cli/README.md

@@ -7,7 +7,7 @@ capabilities first.
 ## Install From Binaries
 
 Precompiled binaries are provided for major platforms on a best-effort basis.
-Visit [the releases page](https://github.com/rust-lang-nursery/mdBook/releases)
+Visit [the releases page](https://github.com/rust-lang/mdBook/releases)
 to download the appropriate version for your platform.
 
 ## Install From Source
@@ -18,7 +18,7 @@ mdBook can also be installed from source
 
 mdBook is written in **[Rust](https://www.rust-lang.org/)** and therefore needs
 to be compiled with **Cargo**. If you haven't already installed Rust, please go
-ahead and [install it](https://www.rust-lang.org/downloads.html) now.
+ahead and [install it](https://www.rust-lang.org/tools/install) now.
 
 ### Install Crates.io version
 
@@ -39,14 +39,14 @@ have installed mdBook!
 
 ### Install Git version
 
-The **[git version](https://github.com/rust-lang-nursery/mdBook)** contains all
+The **[git version](https://github.com/rust-lang/mdBook)** contains all
 the latest bug-fixes and features, that will be released in the next version on
 **Crates.io**, if you can't wait until the next release. You can build the git
 version yourself. Open your terminal and navigate to the directory of you
 choice. We need to clone the git repository and then build it with Cargo.
 
 ```bash
-git clone --depth=1 https://github.com/rust-lang-nursery/mdBook.git
+git clone --depth=1 https://github.com/rust-lang/mdBook.git
 cd mdBook
 cargo build --release
 ```

book-example/src/cli/build.md

@@ -29,8 +29,9 @@ your default web browser after building it.
 #### --dest-dir
 
 The `--dest-dir` (`-d`) option allows you to change the output directory for the
-book. If not specified it will default to the value of the `build.build-dir` key
-in `book.toml`, or to `./book` relative to the book's root directory.
+book. Relative paths are interpreted relative to the book's root directory. If
+not specified it will default to the value of the `build.build-dir` key in
+`book.toml`, or to `./book`.
 
 -------------------
 

book-example/src/cli/clean.md

@@ -19,9 +19,9 @@ mdbook clean path/to/book
 #### --dest-dir
 
 The `--dest-dir` (`-d`) option allows you to override the book's output
-directory, which will be deleted by this command. If not specified it will
-default to the value of the `build.build-dir` key in `book.toml`, or to `./book`
-relative to the book's root directory.
+directory, which will be deleted by this command. Relative paths are interpreted
+relative to the book's root directory. If not specified it will default to the
+value of the `build.build-dir` key in `book.toml`, or to `./book`.
 
 ```bash
 mdbook clean --dest-dir=path/to/book

book-example/src/cli/serve.md

@@ -5,6 +5,9 @@ The serve command is used to preview a book by serving it over HTTP at
 changes, rebuilding the book and refreshing clients for each change. 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
+intended to be a complete HTTP server for a website.*
+
 #### Specify a directory
 
 The `serve` command can take a directory as an argument to use as the book's
@@ -34,16 +37,12 @@ configured.
 
 #### --open
 
-When you use the `--open` (`-o`) flag, mdbook will open the book in your your
+When you use the `--open` (`-o`) flag, mdbook will open the book in your
 default web browser after starting the server.
 
 #### --dest-dir
 
 The `--dest-dir` (`-d`) option allows you to change the output directory for the
-book. If not specified it will default to the value of the `build.build-dir` key
-in `book.toml`, or to `./book` relative to the book's root directory.
-
------
-
-***Note:*** *The `serve` command is for testing, and is not intended to be a
-complete HTTP server for a website.*
+book. Relative paths are interpreted relative to the book's root directory. If
+not specified it will default to the value of the `build.build-dir` key in
+`book.toml`, or to `./book`.

book-example/src/cli/test.md

@@ -48,5 +48,6 @@ comma-delimited list (`-L foo,bar`).
 #### --dest-dir
 
 The `--dest-dir` (`-d`) option allows you to change the output directory for the
-book. If not specified it will default to the value of the `build.build-dir` key
-in `book.toml`, or to `./book` relative to the book's root directory.
+book. Relative paths are interpreted relative to the book's root directory. If
+not specified it will default to the value of the `build.build-dir` key in
+`book.toml`, or to `./book`.

book-example/src/cli/watch.md

@@ -22,5 +22,6 @@ your default web browser.
 #### --dest-dir
 
 The `--dest-dir` (`-d`) option allows you to change the output directory for the
-book. If not specified it will default to the value of the `build.build-dir` key
-in `book.toml`, or to `./book` relative to the book's root directory.
+book. Relative paths are interpreted relative to the book's root directory. If
+not specified it will default to the value of the `build.build-dir` key in
+`book.toml`, or to `./book`.

book-example/src/continuous-integration.md

@@ -22,7 +22,7 @@ rust:
 
 before_script:
   - (test -x $HOME/.cargo/bin/cargo-install-update || cargo install cargo-update)
-  - (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.1" mdbook)
+  - (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.3" mdbook)
   - cargo install-update -a
 
 script:
@@ -54,3 +54,36 @@ deploy:
 ```
 
 That's it!
+
+### Deploying to GitHub Pages manually
+
+If your CI doesn't support GitHub pages, or you're deploying somewhere else
+with integrations such as Github Pages:
+ *note: you may want to use different tmp dirs*:
+
+```console
+$> git worktree add /tmp/book gh-pages
+$> mdbook build
+$> rm -rf /tmp/book/* # this won't delete the .git directory
+$> cp -rp book/* /tmp/book/
+$> cd /tmp/book
+$> git add -A
+$> git commit 'new book message'
+$> git push origin gh-pages
+$> cd -
+```
+
+Or put this into a Makefile rule:
+
+```makefile
+.PHONY: deploy
+deploy: book
+	@echo "====> deploying to github"
+	git worktree add /tmp/book gh-pages
+	rm -rf /tmp/book/*
+	cp -rp book/* /tmp/book/
+	cd /tmp/book && \
+		git add -A && \
+		git commit -m "deployed on $(shell date) by ${USER}" && \
+		git push origin gh-pages
+```

book-example/src/for_developers/README.md

@@ -12,14 +12,14 @@ The *For Developers* chapters are here to show you the more advanced usage of
 The two main ways a developer can hook into the book's build process is via,
 
 - [Preprocessors](preprocessors.md)
-- [Alternate Backends](backends.md)
+- [Alternative Backends](backends.md)
 
 
 ## The Build Process
 
 The process of rendering a book project goes through several steps.
 
-1. Load the book 
+1. Load the book
     - Parse the `book.toml`, falling back to the default `Config` if it doesn't
        exist
     - Load the book chapters into memory
@@ -41,6 +41,6 @@ The easiest way to find out how to use the `mdbook` crate is by looking at the
 explanation on the configuration system.
 
 
-[`MDBook`]: http://rust-lang-nursery.github.io/mdBook/mdbook/book/struct.MDBook.html
+[`MDBook`]: https://docs.rs/mdbook/*/mdbook/book/struct.MDBook.html
 [API Docs]: https://docs.rs/mdbook/*/mdbook/
-[config]: file:///home/michael/Documents/forks/mdBook/target/doc/mdbook/config/index.html
+[config]: https://docs.rs/mdbook/*/mdbook/config/index.html

book-example/src/for_developers/backends.md

@@ -1,11 +1,11 @@
-# Alternate Backends
+# Alternative Backends
 
 A "backend" is simply a program which `mdbook` will invoke during the book
 rendering process. This program is passed a JSON representation of the book and
 configuration information via `stdin`. Once the backend receives this
 information it is free to do whatever it wants.
 
-There are already several alternate backends on GitHub which can be used as a
+There are already several alternative backends on GitHub which can be used as a
 rough example of how this is accomplished in practice.
 
 - [mdbook-linkcheck] - a simple program for verifying the book doesn't contain
@@ -14,7 +14,7 @@ rough example of how this is accomplished in practice.
 - [mdbook-test] - a program to run the book's contents through [rust-skeptic] to
   verify everything compiles and runs correctly (similar to `rustdoc --test`)
 
-This page will step you through creating your own alternate backend in the form
+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
 no reason why it couldn't be accomplished using something like Python or Ruby.
 
@@ -24,9 +24,9 @@ no reason why it couldn't be accomplished using something like Python or Ruby.
 First you'll want to create a new binary program and add `mdbook` as a
 dependency.
 
-```
+```shell
 $ cargo new --bin mdbook-wordcount
-$ cd mdbook-wordcount 
+$ cd mdbook-wordcount
 $ cargo add mdbook
 ```
 
@@ -52,8 +52,8 @@ fn main() {
 > **Note:** The `RenderContext` contains a `version` field. This lets backends
   figure out whether they are compatible with the version of `mdbook` it's being
   called by. This `version` comes directly from the corresponding field in
-  `mdbook`'s `Cargo.toml`. 
-  
+  `mdbook`'s `Cargo.toml`.
+
   It is recommended that backends use the [`semver`] crate to inspect this field
   and emit a warning if there may be a compatibility issue.
 
@@ -92,12 +92,12 @@ fn count_words(ch: &Chapter) -> usize {
 Now we've got the basics running, we want to actually use it. First, install the
 program.
 
-```
-$ cargo install
+```shell
+$ cargo install --path .
 ```
 
 Then `cd` to the particular book you'd like to count the words of and update its
-`book.toml` file. 
+`book.toml` file.
 
 ```diff
   [book]
@@ -112,7 +112,7 @@ Then `cd` to the particular book you'd like to count the words of and update its
 
 When it loads a book into memory, `mdbook` will inspect your `book.toml` file to
 try and figure out which backends to use by looking for all `output.*` tables.
-If none are provided it'll fall back to using the default HTML renderer. 
+If none are provided it'll fall back to using the default HTML renderer.
 
 Notably, this means if you want to add your own custom backend you'll also need
 to make sure to add the HTML backend, even if its table just stays empty.
@@ -120,7 +120,7 @@ to make sure to add the HTML backend, even if its table just stays empty.
 Now you just need to build your book like normal, and everything should *Just
 Work*.
 
-```
+```shell
 $ mdbook build
 ...
 2018-01-16 07:31:15 [INFO] (mdbook::renderer): Invoking the "mdbook-wordcount" renderer
@@ -140,7 +140,7 @@ Syntax highlighting: 314
 MathJax Support: 153
 Rust code specific features: 148
 For Developers: 788
-Alternate Backends: 710
+Alternative Backends: 710
 Contributors: 85
 ```
 
@@ -169,7 +169,7 @@ arguments or be an interpreted script), you can use the `command` field.
 Now imagine you don't want to count the number of words on a particular chapter
 (it might be generated text/code, etc). The canonical way to do this is via the
 usual `book.toml` configuration file by adding items to your `[output.foo]`
-table. 
+table.
 
 The `Config` can be treated roughly as a nested hashmap which lets you call
 methods like `get()` to access the config's contents, with a
@@ -211,13 +211,13 @@ and then add a check to make sure we skip ignored chapters.
 +     let cfg: WordcountConfig = ctx.config
 +         .get_deserialized("output.wordcount")
 +         .unwrap_or_default();
-  
+
       for item in ctx.book.iter() {
           if let BookItem::Chapter(ref ch) = *item {
 +             if cfg.ignores.contains(&ch.name) {
 +                 continue;
 +             }
-+ 
++
               let num_words = count_words(ch);
               println!("{}: {}", ch.name, num_words);
           }
@@ -239,17 +239,17 @@ in [`RenderContext`].
 - use std::io;
   use mdbook::renderer::RenderContext;
   use mdbook::book::{BookItem, Chapter};
-  
+
   fn main() {
     ...
-  
+
 +     let _ = fs::create_dir_all(&ctx.destination);
 +     let mut f = File::create(ctx.destination.join("wordcounts.txt")).unwrap();
-+ 
++
       for item in ctx.book.iter() {
           if let BookItem::Chapter(ref ch) = *item {
               ...
-  
+
               let num_words = count_words(ch);
               println!("{}: {}", ch.name, num_words);
 +             writeln!(f, "{}: {}", ch.name, num_words).unwrap();
@@ -261,6 +261,10 @@ in [`RenderContext`].
 > **Note:** There is no guarantee that the destination directory exists or is
 > empty (`mdbook` may leave the previous contents to let backends do caching),
 > so it's always a good idea to create it with `fs::create_dir_all()`.
+>
+> If the destination directory already exists, don't assume it will be empty.
+> To allow backends to cache the results from previous runs, `mdbook` may leave
+> old content in the directory.
 
 There's always the possibility that an error will occur while processing a book
 (just look at all the `unwrap()`'s we've written already), so `mdbook` will
@@ -276,11 +280,11 @@ like this:
 
   fn main() {
       ...
-  
+
       for item in ctx.book.iter() {
           if let BookItem::Chapter(ref ch) = *item {
               ...
-  
+
               let num_words = count_words(ch);
               println!("{}: {}", ch.name, num_words);
               writeln!(f, "{}: {}", ch.name, num_words).unwrap();
@@ -303,8 +307,8 @@ like this:
 
 Now, if we reinstall the backend and build a book,
 
-```
-$ cargo install --force
+```shell
+$ cargo install --path . --force
 $ mdbook build /path/to/book
 ...
 2018-01-16 21:21:39 [INFO] (mdbook::renderer): Invoking the "wordcount" renderer
@@ -329,7 +333,7 @@ the usual `RUST_LOG` to control logging verbosity.
 ## Wrapping Up
 
 Although contrived, hopefully this example was enough to show how you'd create
-an alternate backend for `mdbook`. If you feel it's missing something, don't
+an alternative backend for `mdbook`. If you feel it's missing something, don't
 hesitate to create an issue in the [issue tracker] so we can improve the user
 guide.
 
@@ -342,10 +346,10 @@ the source code or ask questions.
 [mdbook-epub]: https://github.com/Michael-F-Bryan/mdbook-epub
 [mdbook-test]: https://github.com/Michael-F-Bryan/mdbook-test
 [rust-skeptic]: https://github.com/budziq/rust-skeptic
-[`RenderContext`]: http://rust-lang-nursery.github.io/mdBook/mdbook/renderer/struct.RenderContext.html
-[`RenderContext::from_json()`]: http://rust-lang-nursery.github.io/mdBook/mdbook/renderer/struct.RenderContext.html#method.from_json
+[`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
 [`semver`]: https://crates.io/crates/semver
-[`Book`]: http://rust-lang-nursery.github.io/mdBook/mdbook/book/struct.Book.html
-[`Book::iter()`]: http://rust-lang-nursery.github.io/mdBook/mdbook/book/struct.Book.html#method.iter
-[`Config`]: http://rust-lang-nursery.github.io/mdBook/mdbook/config/struct.Config.html
-[issue tracker]: https://github.com/rust-lang-nursery/mdBook/issues
+[`Book`]: https://docs.rs/mdbook/*/mdbook/book/struct.Book.html
+[`Book::iter()`]: https://docs.rs/mdbook/*/mdbook/book/struct.Book.html#method.iter
+[`Config`]: https://docs.rs/mdbook/*/mdbook/config/struct.Config.html
+[issue tracker]: https://github.com/rust-lang/mdBook/issues

book-example/src/for_developers/preprocessors.md

@@ -109,7 +109,7 @@ For everything else, have a look [at the complete example][example].
 [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
-[example]: https://github.com/rust-lang-nursery/mdBook/blob/master/examples/de-emphasize.rs
-[an example no-op preprocessor]: https://github.com/rust-lang-nursery/mdBook/blob/master/examples/nop-preprocessor.rs
+[example]: https://github.com/rust-lang/mdBook/blob/master/examples/nop-preprocessor.rs
+[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

book-example/src/format/config.md

@@ -14,9 +14,9 @@ description = "The example book covers examples."
 build-dir = "my-example-book"
 create-missing = false
 
-[preprocess.index]
+[preprocessor.index]
 
-[preprocess.links]
+[preprocessor.links]
 
 [output.html]
 additional-css = ["custom.css"]
@@ -27,7 +27,7 @@ limit-results = 15
 
 ## Supported configuration options
 
-It is important to note that **any** relative path specified in the in the
+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.
 
@@ -42,6 +42,7 @@ This is general information about your book.
 - **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
@@ -50,6 +51,7 @@ 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"
 ```
 
 ### Build options
@@ -68,18 +70,18 @@ This controls the build process of your book.
   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 
+  - 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 
+  - 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 `{{ #playpen }}` and `{{ #include }}` handlebars
+- `links`: Expand the `{{ #playpen }}`, `{{ #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
@@ -92,9 +94,9 @@ The following preprocessors are available and included by default:
 build-dir = "build"
 create-missing = false
 
-[preprocess.links]
+[preprocessor.links]
 
-[preprocess.index]
+[preprocessor.index]
 ```
 
 ### Custom Preprocessor Configuration
@@ -105,8 +107,8 @@ configuration to the preprocessor by adding key-value pairs to the table.
 
 For example
 
-```
-[preprocess.links]
+```toml
+[preprocessor.links]
 # set the renderers this preprocessor will run for
 renderers = ["html"]
 some_extra_feature = true
@@ -117,7 +119,7 @@ some_extra_feature = true
 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
 ```
@@ -125,7 +127,7 @@ 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` executa`ble. If you want to use a
+`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.
 
@@ -146,8 +148,16 @@ The following configuration options are available:
 - **theme:** mdBook comes with a default theme and all the resource files needed
   for it. But if this option is set, mdBook will selectively overwrite the theme
   files with the ones found in the specified folder.
+- **default-theme:** The theme color scheme to select by default in the
+  'Change Theme' dropdown. Defaults to `light`.
+- **preferred-dark-theme:** The default dark theme. This theme will be used if
+  the browser requests the dark version of the site via the
+  ['prefers-color-scheme'](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
+  CSS media query. Defaults to the same theme as `default-theme`.
 - **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
+  `false`.
 - **google-analytics:** If you use Google Analytics, this option lets you enable
   it by simply specifying your ID in the configuration file.
 - **additional-css:** If you need to slightly change the appearance of your book
@@ -160,15 +170,29 @@ The following configuration options are available:
 - **no-section-label:** mdBook by defaults adds section label in table of
   contents column. For example, "1.", "2.1". Set this option to true to disable
   those labels. Defaults to `false`.
+- **fold:** A subtable for configuring sidebar section-folding behavior.
 - **playpen:** A subtable for configuring various playpen settings.
 - **search:** A subtable for configuring the in-browser search functionality.
   mdBook must be compiled with the `search` feature enabled (on by default).
+- **git-repository-url:**  A url to the git repository for the book. If provided
+  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`.
+  
+Available configuration options for the `[output.html.fold]` table:
+
+- **enable:** Enable section-folding. When off, all folds are open.
+  Defaults to `false`.
+- **level:** The higher the more folded regions are open. When level is 0, all
+  folds are closed. Defaults to `0`.
 
 Available configuration options for the `[output.html.playpen]` table:
 
 - **editable:** Allow editing the source code. Defaults to `false`.
+- **copyable:** Display the copy button on code snippets. Defaults to `true`.
 - **copy-js:** Copy JavaScript files for the editor to the output directory.
   Defaults to `true`.
+- **line-numbers** Display line numbers on editable sections of code. Requires both `editable` and `copy-js` to be `true`. Defaults to `false`.
 
 [Ace]: https://ace.c9.io/
 
@@ -179,7 +203,7 @@ Available configuration options for the `[output.html.search]` table:
 - **teaser-word-count:** The number of words used for a search result teaser.
   Defaults to `30`.
 - **use-boolean-and:** Define the logical link between multiple search words. If
-  true, all search words must appear in each result. Defaults to `true`.
+  true, all search words must appear in each result. Defaults to `false`.
 - **boost-title:** Boost factor for the search result score if a search word
   appears in the header. Defaults to `2`.
 - **boost-hierarchy:** Boost factor for the search result score if a search word
@@ -203,25 +227,30 @@ title = "Example book"
 authors = ["John Doe", "Jane Doe"]
 description = "The example book covers examples."
 
-[build]
-build-dir = "book"
-create-missing = true
-preprocess = ["links", "index"]
-
 [output.html]
 theme = "my-theme"
+default-theme = "light"
+preferred-dark-theme = "navy"
 curly-quotes = true
+mathjax-support = false
 google-analytics = "123456"
 additional-css = ["custom.css", "custom2.css"]
 additional-js = ["custom.js"]
+no-section-label = false
+git-repository-url = "https://github.com/rust-lang/mdBook"
+git-repository-icon = "fa-github"
+
+[output.html.fold]
+enable = false
+level = 0
 
 [output.html.playpen]
-editor = "./path/to/editor"
 editable = false
+copy-js = true
+line-numbers = false
 
 [output.html.search]
 enable = true
-searcher = "./path/to/searcher"
 limit-results = 30
 teaser-word-count = 30
 use-boolean-and = true
@@ -233,15 +262,35 @@ heading-split-level = 3
 copy-js = true
 ```
 
+### Markdown Renderer
+
+The Markdown renderer will run preprocessors and then output the resulting
+Markdown. This is mostly useful for debugging preprocessors, especially in
+conjunction with `mdbook test` to see the Markdown that `mdbook` is passing
+to `rustdoc`.
+
+The Markdown renderer is included with `mdbook` but disabled by default.
+Enable it by adding an emtpy table to your `book.toml` as follows:
+
+```toml
+[output.markdown]
+```
+
+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
+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 
-instruct `mdbook` to pass a representation of the book to `mdbook-foo` for 
+A custom renderer can be enabled by adding a `[output.foo]` table to your
+`book.toml`. Similar to [preprocessors](#configuring-preprocessors) this will
+instruct `mdbook` to pass a representation of the book to `mdbook-foo` for
 rendering.
 
 Custom renderers will have access to all configuration within their table
-(i.e. anything under `[output.foo]`), and the command to be invoked can be 
+(i.e. anything under `[output.foo]`), and the command to be invoked can be
 manually specified with the `command` field.
 
 ## Environment Variables
@@ -274,11 +323,11 @@ book's title without needing to touch your `book.toml`.
 > This means, if you so desired, you could override all book metadata when
 > building the book with something like
 >
-> ```text
+> ```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.
+building.

book-example/src/format/mdbook.md

@@ -3,7 +3,9 @@
 ## Hiding code lines
 
 There is a feature in mdBook that lets you hide code lines by prepending them
-with a `#`.
+with a `#` [in the same way that Rustdoc does][rustdoc-hide].
+
+[rustdoc-hide]: https://doc.rust-lang.org/stable/rustdoc/documentation-tests.html#hiding-portions-of-the-example
 
 ```bash
 # fn main() {
@@ -35,10 +37,20 @@ With the following syntax, you can include files into your book:
 
 The path to the file has to be relative from the current source file.
 
-Usually, this command is used for including code snippets and examples. In this
-case, oftens one would include a specific part of the file e.g. which only
-contains the relevant lines for the example. We support four different modes of
-partial includes:
+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.
+
+````hbs
+```
+\{{#include file.rs}}
+```
+````
+
+## Including portions of a file
+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
 \{{#include file.rs:2}}
@@ -53,6 +65,114 @@ the file are omitted. The third command includes all lines from line 2, i.e. the
 first line is omitted. The last command includes the excerpt of `file.rs`
 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
+any kind of commented line.
+
+Consider the following file to include:
+```rs
+/* ANCHOR: all */
+
+// ANCHOR: component
+struct Paddle {
+    hello: f32,
+}
+// ANCHOR_END: component
+
+////////// ANCHOR: system
+impl System for MySystem { ... }
+////////// ANCHOR_END: system
+
+/* ANCHOR_END: all */
+```
+
+Then in the book, all you have to do is:
+````hbs
+Here is a component:
+```rust,no_run,noplaypen
+\{{#include file.rs:component}}
+```
+
+Here is a system:
+```rust,no_run,noplaypen
+\{{#include file.rs:system}}
+```
+
+This is the full file.
+```rust,no_run,noplaypen
+\{{#include file.rs:all}}
+```
+````
+
+Lines containing anchor patterns inside the included anchor are ignored.
+
+## Including a file but initially hiding all except specified lines
+
+The `rustdoc_include` helper is for including code from external Rust files that contain complete
+examples, but only initially showing particular lines specified with line numbers or anchors in the
+same way as with `include`.
+
+The lines not in the line number range or between the anchors will still be included, but they will
+be prefaced with `#`. This way, a reader can expand the snippet to see the complete example, and
+Rustdoc will use the complete example when you run `mdbook test`.
+
+For example, consider a file named `file.rs` that contains this Rust program:
+
+```rust
+fn main() {
+    let x = add_one(2);
+    assert_eq!(x, 3);
+}
+
+fn add_one(num: i32) -> i32 {
+    num + 1
+}
+```
+
+We can include a snippet that initially shows only line 2 by using this syntax:
+
+````hbs
+To call the `add_one` function, we pass it an `i32` and bind the returned value to `x`:
+
+```rust
+\{{#rustdoc_include file.rs:2}}
+```
+````
+
+This would have the same effect as if we had manually inserted the code and hidden all but line 2
+using `#`:
+
+````hbs
+To call the `add_one` function, we pass it an `i32` and bind the returned value to `x`:
+
+```rust
+# fn main() {
+    let x = add_one(2);
+#     assert_eq!(x, 3);
+# }
+#
+# fn add_one(num: i32) -> i32 {
+#     num + 1
+#}
+```
+````
+
+That is, it looks like this (click the "expand" icon to see the rest of the file):
+
+```rust
+# fn main() {
+    let x = add_one(2);
+#     assert_eq!(x, 3);
+# }
+#
+# fn add_one(num: i32) -> i32 {
+#     num + 1
+#}
+```
+
 ## Inserting runnable Rust files
 
 With the following syntax, you can insert runnable Rust files into your book:

book-example/src/format/theme/index-hbs.md

@@ -17,9 +17,8 @@ handlebars template you can access this information by using
 
 Here is a list of the properties that are exposed:
 
-- ***language*** Language of the book in the form `en`. To use in <code
-  class="language-html">\<html lang="{{ language }}"></code> for example. At the
-  moment it is hardcoded.
+- ***language*** Language of the book in the form `en`, as specified in `book.toml` (if not specified, defaults to `en`). To use in <code
+  class="language-html">\<html lang="{{ language }}"></code> for example.
 - ***title*** Title of the book, as specified in `book.toml`
 - ***chapter_title*** Title of the current chapter, as listed in `SUMMARY.md`
 
@@ -45,53 +44,57 @@ at your disposal.
 
 ### 1. toc
 
-    The toc helper is used like this
+The toc helper is used like this
 
-    ```handlebars
-    {{#toc}}{{/toc}}
-    ```
+```handlebars
+{{#toc}}{{/toc}}
+```
 
-    and outputs something that looks like this, depending on the structure of your book
+and outputs something that looks like this, depending on the structure of your
+book
 
-    ```html
-    <ul class="chapter">
-        <li><a href="link/to/file.html">Some chapter</a></li>
-        <li>
-            <ul class="section">
-                <li><a href="link/to/other_file.html">Some other Chapter</a></li>
-            </ul>
-        </li>
-    </ul>
-    ```
+```html
+<ul class="chapter">
+    <li><a href="link/to/file.html">Some chapter</a></li>
+    <li>
+        <ul class="section">
+            <li><a href="link/to/other_file.html">Some other Chapter</a></li>
+        </ul>
+    </li>
+</ul>
+```
 
-    If you would like to make a toc with another structure, you have access to the chapters property containing all the data.
-    The only limitation at the moment is that you would have to do it with JavaScript instead of with a handlebars helper.
+If you would like to make a toc with another structure, you have access to the
+chapters property containing all the data. The only limitation at the moment
+is that you would have to do it with JavaScript instead of with a handlebars
+helper.
 
-    ```html
-    <script>
-    var chapters = {{chapters}};
-    // Processing here
-    </script>
-    ```
+```html
+<script>
+var chapters = {{chapters}};
+// Processing here
+</script>
+```
 
 ### 2. previous / next
 
-    The previous and next helpers expose a `link` and `name` property to the previous and next chapters.
+The previous and next helpers expose a `link` and `name` property to the
+previous and next chapters.
 
-    They are used like this
+They are used like this
 
-    ```handlebars
-    {{#previous}}
-        <a href="{{link}}" class="nav-chapters previous">
-            <i class="fa fa-angle-left"></i>
-        </a>
-    {{/previous}}
-    ```
+```handlebars
+{{#previous}}
+    <a href="{{link}}" class="nav-chapters previous">
+        <i class="fa fa-angle-left"></i>
+    </a>
+{{/previous}}
+```
 
-    The inner html will only be rendered if the previous / next chapter exists.
-    Of course the inner html can be changed to your liking.
+The inner html will only be rendered if the previous / next chapter exists.
+Of course the inner html can be changed to your liking.
 
 ------
 
 *If you would like other properties or helpers exposed, please [create a new
-issue](https://github.com/rust-lang-nursery/mdBook/issues)*
+issue](https://github.com/rust-lang/mdBook/issues)*

book-example/src/format/theme/syntax-highlighting.md

@@ -22,7 +22,7 @@ overridden with your own.
 
 If you want to use another theme for `highlight.js` download it from their
 website, or make it yourself, rename it to `highlight.css` and put it in
-`src/theme` (or the equivalent if you changed your source folder)
+the `theme` folder of your book.
 
 Now your theme will be used instead of the default theme.
 
@@ -62,7 +62,7 @@ everyone can benefit from it.**
 
 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
-issue](https://github.com/rust-lang-nursery/mdBook/issues) explaining what you
+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.

ci/before_deploy.sh

@@ -1,32 +0,0 @@
-# This script takes care of building your crate and packaging it for release
-
-set -ex
-
-main() {
-    local src=$(pwd) \
-          stage=
-
-    case $TRAVIS_OS_NAME in
-        linux)
-            stage=$(mktemp -d)
-            ;;
-        osx)
-            stage=$(mktemp -d -t tmp)
-            ;;
-    esac
-
-    # This will slow down the build, but is necessary to not run out of disk space
-    cargo clean
-
-    cargo rustc --bin mdbook --target $TARGET --release -- -C lto
-
-    cp target/$TARGET/release/mdbook $stage/
-
-    cd $stage
-    tar czf $src/$CRATE_NAME-$TRAVIS_TAG-$TARGET.tar.gz *
-    cd $src
-
-    rm -rf $stage
-}
-
-main

ci/install-hub.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Installs the `hub` executable into hub/bin
+set -ex
+case $1 in
+  ubuntu*)
+    curl -LsSf https://github.com/github/hub/releases/download/v2.12.8/hub-linux-amd64-2.12.8.tgz -o hub.tgz
+    mkdir hub
+    tar -xzvf hub.tgz --strip=1 -C hub
+    ;;
+  macos*)
+    curl -LsSf https://github.com/github/hub/releases/download/v2.12.8/hub-darwin-amd64-2.12.8.tgz -o hub.tgz
+    mkdir hub
+    tar -xzvf hub.tgz --strip=1 -C hub
+    ;;
+  windows*)
+    curl -LsSf https://github.com/github/hub/releases/download/v2.12.8/hub-windows-amd64-2.12.8.zip -o hub.zip
+    7z x hub.zip -ohub
+    ;;
+  *)
+    echo "OS should be first parameter, was: $1"
+    ;;
+esac
+
+echo "##[add-path]$PWD/hub/bin"

ci/install-rust.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Install/update rust.
+# The first argument should be the toolchain to install.
+
+set -ex
+if [ -z "$1" ]
+then
+    echo "First parameter must be toolchain to install."
+    exit 1
+fi
+TOOLCHAIN="$1"
+
+rustup set profile minimal
+rustup component remove --toolchain=$TOOLCHAIN rust-docs || echo "already removed"
+rustup update $TOOLCHAIN
+rustup default $TOOLCHAIN
+rustup -V
+rustc -Vv
+cargo -V

ci/install-rustup.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Install/update rustup.
+# The first argument should be the toolchain to install.
+#
+# It is helpful to have this as a separate script due to some issues on
+# Windows where immediately after `rustup self update`, rustup can fail with
+# "Device or resource busy".
+
+set -ex
+if [ -z "$1" ]
+then
+    echo "First parameter must be toolchain to install."
+    exit 1
+fi
+TOOLCHAIN="$1"
+
+# Install/update rustup.
+if command -v rustup
+then
+    echo `command -v rustup` `rustup -V` already installed
+    rustup self update
+else
+    # macOS currently does not have rust pre-installed.
+    curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain $TOOLCHAIN --profile=minimal
+    echo "##[add-path]$HOME/.cargo/bin"
+fi

ci/make-release.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Builds the release and creates an archive and optionally deploys to GitHub.
+set -ex
+
+if [[ -z "$GITHUB_REF" ]]
+then
+  echo "GITHUB_REF must be set"
+  exit 1
+fi
+# Strip mdbook-refs/tags/ from the start of the ref.
+TAG=${GITHUB_REF#*/tags/}
+
+host=$(rustc -Vv | grep ^host: | sed -e "s/host: //g")
+cargo rustc --bin mdbook --release -- -C lto
+cd target/release
+case $1 in
+  ubuntu* | macos*)
+    asset="mdbook-$TAG-$host.tar.gz"
+    tar czf ../../$asset mdbook
+    ;;
+  windows*)
+    asset="mdbook-$TAG-$host.zip"
+    7z a ../../$asset mdbook.exe
+    ;;
+  *)
+    echo "OS should be first parameter, was: $1"
+    ;;
+esac
+cd ../..
+
+if [[ -z "$GITHUB_TOKEN" ]]
+then
+  echo "$GITHUB_TOKEN not set, skipping deploy."
+else
+  hub release edit -m "" --attach $asset $TAG
+fi

examples/de-emphasize.rs

@@ -1,82 +0,0 @@
-//! An example preprocessor for removing all forms of emphasis from a markdown
-//! book.
-
-extern crate mdbook;
-extern crate pulldown_cmark;
-extern crate pulldown_cmark_to_cmark;
-
-use mdbook::book::{Book, BookItem, Chapter};
-use mdbook::errors::{Error, Result};
-use mdbook::preprocess::{Preprocessor, PreprocessorContext};
-use pulldown_cmark::{Event, Parser, Tag};
-use pulldown_cmark_to_cmark::fmt::cmark;
-
-const NAME: &str = "md-links-to-html-links";
-
-fn main() {
-    panic!("This example is intended to be part of a library");
-}
-
-struct Deemphasize;
-
-impl Preprocessor for Deemphasize {
-    fn name(&self) -> &str {
-        NAME
-    }
-
-    fn run(&self, _ctx: &PreprocessorContext, mut book: Book) -> Result<Book> {
-        eprintln!("Running '{}' preprocessor", self.name());
-        let mut num_removed_items = 0;
-
-        process(&mut book.sections, &mut num_removed_items)?;
-
-        eprintln!(
-            "{}: removed {} events from markdown stream.",
-            self.name(),
-            num_removed_items
-        );
-
-        Ok(book)
-    }
-}
-
-fn process<'a, I>(items: I, num_removed_items: &mut usize) -> Result<()>
-where
-    I: IntoIterator<Item = &'a mut BookItem> + 'a,
-{
-    for item in items {
-        if let BookItem::Chapter(ref mut chapter) = *item {
-            eprintln!("{}: processing chapter '{}'", NAME, chapter.name);
-
-            let md = remove_emphasis(num_removed_items, chapter)?;
-            chapter.content = md;
-        }
-    }
-
-    Ok(())
-}
-
-fn remove_emphasis(
-    num_removed_items: &mut usize,
-    chapter: &mut Chapter,
-) -> Result<String> {
-    let mut buf = String::with_capacity(chapter.content.len());
-
-    let events = Parser::new(&chapter.content).filter(|e| {
-        let should_keep = match *e {
-            Event::Start(Tag::Emphasis)
-            | Event::Start(Tag::Strong)
-            | Event::End(Tag::Emphasis)
-            | Event::End(Tag::Strong) => false,
-            _ => true,
-        };
-        if !should_keep {
-            *num_removed_items += 1;
-        }
-        should_keep
-    });
-
-    cmark(events, &mut buf, None).map(|_| buf).map_err(|err| {
-        Error::from(format!("Markdown serialization failed: {}", err))
-    })
-}

examples/nop-preprocessor.rs

@@ -1,14 +1,10 @@
-extern crate clap;
-extern crate mdbook;
-extern crate serde_json;
-
+use crate::nop_lib::Nop;
 use clap::{App, Arg, ArgMatches, SubCommand};
 use mdbook::book::Book;
 use mdbook::errors::Error;
 use mdbook::preprocess::{CmdPreprocessor, Preprocessor, PreprocessorContext};
 use std::io;
 use std::process;
-use nop_lib::Nop;
 
 pub fn make_app() -> App<'static, 'static> {
     App::new("nop-preprocessor")
@@ -16,7 +12,8 @@ pub fn make_app() -> App<'static, 'static> {
         .subcommand(
             SubCommand::with_name("supports")
                 .arg(Arg::with_name("renderer").required(true))
-                .about("Check whether a renderer is supported by this preprocessor"))
+                .about("Check whether a renderer is supported by this preprocessor"),
+        )
 }
 
 fn main() {
@@ -27,11 +24,9 @@ fn main() {
 
     if let Some(sub_args) = matches.subcommand_matches("supports") {
         handle_supports(&preprocessor, sub_args);
-    } else {
-        if let Err(e) = handle_preprocessing(&preprocessor) {
-            eprintln!("{}", e);
-            process::exit(1);
-        }
+    } else if let Err(e) = handle_preprocessing(&preprocessor) {
+        eprintln!("{}", e);
+        process::exit(1);
     }
 }
 
@@ -87,11 +82,7 @@ mod nop_lib {
             "nop-preprocessor"
         }
 
-        fn run(
-            &self,
-            ctx: &PreprocessorContext,
-            book: Book,
-        ) -> Result<Book, Error> {
+        fn run(&self, ctx: &PreprocessorContext, book: Book) -> Result<Book, Error> {
             // In testing we want to tell the preprocessor to blow up by setting a
             // particular config value
             if let Some(nop_cfg) = ctx.config.get_preprocessor(self.name()) {
@@ -109,4 +100,3 @@ mod nop_lib {
         }
     }
 }
-

src/book/book.rs

@@ -5,8 +5,8 @@ use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 
 use super::summary::{parse_summary, Link, SectionNumber, Summary, SummaryItem};
-use config::BuildConfig;
-use errors::*;
+use crate::config::BuildConfig;
+use crate::errors::*;
 
 /// Load a book into memory from its `src/` directory.
 pub fn load_book<P: AsRef<Path>>(src_dir: P, cfg: &BuildConfig) -> Result<Book> {
@@ -82,7 +82,7 @@ impl Book {
     }
 
     /// Get a depth-first iterator over the items in the book.
-    pub fn iter(&self) -> BookItems {
+    pub fn iter(&self) -> BookItems<'_> {
         BookItems {
             items: self.sections.iter().collect(),
         }
@@ -116,7 +116,7 @@ where
     I: IntoIterator<Item = &'a mut BookItem>,
 {
     for item in items {
-        if let &mut BookItem::Chapter(ref mut ch) = item {
+        if let BookItem::Chapter(ch) = item {
             for_each_mut(func, &mut ch.sub_items);
         }
 
@@ -167,9 +167,9 @@ impl Chapter {
     ) -> Chapter {
         Chapter {
             name: name.to_string(),
-            content: content,
+            content,
             path: path.into(),
-            parent_names: parent_names,
+            parent_names,
             ..Default::default()
         }
     }
@@ -179,7 +179,7 @@ impl Chapter {
 ///
 /// You need to pass in the book's source directory because all the links in
 /// `SUMMARY.md` give the chapter locations relative to it.
-fn load_book_from_disk<P: AsRef<Path>>(summary: &Summary, src_dir: P) -> Result<Book> {
+pub(crate) fn load_book_from_disk<P: AsRef<Path>>(summary: &Summary, src_dir: P) -> Result<Book> {
     debug!("Loading the book from disk");
     let src_dir = src_dir.as_ref();
 
@@ -210,7 +210,7 @@ fn load_summary_item<P: AsRef<Path>>(
     match *item {
         SummaryItem::Separator => Ok(BookItem::Separator),
         SummaryItem::Link(ref link) => {
-            load_chapter(link, src_dir, parent_names).map(|c| BookItem::Chapter(c))
+            load_chapter(link, src_dir, parent_names).map(BookItem::Chapter)
         }
     }
 }
@@ -286,7 +286,7 @@ impl<'a> Iterator for BookItems<'a> {
 }
 
 impl Display for Chapter {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         if let Some(ref section_number) = self.number {
             write!(f, "{} ", section_number)?;
         }
@@ -301,7 +301,7 @@ mod tests {
     use std::io::Write;
     use tempfile::{Builder as TempFileBuilder, TempDir};
 
-    const DUMMY_SRC: &'static str = "
+    const DUMMY_SRC: &str = "
 # Dummy Chapter
 
 this is some dummy text.
@@ -317,7 +317,7 @@ And here is some \
         let chapter_path = temp.path().join("chapter_1.md");
         File::create(&chapter_path)
             .unwrap()
-            .write(DUMMY_SRC.as_bytes())
+            .write_all(DUMMY_SRC.as_bytes())
             .unwrap();
 
         let link = Link::new("Chapter 1", chapter_path);
@@ -333,7 +333,7 @@ And here is some \
 
         File::create(&second_path)
             .unwrap()
-            .write_all("Hello World!".as_bytes())
+            .write_all(b"Hello World!")
             .unwrap();
 
         let mut second = Link::new("Nested Chapter 1", &second_path);
@@ -481,7 +481,8 @@ And here is some \
             .filter_map(|i| match *i {
                 BookItem::Chapter(ref ch) => Some(ch.name.clone()),
                 _ => None,
-            }).collect();
+            })
+            .collect();
         let should_be: Vec<_> = vec![
             String::from("Chapter 1"),
             String::from("Hello World"),

src/book/init.rs

@@ -1,12 +1,11 @@
 use std::fs::{self, File};
 use std::io::Write;
 use std::path::PathBuf;
-use toml;
 
 use super::MDBook;
-use config::Config;
-use errors::*;
-use theme;
+use crate::config::Config;
+use crate::errors::*;
+use crate::theme;
 
 /// A helper for setting up a new book and its directory structure.
 #[derive(Debug, Clone, PartialEq)]
@@ -173,15 +172,19 @@ impl BookBuilder {
         let src_dir = self.root.join(&self.config.book.src);
 
         let summary = src_dir.join("SUMMARY.md");
-        let mut f = File::create(&summary).chain_err(|| "Unable to create SUMMARY.md")?;
-        writeln!(f, "# Summary")?;
-        writeln!(f, "")?;
-        writeln!(f, "- [Chapter 1](./chapter_1.md)")?;
-
-        let chapter_1 = src_dir.join("chapter_1.md");
-        let mut f = File::create(&chapter_1).chain_err(|| "Unable to create chapter_1.md")?;
-        writeln!(f, "# Chapter 1")?;
+        if !summary.exists() {
+            trace!("No summary found creating stub summary and chapter_1.md.");
+            let mut f = File::create(&summary).chain_err(|| "Unable to create SUMMARY.md")?;
+            writeln!(f, "# Summary")?;
+            writeln!(f)?;
+            writeln!(f, "- [Chapter 1](./chapter_1.md)")?;
 
+            let chapter_1 = src_dir.join("chapter_1.md");
+            let mut f = File::create(&chapter_1).chain_err(|| "Unable to create chapter_1.md")?;
+            writeln!(f, "# Chapter 1")?;
+        } else {
+            trace!("Existing summary found, no need to create stub files.");
+        }
         Ok(())
     }
 

src/book/mod.rs

@@ -16,16 +16,18 @@ pub use self::summary::{parse_summary, Link, SectionNumber, Summary, SummaryItem
 use std::io::Write;
 use std::path::PathBuf;
 use std::process::Command;
+use std::string::ToString;
 use tempfile::Builder as TempFileBuilder;
 use toml::Value;
 
-use errors::*;
-use preprocess::{IndexPreprocessor, LinkPreprocessor, Preprocessor,
-    PreprocessorContext, CmdPreprocessor};
-use renderer::{CmdRenderer, HtmlHandlebars, RenderContext, Renderer};
-use utils;
+use crate::errors::*;
+use crate::preprocess::{
+    CmdPreprocessor, IndexPreprocessor, LinkPreprocessor, Preprocessor, PreprocessorContext,
+};
+use crate::renderer::{CmdRenderer, HtmlHandlebars, MarkdownRenderer, RenderContext, Renderer};
+use crate::utils;
 
-use config::Config;
+use crate::config::Config;
 
 /// The object used to manage and build a book.
 pub struct MDBook {
@@ -35,10 +37,10 @@ pub struct MDBook {
     pub config: Config,
     /// A representation of the book's contents in memory.
     pub book: Book,
-    renderers: Vec<Box<Renderer>>,
+    renderers: Vec<Box<dyn Renderer>>,
 
     /// List of pre-processors to be run on the book
-    preprocessors: Vec<Box<Preprocessor>>,
+    preprocessors: Vec<Box<dyn Preprocessor>>,
 }
 
 impl MDBook {
@@ -54,7 +56,7 @@ impl MDBook {
             warn!("This format is no longer used, so you should migrate to the");
             warn!("book.toml format.");
             warn!("Check the user guide for migration information:");
-            warn!("\thttps://rust-lang-nursery.github.io/mdBook/format/config.html");
+            warn!("\thttps://rust-lang.github.io/mdBook/format/config.html");
         }
 
         let mut config = if config_location.exists() {
@@ -66,7 +68,7 @@ impl MDBook {
 
         config.update_from_env();
 
-        if log_enabled!(::log::Level::Trace) {
+        if log_enabled!(log::Level::Trace) {
             for line in format!("Config: {:#?}", config).lines() {
                 trace!("{}", line);
             }
@@ -94,12 +96,34 @@ impl MDBook {
         })
     }
 
+    /// Load a book from its root directory using a custom config and a custom summary.
+    pub fn load_with_config_and_summary<P: Into<PathBuf>>(
+        book_root: P,
+        config: Config,
+        summary: Summary,
+    ) -> Result<MDBook> {
+        let root = book_root.into();
+
+        let src_dir = root.join(&config.book.src);
+        let book = book::load_book_from_disk(&summary, &src_dir)?;
+
+        let renderers = determine_renderers(&config);
+        let preprocessors = determine_preprocessors(&config)?;
+
+        Ok(MDBook {
+            root,
+            config,
+            book,
+            renderers,
+            preprocessors,
+        })
+    }
+
     /// Returns a flat depth-first iterator over the elements of the book,
     /// it returns an [BookItem enum](bookitem.html):
     /// `(section: String, bookitem: &BookItem)`
     ///
     /// ```no_run
-    /// # extern crate mdbook;
     /// # use mdbook::MDBook;
     /// # use mdbook::book::BookItem;
     /// # #[allow(unused_variables)]
@@ -121,7 +145,7 @@ impl MDBook {
     /// // etc.
     /// # }
     /// ```
-    pub fn iter(&self) -> BookItems {
+    pub fn iter(&self) -> BookItems<'_> {
         self.book.iter()
     }
 
@@ -158,17 +182,18 @@ impl MDBook {
     }
 
     /// Run the entire build process for a particular `Renderer`.
-    fn execute_build_process(&self, renderer: &Renderer) -> Result<()> {
+    fn execute_build_process(&self, renderer: &dyn Renderer) -> Result<()> {
         let mut preprocessed_book = self.book.clone();
-        let preprocess_ctx = PreprocessorContext::new(self.root.clone(),
-                                     self.config.clone(),
-                                     renderer.name().to_string());
+        let preprocess_ctx = PreprocessorContext::new(
+            self.root.clone(),
+            self.config.clone(),
+            renderer.name().to_string(),
+        );
 
         for preprocessor in &self.preprocessors {
             if preprocessor_should_run(&**preprocessor, renderer, &self.config) {
                 debug!("Running the {} preprocessor.", preprocessor.name());
-                preprocessed_book =
-                    preprocessor.run(&preprocess_ctx, preprocessed_book)?;
+                preprocessed_book = preprocessor.run(&preprocess_ctx, preprocessed_book)?;
             }
         }
 
@@ -178,23 +203,9 @@ impl MDBook {
         Ok(())
     }
 
-    fn render(
-        &self,
-        preprocessed_book: &Book,
-        renderer: &Renderer,
-    ) -> Result<()> {
+    fn render(&self, preprocessed_book: &Book, renderer: &dyn Renderer) -> Result<()> {
         let name = renderer.name();
         let build_dir = self.build_dir_for(name);
-        if build_dir.exists() {
-            debug!(
-                "Cleaning build dir for the \"{}\" renderer ({})",
-                name,
-                build_dir.display()
-            );
-
-            utils::fs::remove_dir_content(&build_dir)
-                .chain_err(|| "Unable to clear output directory")?;
-        }
 
         let render_context = RenderContext::new(
             self.root.clone(),
@@ -217,7 +228,7 @@ impl MDBook {
     }
 
     /// Register a [`Preprocessor`](../preprocess/trait.Preprocessor.html) to be used when rendering the book.
-    pub fn with_preprecessor<P: Preprocessor + 'static>(&mut self, preprocessor: P) -> &mut Self {
+    pub fn with_preprocessor<P: Preprocessor + 'static>(&mut self, preprocessor: P) -> &mut Self {
         self.preprocessors.push(Box::new(preprocessor));
         self
     }
@@ -233,9 +244,8 @@ impl MDBook {
         let temp_dir = TempFileBuilder::new().prefix("mdbook-").tempdir()?;
 
         // FIXME: Is "test" the proper renderer name to use here?
-        let preprocess_context = PreprocessorContext::new(self.root.clone(),
-                                                          self.config.clone(),
-                                                          "test".to_string());
+        let preprocess_context =
+            PreprocessorContext::new(self.root.clone(), self.config.clone(), "test".to_string());
 
         let book = LinkPreprocessor::new().run(&preprocess_context, self.book.clone())?;
         // Index Preprocessor is disabled so that chapter paths continue to point to the
@@ -245,13 +255,12 @@ impl MDBook {
             if let BookItem::Chapter(ref ch) = *item {
                 if !ch.path.as_os_str().is_empty() {
                     let path = self.source_dir().join(&ch.path);
-                    let content = utils::fs::file_to_string(&path)?;
                     info!("Testing file: {:?}", path);
 
                     // write preprocessed file to tempdir
                     let path = temp_dir.path().join(&ch.path);
                     let mut tmpf = utils::fs::create_file(&path)?;
-                    tmpf.write_all(content.as_bytes())?;
+                    tmpf.write_all(ch.content.as_bytes())?;
 
                     let output = Command::new("rustdoc")
                         .arg(&path)
@@ -320,19 +329,19 @@ impl MDBook {
 }
 
 /// Look at the `Config` and try to figure out what renderers to use.
-fn determine_renderers(config: &Config) -> Vec<Box<Renderer>> {
-    let mut renderers: Vec<Box<Renderer>> = Vec::new();
+fn determine_renderers(config: &Config) -> Vec<Box<dyn Renderer>> {
+    let mut renderers = Vec::new();
 
-    if let Some(output_table) = config.get("output").and_then(|o| o.as_table()) {
-        for (key, table) in output_table.iter() {
-            // the "html" backend has its own Renderer
+    if let Some(output_table) = config.get("output").and_then(Value::as_table) {
+        renderers.extend(output_table.iter().map(|(key, table)| {
             if key == "html" {
-                renderers.push(Box::new(HtmlHandlebars::new()));
+                Box::new(HtmlHandlebars::new()) as Box<dyn Renderer>
+            } else if key == "markdown" {
+                Box::new(MarkdownRenderer::new()) as Box<dyn Renderer>
             } else {
-                let renderer = interpret_custom_renderer(key, table);
-                renderers.push(renderer);
+                interpret_custom_renderer(key, table)
             }
-        }
+        }));
     }
 
     // if we couldn't find anything, add the HTML renderer as a default
@@ -343,37 +352,31 @@ fn determine_renderers(config: &Config) -> Vec<Box<Renderer>> {
     renderers
 }
 
-fn default_preprocessors() -> Vec<Box<Preprocessor>> {
+fn default_preprocessors() -> Vec<Box<dyn Preprocessor>> {
     vec![
         Box::new(LinkPreprocessor::new()),
         Box::new(IndexPreprocessor::new()),
     ]
 }
 
-fn is_default_preprocessor(pre: &Preprocessor) -> bool {
+fn is_default_preprocessor(pre: &dyn Preprocessor) -> bool {
     let name = pre.name();
     name == LinkPreprocessor::NAME || name == IndexPreprocessor::NAME
 }
 
 /// Look at the `MDBook` and try to figure out what preprocessors to run.
-fn determine_preprocessors(config: &Config) -> Result<Vec<Box<Preprocessor>>> {
+fn determine_preprocessors(config: &Config) -> Result<Vec<Box<dyn Preprocessor>>> {
     let mut preprocessors = Vec::new();
 
     if config.build.use_default_preprocessors {
         preprocessors.extend(default_preprocessors());
     }
 
-    if let Some(preprocessor_table) =
-        config.get("preprocessor").and_then(|v| v.as_table())
-    {
+    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()))
-                }
+                "links" => preprocessors.push(Box::new(LinkPreprocessor::new())),
+                "index" => preprocessors.push(Box::new(IndexPreprocessor::new())),
                 name => preprocessors.push(interpret_custom_preprocessor(
                     name,
                     &preprocessor_table[name],
@@ -385,14 +388,11 @@ fn determine_preprocessors(config: &Config) -> Result<Vec<Box<Preprocessor>>> {
     Ok(preprocessors)
 }
 
-fn interpret_custom_preprocessor(
-    key: &str,
-    table: &Value,
-) -> Box<CmdPreprocessor> {
+fn interpret_custom_preprocessor(key: &str, table: &Value) -> Box<CmdPreprocessor> {
     let command = table
         .get("command")
-        .and_then(|c| c.as_str())
-        .map(|s| s.to_string())
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
         .unwrap_or_else(|| format!("mdbook-{}", key));
 
     Box::new(CmdPreprocessor::new(key.to_string(), command.to_string()))
@@ -403,11 +403,10 @@ fn interpret_custom_renderer(key: &str, table: &Value) -> Box<CmdRenderer> {
     // prepended by "mdbook-"
     let table_dot_command = table
         .get("command")
-        .and_then(|c| c.as_str())
-        .map(|s| s.to_string());
+        .and_then(Value::as_str)
+        .map(ToString::to_string);
 
-    let command =
-        table_dot_command.unwrap_or_else(|| format!("mdbook-{}", key));
+    let command = table_dot_command.unwrap_or_else(|| format!("mdbook-{}", key));
 
     Box::new(CmdRenderer::new(key.to_string(), command.to_string()))
 }
@@ -418,7 +417,11 @@ fn interpret_custom_renderer(key: &str, table: &Value) -> Box<CmdRenderer> {
 ///
 /// The `build.use-default-preprocessors` config option can be used to ensure
 /// default preprocessors always run if they support the renderer.
-fn preprocessor_should_run(preprocessor: &Preprocessor, renderer: &Renderer, cfg: &Config) -> bool {
+fn preprocessor_should_run(
+    preprocessor: &dyn Preprocessor,
+    renderer: &dyn Renderer,
+    cfg: &Config,
+) -> bool {
     // default preprocessors should be run by default (if supported)
     if cfg.build.use_default_preprocessors && is_default_preprocessor(preprocessor) {
         return preprocessor.supports_renderer(renderer.name());
@@ -428,18 +431,19 @@ fn preprocessor_should_run(preprocessor: &Preprocessor, renderer: &Renderer, cfg
     let renderer_name = renderer.name();
 
     if let Some(Value::Array(ref explicit_renderers)) = cfg.get(&key) {
-        return explicit_renderers.into_iter()
-            .filter_map(|val| val.as_str())
+        return explicit_renderers
+            .iter()
+            .filter_map(Value::as_str)
             .any(|name| name == renderer_name);
     }
 
     preprocessor.supports_renderer(renderer_name)
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::str::FromStr;
     use toml::value::{Table, Value};
 
     #[test]
@@ -507,7 +511,7 @@ mod tests {
 
     #[test]
     fn can_determine_third_party_preprocessors() {
-        let cfg_str: &'static str = r#"
+        let cfg_str = r#"
         [book]
         title = "Some Book"
 
@@ -539,17 +543,14 @@ 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 = interpret_custom_preprocessor("random", &Value::Table(random.clone()));
 
         assert_eq!(random.cmd(), "python random.py");
     }
 
     #[test]
     fn config_respects_preprocessor_selection() {
-        let cfg_str: &'static str = r#"
+        let cfg_str = r#"
         [preprocessor.links]
         renderers = ["html"]
         "#;
@@ -557,11 +558,12 @@ mod tests {
         let cfg = Config::from_str(cfg_str).unwrap();
 
         // double-check that we can access preprocessor.links.renderers[0]
-        let html = cfg.get_preprocessor("links")
+        let html = cfg
+            .get_preprocessor("links")
             .and_then(|links| links.get("renderers"))
-            .and_then(|renderers| renderers.as_array())
+            .and_then(Value::as_array)
             .and_then(|renderers| renderers.get(0))
-            .and_then(|renderer| renderer.as_str())
+            .and_then(Value::as_str)
             .unwrap();
         assert_eq!(html, "html");
         let html_renderer = HtmlHandlebars::default();

src/book/summary.rs

@@ -1,4 +1,4 @@
-use errors::*;
+use crate::errors::*;
 use memchr::{self, Memchr};
 use pulldown_cmark::{self, Event, Tag};
 use std::fmt::{self, Display, Formatter};
@@ -153,7 +153,8 @@ impl From<Link> for SummaryItem {
 /// > match the following regex: "[^<>\n[]]+".
 struct SummaryParser<'a> {
     src: &'a str,
-    stream: pulldown_cmark::Parser<'a>,
+    stream: pulldown_cmark::OffsetIter<'a>,
+    offset: usize,
 }
 
 /// Reads `Events` from the provided stream until the corresponding
@@ -174,7 +175,7 @@ macro_rules! collect_events {
         let mut events = Vec::new();
 
         loop {
-            let event = $stream.next();
+            let event = $stream.next().map(|(ev, _range)| ev);
             trace!("Next event: {:?}", event);
 
             match event {
@@ -195,24 +196,23 @@ macro_rules! collect_events {
 }
 
 impl<'a> SummaryParser<'a> {
-    fn new(text: &str) -> SummaryParser {
-        let pulldown_parser = pulldown_cmark::Parser::new(text);
+    fn new(text: &str) -> SummaryParser<'_> {
+        let pulldown_parser = pulldown_cmark::Parser::new(text).into_offset_iter();
 
         SummaryParser {
             src: text,
             stream: pulldown_parser,
+            offset: 0,
         }
     }
 
     /// Get the current line and column to give the user more useful error
     /// messages.
     fn current_location(&self) -> (usize, usize) {
-        let byte_offset = self.stream.get_offset();
-
-        let previous_text = self.src[..byte_offset].as_bytes();
+        let previous_text = self.src[..self.offset].as_bytes();
         let line = Memchr::new(b'\n', previous_text).count() + 1;
         let start_of_line = memchr::memrchr(b'\n', previous_text).unwrap_or(0);
-        let col = self.src[start_of_line..byte_offset].chars().count();
+        let col = self.src[start_of_line..self.offset].chars().count();
 
         (line, col)
     }
@@ -259,11 +259,11 @@ impl<'a> SummaryParser<'a> {
                         bail!(self.parse_error("Suffix chapters cannot be followed by a list"));
                     }
                 }
-                Some(Event::Start(Tag::Link(href, _))) => {
+                Some(Event::Start(Tag::Link(_type, href, _title))) => {
                     let link = self.parse_link(href.to_string())?;
                     items.push(SummaryItem::Link(link));
                 }
-                Some(Event::Start(Tag::Rule)) => items.push(SummaryItem::Separator),
+                Some(Event::Rule) => items.push(SummaryItem::Separator),
                 Some(_) => {}
                 None => break,
             }
@@ -280,7 +280,7 @@ impl<'a> SummaryParser<'a> {
             Err(self.parse_error("You can't have an empty link."))
         } else {
             Ok(Link {
-                name: name,
+                name,
                 location: PathBuf::from(href.to_string()),
                 number: None,
                 nested_items: Vec::new(),
@@ -313,16 +313,12 @@ impl<'a> SummaryParser<'a> {
             root_items += bunch_of_items.len() as u32;
             items.extend(bunch_of_items);
 
-
             match self.next_event() {
                 Some(Event::Start(Tag::Paragraph)) => {
                     // we're starting the suffix chapters
                     break;
                 }
                 Some(Event::Start(other_tag)) => {
-                    if other_tag == Tag::Rule {
-                        items.push(SummaryItem::Separator);
-                    }
                     trace!("Skipping contents of {:?}", other_tag);
 
                     // Skip over the contents of this tag
@@ -338,6 +334,14 @@ impl<'a> SummaryParser<'a> {
                         break;
                     }
                 }
+                Some(Event::Rule) => {
+                    items.push(SummaryItem::Separator);
+                    if let Some(Event::Start(Tag::List(..))) = self.next_event() {
+                        continue;
+                    } else {
+                        break;
+                    }
+                }
                 Some(_) => {
                     // something else... ignore
                     continue;
@@ -353,7 +357,10 @@ impl<'a> SummaryParser<'a> {
     }
 
     fn next_event(&mut self) -> Option<Event<'a>> {
-        let next = self.stream.next();
+        let next = self.stream.next().map(|(ev, range)| {
+            self.offset = range.start;
+            ev
+        });
         trace!("Next event: {:?}", next);
 
         next
@@ -398,7 +405,7 @@ impl<'a> SummaryParser<'a> {
         loop {
             match self.next_event() {
                 Some(Event::Start(Tag::Paragraph)) => continue,
-                Some(Event::Start(Tag::Link(href, _))) => {
+                Some(Event::Start(Tag::Link(_type, href, _title))) => {
                     let mut link = self.parse_link(href.to_string())?;
 
                     let mut number = parent.clone();
@@ -432,10 +439,10 @@ impl<'a> SummaryParser<'a> {
 
     /// Try to parse the title line.
     fn parse_title(&mut self) -> Option<String> {
-        if let Some(Event::Start(Tag::Header(1))) = self.next_event() {
+        if let Some(Event::Start(Tag::Heading(1))) = self.next_event() {
             debug!("Found a h1 in the SUMMARY");
 
-            let tags = collect_events!(self.stream, end Tag::Header(1));
+            let tags = collect_events!(self.stream, end Tag::Heading(1));
             Some(stringify_events(tags))
         } else {
             None
@@ -472,13 +479,14 @@ fn get_last_link(links: &mut [SummaryItem]) -> Result<(usize, &mut Link)> {
 
 /// Removes the styling from a list of Markdown events and returns just the
 /// plain text.
-fn stringify_events(events: Vec<Event>) -> String {
+fn stringify_events(events: Vec<Event<'_>>) -> String {
     events
         .into_iter()
         .filter_map(|t| match t {
-            Event::Text(text) => Some(text.into_owned()),
+            Event::Text(text) | Event::Code(text) => Some(text.into_string()),
             _ => None,
-        }).collect()
+        })
+        .collect()
 }
 
 /// A section number like "1.2.3", basically just a newtype'd `Vec<u32>` with
@@ -487,7 +495,7 @@ fn stringify_events(events: Vec<Event>) -> String {
 pub struct SectionNumber(pub Vec<u32>);
 
 impl Display for SectionNumber {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         if self.0.is_empty() {
             write!(f, "0")
         } else {
@@ -629,7 +637,7 @@ mod tests {
         let _ = parser.stream.next(); // skip past start of paragraph
 
         let href = match parser.stream.next() {
-            Some(Event::Start(Tag::Link(href, _))) => href.to_string(),
+            Some((Event::Start(Tag::Link(_type, href, _title)), _range)) => href.to_string(),
             other => panic!("Unreachable, {:?}", other),
         };
 
@@ -728,11 +736,12 @@ mod tests {
         assert!(got.is_err());
     }
 
-    /// Regression test for https://github.com/rust-lang-nursery/mdBook/issues/779
+    /// Regression test for https://github.com/rust-lang/mdBook/issues/779
     /// Ensure section numbers are correctly incremented after a horizontal separator.
     #[test]
     fn keep_numbering_after_separator() {
-        let src = "- [First](./first.md)\n---\n- [Second](./second.md)\n---\n- [Third](./third.md)\n";
+        let src =
+            "- [First](./first.md)\n---\n- [Second](./second.md)\n---\n- [Third](./third.md)\n";
         let should_be = vec![
             SummaryItem::Link(Link {
                 name: String::from("First"),

src/cmd/build.rs

@@ -1,7 +1,7 @@
+use crate::{get_book_dir, open};
 use clap::{App, ArgMatches, SubCommand};
 use mdbook::errors::Result;
 use mdbook::MDBook;
-use {get_book_dir, open};
 
 // Create clap subcommand arguments
 pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
@@ -9,11 +9,14 @@ pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
         .about("Builds a book from its markdown files")
         .arg_from_usage(
             "-d, --dest-dir=[dest-dir] 'Output directory for the book{n}\
-             (If omitted, uses build.build-dir from book.toml or defaults to ./book)'",
-        ).arg_from_usage(
+             Relative paths are interpreted relative to the book's root directory.{n}\
+             If omitted, mdBook uses build.build-dir from book.toml or defaults to `./book`.'",
+        )
+        .arg_from_usage(
             "[dir] 'Root directory for the book{n}\
              (Defaults to the Current Directory when omitted)'",
-        ).arg_from_usage("-o, --open 'Opens the compiled book in a web browser'")
+        )
+        .arg_from_usage("-o, --open 'Opens the compiled book in a web browser'")
 }
 
 // Build command implementation

src/cmd/clean.rs

@@ -1,5 +1,5 @@
+use crate::get_book_dir;
 use clap::{App, ArgMatches, SubCommand};
-use get_book_dir;
 use mdbook::errors::*;
 use mdbook::MDBook;
 use std::fs;
@@ -10,15 +10,18 @@ pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
         .about("Deletes a built book")
         .arg_from_usage(
             "-d, --dest-dir=[dest-dir] 'Output directory for the book{n}\
-             (If omitted, uses build.build-dir from book.toml or defaults to ./book)'",
-        ).arg_from_usage(
+             Relative paths are interpreted relative to the book's root directory.{n}\
+             Running this command deletes this directory.{n}\
+             If omitted, mdBook uses build.build-dir from book.toml or defaults to `./book`.'",
+        )
+        .arg_from_usage(
             "[dir] 'Root directory for the book{n}\
              (Defaults to the Current Directory when omitted)'",
         )
 }
 
 // Clean command implementation
-pub fn execute(args: &ArgMatches) -> ::mdbook::errors::Result<()> {
+pub fn execute(args: &ArgMatches) -> mdbook::errors::Result<()> {
     let book_dir = get_book_dir(args);
     let book = MDBook::load(&book_dir)?;
 
@@ -26,7 +29,10 @@ pub fn execute(args: &ArgMatches) -> ::mdbook::errors::Result<()> {
         Some(dest_dir) => dest_dir.into(),
         None => book.root.join(&book.config.build.build_dir),
     };
-    fs::remove_dir_all(&dir_to_remove).chain_err(|| "Unable to remove the build directory")?;
+
+    if dir_to_remove.exists() {
+        fs::remove_dir_all(&dir_to_remove).chain_err(|| "Unable to remove the build directory")?;
+    }
 
     Ok(())
 }

src/cmd/init.rs

@@ -1,5 +1,5 @@
+use crate::get_book_dir;
 use clap::{App, ArgMatches, SubCommand};
-use get_book_dir;
 use mdbook::config;
 use mdbook::errors::Result;
 use mdbook::MDBook;
@@ -12,8 +12,10 @@ pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
     SubCommand::with_name("init")
         .about("Creates the boilerplate structure and files for a new book")
         // the {n} denotes a newline which will properly aligned in all help messages
-        .arg_from_usage("[dir] 'Directory to create the book in{n}\
-            (Defaults to the Current Directory when omitted)'")
+        .arg_from_usage(
+            "[dir] 'Directory to create the book in{n}\
+             (Defaults to the Current Directory when omitted)'",
+        )
         .arg_from_usage("--theme 'Copies the default theme into your source folder'")
         .arg_from_usage("--force 'Skips confirmation prompts'")
 }

src/cmd/serve.rs

@@ -1,18 +1,11 @@
-extern crate iron;
-extern crate staticfile;
-extern crate ws;
-
-use self::iron::{
-    status, AfterMiddleware, Chain, Iron, IronError, IronResult, Request, Response, Set,
-};
 #[cfg(feature = "watch")]
 use super::watch;
+use crate::{get_book_dir, open};
 use clap::{App, Arg, ArgMatches, SubCommand};
+use iron::{status, AfterMiddleware, Chain, Iron, IronError, IronResult, Request, Response, Set};
 use mdbook::errors::*;
 use mdbook::utils;
 use mdbook::MDBook;
-use std;
-use {get_book_dir, open};
 
 struct ErrorRecover;
 
@@ -22,7 +15,8 @@ pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
         .about("Serves a book at http://localhost:3000, and rebuilds it on changes")
         .arg_from_usage(
             "-d, --dest-dir=[dest-dir] 'Output directory for the book{n}\
-             (If omitted, uses build.build-dir from book.toml or defaults to ./book)'",
+             Relative paths are interpreted relative to the book's root directory.{n}\
+             If omitted, mdBook uses build.build-dir from book.toml or defaults to `./book`.'",
         )
         .arg_from_usage(
             "[dir] 'Root directory for the book{n}\
@@ -75,7 +69,7 @@ pub fn execute(args: &ArgMatches) -> Result<()> {
     let port = args.value_of("port").unwrap();
     let ws_port = args.value_of("websocket-port").unwrap();
     let hostname = args.value_of("hostname").unwrap();
-    let public_address = args.value_of("websocket-address").unwrap_or(hostname);
+    let public_address = args.value_of("websocket-hostname").unwrap_or(hostname);
     let open_browser = args.is_present("open");
 
     let address = format!("{}:{}", hostname, port);
@@ -114,8 +108,8 @@ pub fn execute(args: &ArgMatches) -> Result<()> {
     }
 
     #[cfg(feature = "watch")]
-    watch::trigger_on_change(&mut book, move |path, book_dir| {
-        info!("File changed: {:?}", path);
+    watch::trigger_on_change(&book, move |paths, book_dir| {
+        info!("Files changed: {:?}", paths);
         info!("Building book...");
 
         // FIXME: This area is really ugly because we need to re-set livereload :(
@@ -125,7 +119,8 @@ pub fn execute(args: &ArgMatches) -> Result<()> {
                 b.config
                     .set("output.html.livereload-url", &livereload_url)?;
                 Ok(b)
-            }).and_then(|b| b.build());
+            })
+            .and_then(|b| b.build());
 
         if let Err(e) = result {
             error!("Unable to load the book");

src/cmd/test.rs

@@ -1,5 +1,5 @@
+use crate::get_book_dir;
 use clap::{App, Arg, ArgMatches, SubCommand};
-use get_book_dir;
 use mdbook::errors::Result;
 use mdbook::MDBook;
 
@@ -9,7 +9,8 @@ pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
         .about("Tests that a book's Rust code samples compile")
         .arg_from_usage(
             "-d, --dest-dir=[dest-dir] 'Output directory for the book{n}\
-             (If omitted, uses build.build-dir from book.toml or defaults to ./book)'",
+             Relative paths are interpreted relative to the book's root directory.{n}\
+             If omitted, mdBook uses build.build-dir from book.toml or defaults to `./book`.'",
         )
         .arg_from_usage(
             "[dir] 'Root directory for the book{n}\
@@ -30,7 +31,7 @@ pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
 pub fn execute(args: &ArgMatches) -> Result<()> {
     let library_paths: Vec<&str> = args
         .values_of("library-path")
-        .map(|v| v.collect())
+        .map(std::iter::Iterator::collect)
         .unwrap_or_default();
     let book_dir = get_book_dir(args);
     let mut book = MDBook::load(&book_dir)?;

src/cmd/watch.rs

@@ -1,14 +1,13 @@
-extern crate notify;
-
-use self::notify::Watcher;
+use crate::{get_book_dir, open};
 use clap::{App, ArgMatches, SubCommand};
 use mdbook::errors::Result;
 use mdbook::utils;
 use mdbook::MDBook;
-use std::path::Path;
+use notify::Watcher;
+use std::path::{Path, PathBuf};
 use std::sync::mpsc::channel;
+use std::thread::sleep;
 use std::time::Duration;
-use {get_book_dir, open};
 
 // Create clap subcommand arguments
 pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
@@ -16,11 +15,14 @@ pub fn make_subcommand<'a, 'b>() -> App<'a, 'b> {
         .about("Watches a book's files and rebuilds it on changes")
         .arg_from_usage(
             "-d, --dest-dir=[dest-dir] 'Output directory for the book{n}\
-             (If omitted, uses build.build-dir from book.toml or defaults to ./book)'",
-        ).arg_from_usage(
+             Relative paths are interpreted relative to the book's root directory.{n}\
+             If omitted, mdBook uses build.build-dir from book.toml or defaults to `./book`.'",
+        )
+        .arg_from_usage(
             "[dir] 'Root directory for the book{n}\
              (Defaults to the Current Directory when omitted)'",
-        ).arg_from_usage("-o, --open 'Open the compiled book in a web browser'")
+        )
+        .arg_from_usage("-o, --open 'Open the compiled book in a web browser'")
 }
 
 // Watch command implementation
@@ -33,8 +35,8 @@ pub fn execute(args: &ArgMatches) -> Result<()> {
         open(book.build_dir_for("html").join("index.html"));
     }
 
-    trigger_on_change(&book, |path, book_dir| {
-        info!("File changed: {:?}\nBuilding book...\n", path);
+    trigger_on_change(&book, |paths, book_dir| {
+        info!("Files changed: {:?}\nBuilding book...\n", paths);
         let result = MDBook::load(&book_dir).and_then(|b| b.build());
 
         if let Err(e) = result {
@@ -46,13 +48,60 @@ pub fn execute(args: &ArgMatches) -> Result<()> {
     Ok(())
 }
 
+fn remove_ignored_files(book_root: &PathBuf, paths: &[PathBuf]) -> Vec<PathBuf> {
+    if paths.is_empty() {
+        return vec![];
+    }
+
+    match find_gitignore(book_root) {
+        Some(gitignore_path) => {
+            match gitignore::File::new(gitignore_path.as_path()) {
+                Ok(exclusion_checker) => filter_ignored_files(exclusion_checker, paths),
+                Err(_) => {
+                    // We're unable to read the .gitignore file, so we'll silently allow everything.
+                    // Please see discussion: https://github.com/rust-lang/mdBook/pull/1051
+                    paths.iter().map(|path| path.to_path_buf()).collect()
+                }
+            }
+        }
+        None => {
+            // There is no .gitignore file.
+            paths.iter().map(|path| path.to_path_buf()).collect()
+        }
+    }
+}
+
+fn find_gitignore(book_root: &PathBuf) -> Option<PathBuf> {
+    book_root
+        .ancestors()
+        .map(|p| p.join(".gitignore"))
+        .find(|p| p.exists())
+}
+
+fn filter_ignored_files(exclusion_checker: gitignore::File, paths: &[PathBuf]) -> Vec<PathBuf> {
+    paths
+        .iter()
+        .filter(|path| match exclusion_checker.is_excluded(path) {
+            Ok(exclude) => !exclude,
+            Err(error) => {
+                warn!(
+                    "Unable to determine if {:?} is excluded: {:?}. Including it.",
+                    &path, error
+                );
+                true
+            }
+        })
+        .map(|path| path.to_path_buf())
+        .collect()
+}
+
 /// Calls the closure when a book source file is changed, blocking indefinitely.
 pub fn trigger_on_change<F>(book: &MDBook, closure: F)
 where
-    F: Fn(&Path, &Path),
+    F: Fn(Vec<PathBuf>, &Path),
 {
-    use self::notify::DebouncedEvent::*;
-    use self::notify::RecursiveMode::*;
+    use notify::DebouncedEvent::*;
+    use notify::RecursiveMode::*;
 
     // Create a channel to receive the events.
     let (tx, rx) = channel();
@@ -61,14 +110,14 @@ where
         Ok(w) => w,
         Err(e) => {
             error!("Error while trying to watch the files:\n\n\t{:?}", e);
-            ::std::process::exit(1)
+            std::process::exit(1)
         }
     };
 
     // Add the source directory to the watcher
     if let Err(e) = watcher.watch(book.source_dir(), Recursive) {
         error!("Error while watching {:?}:\n    {:?}", book.source_dir(), e);
-        ::std::process::exit(1);
+        std::process::exit(1);
     };
 
     let _ = watcher.watch(book.theme_dir(), Recursive);
@@ -78,13 +127,28 @@ where
 
     info!("Listening for changes...");
 
-    for event in rx.iter() {
-        debug!("Received filesystem event: {:?}", event);
-        match event {
-            Create(path) | Write(path) | Remove(path) | Rename(_, path) => {
-                closure(&path, &book.root);
-            }
-            _ => {}
+    loop {
+        let first_event = rx.recv().unwrap();
+        sleep(Duration::from_millis(50));
+        let other_events = rx.try_iter();
+
+        let all_events = std::iter::once(first_event).chain(other_events);
+
+        let paths = all_events
+            .filter_map(|event| {
+                debug!("Received filesystem event: {:?}", event);
+
+                match event {
+                    Create(path) | Write(path) | Remove(path) | Rename(_, path) => Some(path),
+                    _ => None,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let paths = remove_ignored_files(&book.root, &paths[..]);
+
+        if !paths.is_empty() {
+            closure(paths, &book.root);
         }
     }
 }

src/config.rs

@@ -3,16 +3,15 @@
 //! The main entrypoint of the `config` module is the `Config` struct. This acts
 //! essentially as a bag of configuration information, with a couple
 //! pre-determined tables (`BookConfig` and `BuildConfig`) as well as support
-//! for arbitrary data which is exposed to plugins and alternate backends.
+//! for arbitrary data which is exposed to plugins and alternative backends.
 //!
 //!
 //! # Examples
 //!
 //! ```rust
-//! # extern crate mdbook;
 //! # use mdbook::errors::*;
-//! # extern crate toml;
 //! use std::path::PathBuf;
+//! use std::str::FromStr;
 //! use mdbook::Config;
 //! use toml::Value;
 //!
@@ -41,8 +40,8 @@
 //! cfg.set("output.html.theme", "./themes");
 //!
 //! // then load it again, automatically deserializing to a `PathBuf`.
-//! let got: PathBuf = cfg.get_deserialized("output.html.theme")?;
-//! assert_eq!(got, PathBuf::from("./themes"));
+//! let got: Option<PathBuf> = cfg.get_deserialized_opt("output.html.theme")?;
+//! assert_eq!(got, Some(PathBuf::from("./themes")));
 //! # Ok(())
 //! # }
 //! # fn main() { run().unwrap() }
@@ -51,18 +50,19 @@
 #![deny(missing_docs)]
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use serde_json;
 use std::env;
 use std::fs::File;
 use std::io::Read;
 use std::path::{Path, PathBuf};
+use std::str::FromStr;
 use toml::value::Table;
 use toml::{self, Value};
 use toml_query::delete::TomlValueDeleteExt;
 use toml_query::insert::TomlValueInsertExt;
 use toml_query::read::TomlValueReadExt;
 
-use errors::*;
+use crate::errors::*;
+use crate::utils;
 
 /// The overall configuration object for MDBook, essentially an in-memory
 /// representation of `book.toml`.
@@ -75,12 +75,16 @@ pub struct Config {
     rest: Value,
 }
 
-impl Config {
+impl FromStr for Config {
+    type Err = Error;
+
     /// Load a `Config` from some string.
-    pub fn from_str(src: &str) -> Result<Config> {
+    fn from_str(src: &str) -> Result<Self> {
         toml::from_str(src).chain_err(|| Error::from("Invalid configuration file"))
     }
+}
 
+impl Config {
     /// Load the configuration file from disk.
     pub fn from_disk<P: AsRef<Path>>(config_file: P) -> Result<Config> {
         let mut buffer = String::new();
@@ -128,10 +132,8 @@ impl Config {
     pub fn update_from_env(&mut self) {
         debug!("Updating the config from environment variables");
 
-        let overrides = env::vars().filter_map(|(key, value)| match parse_env(&key) {
-            Some(index) => Some((index, value)),
-            None => None,
-        });
+        let overrides =
+            env::vars().filter_map(|(key, value)| parse_env(&key).map(|index| (index, value)));
 
         for (key, value) in overrides {
             trace!("{} => {}", key, value);
@@ -148,14 +150,11 @@ impl Config {
     /// `output.html.playpen` will fetch the "playpen" out of the html output
     /// table).
     pub fn get(&self, key: &str) -> Option<&Value> {
-        match self.rest.read(key) {
-            Ok(inner) => inner,
-            Err(_) => None,
-        }
+        self.rest.read(key).unwrap_or(None)
     }
 
     /// Fetch a value from the `Config` so you can mutate it.
-    pub fn get_mut<'a>(&'a mut self, key: &str) -> Option<&'a mut Value> {
+    pub fn get_mut(&mut self, key: &str) -> Option<&mut Value> {
         match self.rest.read_mut(key) {
             Ok(inner) => inner,
             Err(_) => None,
@@ -170,22 +169,41 @@ impl Config {
     /// HTML renderer is refactored to be less coupled to `mdbook` internals.
     #[doc(hidden)]
     pub fn html_config(&self) -> Option<HtmlConfig> {
-        self.get_deserialized("output.html").ok()
+        match self.get_deserialized_opt("output.html") {
+            Ok(Some(config)) => Some(config),
+            Ok(None) => None,
+            Err(e) => {
+                utils::log_backtrace(&e.chain_err(|| "Parsing configuration [output.html]"));
+                None
+            }
+        }
+    }
+
+    /// Deprecated, use get_deserialized_opt instead.
+    #[deprecated = "use get_deserialized_opt instead"]
+    pub fn get_deserialized<'de, T: Deserialize<'de>, S: AsRef<str>>(&self, name: S) -> Result<T> {
+        let name = name.as_ref();
+        match self.get_deserialized_opt(name)? {
+            Some(value) => Ok(value),
+            None => bail!("Key not found, {:?}", name),
+        }
     }
 
     /// Convenience function to fetch a value from the config and deserialize it
     /// into some arbitrary type.
-    pub fn get_deserialized<'de, T: Deserialize<'de>, S: AsRef<str>>(&self, name: S) -> Result<T> {
+    pub fn get_deserialized_opt<'de, T: Deserialize<'de>, S: AsRef<str>>(
+        &self,
+        name: S,
+    ) -> Result<Option<T>> {
         let name = name.as_ref();
-
-        if let Some(value) = self.get(name) {
-            value
-                .clone()
-                .try_into()
-                .chain_err(|| "Couldn't deserialize the value")
-        } else {
-            bail!("Key not found, {:?}", name)
-        }
+        self.get(name)
+            .map(|value| {
+                value
+                    .clone()
+                    .try_into()
+                    .chain_err(|| "Couldn't deserialize the value")
+            })
+            .transpose()
     }
 
     /// Set a config key, clobbering any existing values along the way.
@@ -203,7 +221,9 @@ impl Config {
         } else if index.starts_with("build.") {
             self.build.update_value(&index[6..], value);
         } else {
-            self.rest.insert(index, value)?;
+            self.rest
+                .insert(index, value)
+                .map_err(ErrorKind::TomlQueryError)?;
         }
 
         Ok(())
@@ -212,13 +232,13 @@ impl Config {
     /// Get the table associated with a particular renderer.
     pub fn get_renderer<I: AsRef<str>>(&self, index: I) -> Option<&Table> {
         let key = format!("output.{}", index.as_ref());
-        self.get(&key).and_then(|v| v.as_table())
+        self.get(&key).and_then(Value::as_table)
     }
 
     /// Get the table associated with a particular preprocessor.
     pub fn get_preprocessor<I: AsRef<str>>(&self, index: I) -> Option<&Table> {
         let key = format!("preprocessor.{}", index.as_ref());
-        self.get(&key).and_then(|v| v.as_table())
+        self.get(&key).and_then(Value::as_table)
     }
 
     fn from_legacy(mut table: Value) -> Config {
@@ -265,7 +285,7 @@ impl Default for Config {
     }
 }
 impl<'de> Deserialize<'de> for Config {
-    fn deserialize<D: Deserializer<'de>>(de: D) -> ::std::result::Result<Self, D::Error> {
+    fn deserialize<D: Deserializer<'de>>(de: D) -> std::result::Result<Self, D::Error> {
         let raw = Value::deserialize(de)?;
 
         if is_legacy_format(&raw) {
@@ -276,7 +296,7 @@ impl<'de> Deserialize<'de> for Config {
             warn!("`description` under a table called `[book]`, move the `destination` entry");
             warn!("from `[output.html]`, renamed to `build-dir`, under a table called");
             warn!("`[build]`, and it should all work.");
-            warn!("Documentation: http://rust-lang-nursery.github.io/mdBook/format/config.html");
+            warn!("Documentation: http://rust-lang.github.io/mdBook/format/config.html");
             return Ok(Config::from_legacy(raw));
         }
 
@@ -301,15 +321,15 @@ impl<'de> Deserialize<'de> for Config {
             .unwrap_or_default();
 
         Ok(Config {
-            book: book,
-            build: build,
+            book,
+            build,
             rest: Value::Table(table),
         })
     }
 }
 
 impl Serialize for Config {
-    fn serialize<S: Serializer>(&self, s: S) -> ::std::result::Result<S::Ok, S::Error> {
+    fn serialize<S: Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
         use serde::ser::Error;
 
         let mut table = self.rest.clone();
@@ -371,6 +391,8 @@ pub struct BookConfig {
     pub src: PathBuf,
     /// Does this book support more than one language?
     pub multilingual: bool,
+    /// The main language of the book.
+    pub language: Option<String>,
 }
 
 impl Default for BookConfig {
@@ -381,6 +403,7 @@ impl Default for BookConfig {
             description: None,
             src: PathBuf::from("src"),
             multilingual: false,
+            language: Some(String::from("en")),
         }
     }
 }
@@ -415,6 +438,11 @@ impl Default for BuildConfig {
 pub struct HtmlConfig {
     /// The theme directory, if specified.
     pub theme: Option<PathBuf>,
+    /// The default theme to use, defaults to 'light'
+    pub default_theme: Option<String>,
+    /// The theme to use if the browser requests the dark version of the site.
+    /// Defaults to the same as 'default_theme'
+    pub preferred_dark_theme: Option<String>,
     /// Use "smart quotes" instead of the usual `"` character.
     pub curly_quotes: bool,
     /// Should mathjax be enabled?
@@ -426,8 +454,19 @@ pub struct HtmlConfig {
     /// Additional JS scripts to include at the bottom of the rendered page's
     /// `<body>`.
     pub additional_js: Vec<PathBuf>,
+    /// Fold settings.
+    pub fold: Fold,
     /// Playpen settings.
     pub playpen: Playpen,
+    /// Don't render section labels.
+    pub no_section_label: bool,
+    /// Search settings. If `None`, the default will be used.
+    pub search: Option<Search>,
+    /// Git repository url. If `None`, the git button will not be shown.
+    pub git_repository_url: Option<String>,
+    /// FontAwesome icon class to use for the Git repository link.
+    /// Defaults to `fa-github` if `None`.
+    pub git_repository_icon: 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
@@ -436,10 +475,6 @@ pub struct HtmlConfig {
     /// This config item *should not be edited* by the end user.
     #[doc(hidden)]
     pub livereload_url: Option<String>,
-    /// Should section labels be rendered?
-    pub no_section_label: bool,
-    /// Search settings. If `None`, the default will be used.
-    pub search: Option<Search>,
 }
 
 impl HtmlConfig {
@@ -453,22 +488,40 @@ impl HtmlConfig {
     }
 }
 
+/// Configuration for how to fold chapters of sidebar.
+#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "kebab-case")]
+pub struct Fold {
+    /// When off, all folds are open. Default: `false`.
+    pub enable: bool,
+    /// The higher the more folded regions are open. When level is 0, all folds
+    /// are closed.
+    /// Default: `0`.
+    pub level: u8,
+}
+
 /// Configuration for tweaking how the the HTML renderer handles the playpen.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "kebab-case")]
 pub struct Playpen {
     /// Should playpen snippets be editable? Default: `false`.
     pub editable: bool,
+    /// Display the copy button. Default: `true`.
+    pub copyable: bool,
     /// Copy JavaScript files for the editor to the output directory?
     /// Default: `true`.
     pub copy_js: bool,
+    /// Display line numbers on playpen snippets. Default: `false`.
+    pub line_numbers: bool,
 }
 
 impl Default for Playpen {
     fn default() -> Playpen {
         Playpen {
             editable: false,
+            copyable: true,
             copy_js: true,
+            line_numbers: false,
         }
     }
 }
@@ -484,7 +537,7 @@ pub struct Search {
     /// The number of words used for a search result teaser. Default: `30`.
     pub teaser_word_count: u32,
     /// Define the logical link between multiple search words.
-    /// If true, all search words must appear in each result. Default: `true`.
+    /// If true, all search words must appear in each result. Default: `false`.
     pub use_boolean_and: bool,
     /// Boost factor for the search result score if a search word appears in the header.
     /// Default: `2`.
@@ -533,12 +586,10 @@ trait Updateable<'de>: Serialize + Deserialize<'de> {
     fn update_value<S: Serialize>(&mut self, key: &str, value: S) {
         let mut raw = Value::try_from(&self).expect("unreachable");
 
-        {
-            if let Ok(value) = Value::try_from(value) {
-                let _ = raw.insert(key, value);
-            } else {
-                return;
-            }
+        if let Ok(value) = Value::try_from(value) {
+            let _ = raw.insert(key, value);
+        } else {
+            return;
         }
 
         if let Ok(updated) = raw.try_into() {
@@ -553,13 +604,14 @@ impl<'de, T> Updateable<'de> for T where T: Serialize + Deserialize<'de> {}
 mod tests {
     use super::*;
 
-    const COMPLEX_CONFIG: &'static str = r#"
+    const COMPLEX_CONFIG: &str = r#"
         [book]
         title = "Some Book"
         authors = ["Michael-F-Bryan <michaelfbryan@gmail.com>"]
         description = "A completely useless book"
         multilingual = true
         src = "source"
+        language = "ja"
 
         [build]
         build-dir = "outputs"
@@ -568,17 +620,20 @@ mod tests {
 
         [output.html]
         theme = "./themedir"
+        default-theme = "rust"
         curly-quotes = true
         google-analytics = "123456"
         additional-css = ["./foo/bar/baz.css"]
+        git-repository-url = "https://foo.com/"
+        git-repository-icon = "fa-code-fork"
 
         [output.html.playpen]
         editable = true
         editor = "ace"
 
-        [preprocess.first]
+        [preprocessor.first]
 
-        [preprocess.second]
+        [preprocessor.second]
         "#;
 
     #[test]
@@ -591,7 +646,7 @@ mod tests {
             description: Some(String::from("A completely useless book")),
             multilingual: true,
             src: PathBuf::from("source"),
-            ..Default::default()
+            language: Some(String::from("ja")),
         };
         let build_should_be = BuildConfig {
             build_dir: PathBuf::from("outputs"),
@@ -600,14 +655,19 @@ mod tests {
         };
         let playpen_should_be = Playpen {
             editable: true,
+            copyable: true,
             copy_js: true,
+            line_numbers: false,
         };
         let html_should_be = HtmlConfig {
             curly_quotes: true,
             google_analytics: Some(String::from("123456")),
             additional_css: vec![PathBuf::from("./foo/bar/baz.css")],
             theme: Some(PathBuf::from("./themedir")),
+            default_theme: Some(String::from("rust")),
             playpen: playpen_should_be,
+            git_repository_url: Some(String::from("https://foo.com/")),
+            git_repository_icon: Some(String::from("fa-code-fork")),
             ..Default::default()
         };
 
@@ -641,14 +701,17 @@ mod tests {
         };
 
         let cfg = Config::from_str(src).unwrap();
-        let got: RandomOutput = cfg.get_deserialized("output.random").unwrap();
+        let got: RandomOutput = cfg.get_deserialized_opt("output.random").unwrap().unwrap();
 
         assert_eq!(got, should_be);
 
-        let baz: Vec<bool> = cfg.get_deserialized("output.random.baz").unwrap();
+        let got_baz: Vec<bool> = cfg
+            .get_deserialized_opt("output.random.baz")
+            .unwrap()
+            .unwrap();
         let baz_should_be = vec![true, true, false];
 
-        assert_eq!(baz, baz_should_be);
+        assert_eq!(got_baz, baz_should_be);
     }
 
     #[test]
@@ -725,7 +788,7 @@ mod tests {
         assert!(cfg.get(key).is_none());
         cfg.set(key, value).unwrap();
 
-        let got: String = cfg.get_deserialized(key).unwrap();
+        let got: String = cfg.get_deserialized_opt(key).unwrap().unwrap();
         assert_eq!(got, value);
     }
 
@@ -740,7 +803,7 @@ mod tests {
 
         for (src, should_be) in inputs {
             let got = parse_env(src);
-            let should_be = should_be.map(|s| s.to_string());
+            let should_be = should_be.map(ToString::to_string);
 
             assert_eq!(got, should_be);
         }
@@ -766,10 +829,14 @@ mod tests {
 
         cfg.update_from_env();
 
-        assert_eq!(cfg.get_deserialized::<String, _>(key).unwrap(), value);
+        assert_eq!(
+            cfg.get_deserialized_opt::<String, _>(key).unwrap().unwrap(),
+            value
+        );
     }
 
     #[test]
+    #[allow(clippy::approx_constant)]
     fn update_config_using_env_var_and_complex_value() {
         let mut cfg = Config::default();
         let key = "foo-bar.baz";
@@ -784,7 +851,9 @@ mod tests {
         cfg.update_from_env();
 
         assert_eq!(
-            cfg.get_deserialized::<serde_json::Value, _>(key).unwrap(),
+            cfg.get_deserialized_opt::<serde_json::Value, _>(key)
+                .unwrap()
+                .unwrap(),
             value
         );
     }

src/lib.rs

@@ -75,33 +75,24 @@
 //! directly, making deserializing the `RenderContext` easy and giving you
 //! access to the various methods for working with the [`Config`].
 //!
-//! [user guide]: https://rust-lang-nursery.github.io/mdBook/
+//! [user guide]: https://rust-lang.github.io/mdBook/
 //! [`RenderContext`]: renderer/struct.RenderContext.html
-//! [relevant chapter]: https://rust-lang-nursery.github.io/mdBook/for_developers/backends.html
+//! [relevant chapter]: https://rust-lang.github.io/mdBook/for_developers/backends.html
 //! [`Config`]: config/struct.Config.html
 
 #![deny(missing_docs)]
+#![deny(rust_2018_idioms)]
 
 #[macro_use]
 extern crate error_chain;
-extern crate handlebars;
-extern crate itertools;
 #[macro_use]
 extern crate lazy_static;
 #[macro_use]
 extern crate log;
-extern crate memchr;
-extern crate pulldown_cmark;
-extern crate regex;
-extern crate serde;
 #[macro_use]
 extern crate serde_derive;
 #[macro_use]
 extern crate serde_json;
-extern crate shlex;
-extern crate tempfile;
-extern crate toml;
-extern crate toml_query;
 
 #[cfg(test)]
 #[macro_use]
@@ -120,31 +111,27 @@ pub mod utils;
 /// compatibility checks.
 pub const MDBOOK_VERSION: &str = env!("CARGO_PKG_VERSION");
 
-pub use book::BookItem;
-pub use book::MDBook;
-pub use config::Config;
-pub use renderer::Renderer;
+pub use crate::book::BookItem;
+pub use crate::book::MDBook;
+pub use crate::config::Config;
+pub use crate::renderer::Renderer;
 
 /// The error types used through out this crate.
 pub mod errors {
     use std::path::PathBuf;
 
-    error_chain!{
+    error_chain! {
         foreign_links {
-            Io(::std::io::Error) #[doc = "A wrapper around `std::io::Error`"];
-            HandlebarsRender(::handlebars::RenderError) #[doc = "Handlebars rendering failed"];
-            HandlebarsTemplate(Box<::handlebars::TemplateError>) #[doc = "Unable to parse the template"];
-            Utf8(::std::string::FromUtf8Error) #[doc = "Invalid UTF-8"];
-            SerdeJson(::serde_json::Error) #[doc = "JSON conversion failed"];
-        }
-
-        links {
-            TomlQuery(::toml_query::error::Error, ::toml_query::error::ErrorKind) #[doc = "A TomlQuery error"];
+            Io(std::io::Error) #[doc = "A wrapper around `std::io::Error`"];
+            HandlebarsRender(handlebars::RenderError) #[doc = "Handlebars rendering failed"];
+            HandlebarsTemplate(Box<handlebars::TemplateError>) #[doc = "Unable to parse the template"];
+            Utf8(std::string::FromUtf8Error) #[doc = "Invalid UTF-8"];
+            SerdeJson(serde_json::Error) #[doc = "JSON conversion failed"];
         }
 
         errors {
             /// A subprocess exited with an unsuccessful return code.
-            Subprocess(message: String, output: ::std::process::Output) {
+            Subprocess(message: String, output: std::process::Output) {
                 description("A subprocess failed")
                 display("{}: {}", message, String::from_utf8_lossy(&output.stdout))
             }
@@ -160,12 +147,18 @@ pub mod errors {
                 description("Reserved Filename")
                 display("{} is reserved for internal use", filename.display())
             }
+
+            /// Error with a TOML file.
+            TomlQueryError(inner: toml_query::error::Error) {
+                description("toml_query error")
+                display("{}", inner)
+            }
         }
     }
 
     // Box to halve the size of Error
-    impl From<::handlebars::TemplateError> for Error {
-        fn from(e: ::handlebars::TemplateError) -> Error {
+    impl From<handlebars::TemplateError> for Error {
+        fn from(e: handlebars::TemplateError) -> Error {
             From::from(Box::new(e))
         }
     }

src/main.rs

@@ -1,12 +1,7 @@
-extern crate chrono;
 #[macro_use]
 extern crate clap;
-extern crate env_logger;
-extern crate error_chain;
 #[macro_use]
 extern crate log;
-extern crate mdbook;
-extern crate open;
 
 use chrono::Local;
 use clap::{App, AppSettings, ArgMatches};
@@ -20,22 +15,22 @@ use std::path::{Path, PathBuf};
 
 mod cmd;
 
-const NAME: &'static str = "mdBook";
-const VERSION: &'static str = concat!("v", crate_version!());
+const VERSION: &str = concat!("v", crate_version!());
 
 fn main() {
     init_logger();
 
     // Create a list of valid arguments and sub-commands
-    let app = App::new(NAME)
-        .about("Creates a book from markdown files")
+    let app = App::new(crate_name!())
+        .about(crate_description!())
         .author("Mathieu David <mathieudavid@mathieudavid.org>")
         .version(VERSION)
         .setting(AppSettings::GlobalVersion)
         .setting(AppSettings::ArgRequiredElseHelp)
+        .setting(AppSettings::ColoredHelp)
         .after_help(
             "For more information about a specific command, try `mdbook <command> --help`\n\
-             The source code for mdBook is available at: https://github.com/rust-lang-nursery/mdBook",
+             The source code for mdBook is available at: https://github.com/rust-lang/mdBook",
         )
         .subcommand(cmd::init::make_subcommand())
         .subcommand(cmd::build::make_subcommand())
@@ -63,7 +58,7 @@ fn main() {
     if let Err(e) = res {
         utils::log_backtrace(&e);
 
-        ::std::process::exit(101);
+        std::process::exit(101);
     }
 }
 
@@ -82,7 +77,7 @@ fn init_logger() {
     });
 
     if let Ok(var) = env::var("RUST_LOG") {
-        builder.parse(&var);
+        builder.parse_filters(&var);
     } else {
         // if no RUST_LOG provided, default to logging at the Info level
         builder.filter(None, LevelFilter::Info);

src/preprocess/cmd.rs

@@ -1,7 +1,6 @@
 use super::{Preprocessor, PreprocessorContext};
-use book::Book;
-use errors::*;
-use serde_json;
+use crate::book::Book;
+use crate::errors::*;
 use shlex::Shlex;
 use std::io::{self, Read, Write};
 use std::process::{Child, Command, Stdio};
@@ -43,19 +42,11 @@ impl CmdPreprocessor {
 
     /// A convenience function custom preprocessors can use to parse the input
     /// written to `stdin` by a `CmdRenderer`.
-    pub fn parse_input<R: Read>(
-        reader: R,
-    ) -> Result<(PreprocessorContext, Book)> {
-        serde_json::from_reader(reader)
-            .chain_err(|| "Unable to parse the input")
+    pub fn parse_input<R: Read>(reader: R) -> Result<(PreprocessorContext, Book)> {
+        serde_json::from_reader(reader).chain_err(|| "Unable to parse the input")
     }
 
-    fn write_input_to_child(
-        &self,
-        child: &mut Child,
-        book: &Book,
-        ctx: &PreprocessorContext,
-    ) {
+    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) {
@@ -65,9 +56,13 @@ impl CmdPreprocessor {
         }
     }
 
-    fn write_input<W: Write>(&self, writer: W, book: &Book, ctx: &PreprocessorContext) -> Result<()> {
-        serde_json::to_writer(writer, &(ctx, book))
-            .map_err(Into::into)
+    fn write_input<W: Write>(
+        &self,
+        writer: W,
+        book: &Book,
+        ctx: &PreprocessorContext,
+    ) -> Result<()> {
+        serde_json::to_writer(writer, &(ctx, book)).map_err(Into::into)
     }
 
     /// The command this `Preprocessor` will invoke.
@@ -105,7 +100,12 @@ impl Preprocessor for CmdPreprocessor {
             .stdout(Stdio::piped())
             .stderr(Stdio::inherit())
             .spawn()
-            .chain_err(|| format!("Unable to start the \"{}\" preprocessor. Is it installed?", self.name()))?;
+            .chain_err(|| {
+                format!(
+                    "Unable to start the \"{}\" preprocessor. Is it installed?",
+                    self.name()
+                )
+            })?;
 
         self.write_input_to_child(&mut child, &book, ctx);
 
@@ -114,18 +114,29 @@ impl Preprocessor for CmdPreprocessor {
             .chain_err(|| "Error waiting for the preprocessor to complete")?;
 
         trace!("{} exited with output: {:?}", self.cmd, output);
-        ensure!(output.status.success(), "The preprocessor exited unsuccessfully");
+        ensure!(
+            output.status.success(),
+            "The preprocessor exited unsuccessfully"
+        );
 
         serde_json::from_slice(&output.stdout).chain_err(|| "Unable to parse the preprocessed book")
     }
 
     fn supports_renderer(&self, renderer: &str) -> bool {
-        debug!("Checking if the \"{}\" preprocessor supports \"{}\"", self.name(), renderer);
+        debug!(
+            "Checking if the \"{}\" preprocessor supports \"{}\"",
+            self.name(),
+            renderer
+        );
 
         let mut cmd = match self.command() {
             Ok(c) => c,
             Err(e) => {
-                warn!("Unable to create the command for the \"{}\" preprocessor, {}", self.name(), e);
+                warn!(
+                    "Unable to create the command for the \"{}\" preprocessor, {}",
+                    self.name(),
+                    e
+                );
                 return false;
             }
         };
@@ -152,3 +163,34 @@ impl Preprocessor for CmdPreprocessor {
         outcome.unwrap_or(false)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::MDBook;
+    use std::path::Path;
+
+    fn book_example() -> MDBook {
+        let example = Path::new(env!("CARGO_MANIFEST_DIR")).join("book-example");
+        MDBook::load(example).unwrap()
+    }
+
+    #[test]
+    fn round_trip_write_and_parse_input() {
+        let cmd = CmdPreprocessor::new("test".to_string(), "test".to_string());
+        let md = book_example();
+        let ctx = PreprocessorContext::new(
+            md.root.clone(),
+            md.config.clone(),
+            "some-renderer".to_string(),
+        );
+
+        let mut buffer = Vec::new();
+        cmd.write_input(&mut buffer, &md.book, &ctx).unwrap();
+
+        let (got_ctx, got_book) = CmdPreprocessor::parse_input(buffer.as_slice()).unwrap();
+
+        assert_eq!(got_book, md.book);
+        assert_eq!(got_ctx, ctx);
+    }
+}

src/preprocess/index.rs

@@ -1,13 +1,14 @@
 use regex::Regex;
 use std::path::Path;
 
-use errors::*;
+use crate::errors::*;
 
 use super::{Preprocessor, PreprocessorContext};
-use book::{Book, BookItem};
+use crate::book::{Book, BookItem};
 
 /// A preprocessor for converting file name `README.md` to `index.md` since
-/// `README.md` is the de facto index file in a markdown-based documentation.
+/// `README.md` is the de facto index file in markdown-based documentation.
+#[derive(Default)]
 pub struct IndexPreprocessor;
 
 impl IndexPreprocessor {
@@ -45,7 +46,10 @@ impl Preprocessor for IndexPreprocessor {
 
 fn warn_readme_name_conflict<P: AsRef<Path>>(readme_path: P, index_path: P) {
     let file_name = readme_path.as_ref().file_name().unwrap_or_default();
-    let parent_dir = index_path.as_ref().parent().unwrap_or(index_path.as_ref());
+    let parent_dir = index_path
+        .as_ref()
+        .parent()
+        .unwrap_or_else(|| index_path.as_ref());
     warn!(
         "It seems that there are both {:?} and index.md under \"{}\".",
         file_name,
@@ -67,7 +71,7 @@ fn is_readme_file<P: AsRef<Path>>(path: P) -> bool {
     RE.is_match(
         path.as_ref()
             .file_stem()
-            .and_then(|s| s.to_str())
+            .and_then(std::ffi::OsStr::to_str)
             .unwrap_or_default(),
     )
 }

src/preprocess/links.rs

@@ -1,18 +1,29 @@
-use errors::*;
+use crate::errors::*;
+use crate::utils::{
+    take_anchored_lines, take_lines, take_rustdoc_include_anchored_lines,
+    take_rustdoc_include_lines,
+};
 use regex::{CaptureMatches, Captures, Regex};
-use std::ops::{Range, RangeFrom, RangeFull, RangeTo};
+use std::fs;
+use std::ops::{Bound, Range, RangeBounds, RangeFrom, RangeFull, RangeTo};
 use std::path::{Path, PathBuf};
-use utils::fs::file_to_string;
-use utils::take_lines;
 
 use super::{Preprocessor, PreprocessorContext};
-use book::{Book, BookItem};
+use crate::book::{Book, BookItem};
 
 const ESCAPE_CHAR: char = '\\';
 const MAX_LINK_NESTED_DEPTH: usize = 10;
 
-/// A preprocessor for expanding the `{{# playpen}}` and `{{# include}}`
-/// helpers in a chapter.
+/// A preprocessor for expanding helpers in a chapter. Supported helpers are:
+///
+/// - `{{# include}}` - Insert an external file of any type. Include the whole file, only particular
+///.  lines, or only between the specified anchors.
+/// - `{{# rustdoc_include}}` - Insert an external Rust file, showing the particular lines
+///.  specified or the lines between specified anchors, and include the rest of the file behind `#`.
+///   This hides the lines from initial display but shows them when the reader expands the code
+///   block and provides them to Rustdoc for testing.
+/// - `{{# playpen}}` - Insert runnable Rust files
+#[derive(Default)]
 pub struct LinkPreprocessor;
 
 impl LinkPreprocessor {
@@ -62,19 +73,14 @@ where
     let mut previous_end_index = 0;
     let mut replaced = String::new();
 
-    for playpen in find_links(s) {
-        replaced.push_str(&s[previous_end_index..playpen.start_index]);
+    for link in find_links(s) {
+        replaced.push_str(&s[previous_end_index..link.start_index]);
 
-        match playpen.render_with_path(&path) {
+        match link.render_with_path(&path) {
             Ok(new_content) => {
                 if depth < MAX_LINK_NESTED_DEPTH {
-                    if let Some(rel_path) = playpen.link.relative_path(path) {
-                        replaced.push_str(&replace_all(
-                            &new_content,
-                            rel_path,
-                            source,
-                            depth + 1,
-                        ));
+                    if let Some(rel_path) = link.link_type.relative_path(path) {
+                        replaced.push_str(&replace_all(&new_content, rel_path, source, depth + 1));
                     } else {
                         replaced.push_str(&new_content);
                     }
@@ -84,17 +90,17 @@ where
                         source.display()
                     );
                 }
-                previous_end_index = playpen.end_index;
+                previous_end_index = link.end_index;
             }
             Err(e) => {
-                error!("Error updating \"{}\", {}", playpen.link_text, e);
+                error!("Error updating \"{}\", {}", link.link_text, e);
                 for cause in e.iter().skip(1) {
                     warn!("Caused By: {}", cause);
                 }
 
                 // This should make sure we include the raw `{{# ... }}` snippet
                 // in the page content if there are any errors.
-                previous_end_index = playpen.start_index;
+                previous_end_index = link.start_index;
             }
         }
     }
@@ -106,11 +112,68 @@ where
 #[derive(PartialEq, Debug, Clone)]
 enum LinkType<'a> {
     Escaped,
-    IncludeRange(PathBuf, Range<usize>),
-    IncludeRangeFrom(PathBuf, RangeFrom<usize>),
-    IncludeRangeTo(PathBuf, RangeTo<usize>),
-    IncludeRangeFull(PathBuf, RangeFull),
+    Include(PathBuf, RangeOrAnchor),
     Playpen(PathBuf, Vec<&'a str>),
+    RustdocInclude(PathBuf, RangeOrAnchor),
+}
+
+#[derive(PartialEq, Debug, Clone)]
+enum RangeOrAnchor {
+    Range(LineRange),
+    Anchor(String),
+}
+
+// A range of lines specified with some include directive.
+#[derive(PartialEq, Debug, Clone)]
+enum LineRange {
+    Range(Range<usize>),
+    RangeFrom(RangeFrom<usize>),
+    RangeTo(RangeTo<usize>),
+    RangeFull(RangeFull),
+}
+
+impl RangeBounds<usize> for LineRange {
+    fn start_bound(&self) -> Bound<&usize> {
+        match self {
+            LineRange::Range(r) => r.start_bound(),
+            LineRange::RangeFrom(r) => r.start_bound(),
+            LineRange::RangeTo(r) => r.start_bound(),
+            LineRange::RangeFull(r) => r.start_bound(),
+        }
+    }
+
+    fn end_bound(&self) -> Bound<&usize> {
+        match self {
+            LineRange::Range(r) => r.end_bound(),
+            LineRange::RangeFrom(r) => r.end_bound(),
+            LineRange::RangeTo(r) => r.end_bound(),
+            LineRange::RangeFull(r) => r.end_bound(),
+        }
+    }
+}
+
+impl From<Range<usize>> for LineRange {
+    fn from(r: Range<usize>) -> LineRange {
+        LineRange::Range(r)
+    }
+}
+
+impl From<RangeFrom<usize>> for LineRange {
+    fn from(r: RangeFrom<usize>) -> LineRange {
+        LineRange::RangeFrom(r)
+    }
+}
+
+impl From<RangeTo<usize>> for LineRange {
+    fn from(r: RangeTo<usize>) -> LineRange {
+        LineRange::RangeTo(r)
+    }
+}
+
+impl From<RangeFull> for LineRange {
+    fn from(r: RangeFull) -> LineRange {
+        LineRange::RangeFull(r)
+    }
 }
 
 impl<'a> LinkType<'a> {
@@ -118,19 +181,9 @@ impl<'a> LinkType<'a> {
         let base = base.as_ref();
         match self {
             LinkType::Escaped => None,
-            LinkType::IncludeRange(p, _) => {
-                Some(return_relative_path(base, &p))
-            }
-            LinkType::IncludeRangeFrom(p, _) => {
-                Some(return_relative_path(base, &p))
-            }
-            LinkType::IncludeRangeTo(p, _) => {
-                Some(return_relative_path(base, &p))
-            }
-            LinkType::IncludeRangeFull(p, _) => {
-                Some(return_relative_path(base, &p))
-            }
+            LinkType::Include(p, _) => Some(return_relative_path(base, &p)),
             LinkType::Playpen(p, _) => Some(return_relative_path(base, &p)),
+            LinkType::RustdocInclude(p, _) => Some(return_relative_path(base, &p)),
         }
     }
 }
@@ -142,50 +195,59 @@ fn return_relative_path<P: AsRef<Path>>(base: P, relative: P) -> PathBuf {
         .to_path_buf()
 }
 
-fn parse_include_path(path: &str) -> LinkType<'static> {
-    let mut parts = path.split(':');
-    let path = parts.next().unwrap().into();
-    // subtract 1 since line numbers usually begin with 1
-    let start = parts
-        .next()
-        .and_then(|s| s.parse::<usize>().ok())
-        .map(|val| val.saturating_sub(1));
+fn parse_range_or_anchor(parts: Option<&str>) -> RangeOrAnchor {
+    let mut parts = parts.unwrap_or("").splitn(3, ':').fuse();
+
+    let next_element = parts.next();
+    let start = if let Some(value) = next_element.and_then(|s| s.parse::<usize>().ok()) {
+        // subtract 1 since line numbers usually begin with 1
+        Some(value.saturating_sub(1))
+    } else if let Some("") = next_element {
+        None
+    } else if let Some(anchor) = next_element {
+        return RangeOrAnchor::Anchor(String::from(anchor));
+    } else {
+        None
+    };
+
     let end = parts.next();
-    let has_end = end.is_some();
-    let end = end.and_then(|s| s.parse::<usize>().ok());
-    match start {
-        Some(start) => match end {
-            Some(end) => LinkType::IncludeRange(
-                path,
-                Range {
-                    start: start,
-                    end: end,
-                },
-            ),
-            None => if has_end {
-                LinkType::IncludeRangeFrom(path, RangeFrom { start: start })
-            } else {
-                LinkType::IncludeRange(
-                    path,
-                    Range {
-                        start: start,
-                        end: start + 1,
-                    },
-                )
-            },
-        },
-        None => match end {
-            Some(end) => LinkType::IncludeRangeTo(path, RangeTo { end: end }),
-            None => LinkType::IncludeRangeFull(path, RangeFull),
-        },
+    // If `end` is empty string or any other value that can't be parsed as a usize, treat this
+    // include as a range with only a start bound. However, if end isn't specified, include only
+    // the single line specified by `start`.
+    let end = end.map(|s| s.parse::<usize>());
+
+    match (start, end) {
+        (Some(start), Some(Ok(end))) => RangeOrAnchor::Range(LineRange::from(start..end)),
+        (Some(start), Some(Err(_))) => RangeOrAnchor::Range(LineRange::from(start..)),
+        (Some(start), None) => RangeOrAnchor::Range(LineRange::from(start..start + 1)),
+        (None, Some(Ok(end))) => RangeOrAnchor::Range(LineRange::from(..end)),
+        (None, None) | (None, Some(Err(_))) => RangeOrAnchor::Range(LineRange::from(RangeFull)),
     }
 }
 
+fn parse_include_path(path: &str) -> LinkType<'static> {
+    let mut parts = path.splitn(2, ':');
+
+    let path = parts.next().unwrap().into();
+    let range_or_anchor = parse_range_or_anchor(parts.next());
+
+    LinkType::Include(path, range_or_anchor)
+}
+
+fn parse_rustdoc_include_path(path: &str) -> LinkType<'static> {
+    let mut parts = path.splitn(2, ':');
+
+    let path = parts.next().unwrap().into();
+    let range_or_anchor = parse_range_or_anchor(parts.next());
+
+    LinkType::RustdocInclude(path, range_or_anchor)
+}
+
 #[derive(PartialEq, Debug, Clone)]
 struct Link<'a> {
     start_index: usize,
     end_index: usize,
-    link: LinkType<'a>,
+    link_type: LinkType<'a>,
     link_text: &'a str,
 }
 
@@ -199,25 +261,22 @@ impl<'a> Link<'a> {
 
                 match (typ.as_str(), file_arg) {
                     ("include", Some(pth)) => Some(parse_include_path(pth)),
-                    ("playpen", Some(pth)) => {
-                        Some(LinkType::Playpen(pth.into(), props))
-                    }
+                    ("playpen", Some(pth)) => Some(LinkType::Playpen(pth.into(), props)),
+                    ("rustdoc_include", Some(pth)) => Some(parse_rustdoc_include_path(pth)),
                     _ => None,
                 }
             }
-            (Some(mat), None, None)
-                if mat.as_str().starts_with(ESCAPE_CHAR) =>
-            {
+            (Some(mat), None, None) if mat.as_str().starts_with(ESCAPE_CHAR) => {
                 Some(LinkType::Escaped)
             }
             _ => None,
         };
 
-        link_type.and_then(|lnk| {
+        link_type.and_then(|lnk_type| {
             cap.get(0).map(|mat| Link {
                 start_index: mat.start(),
                 end_index: mat.end(),
-                link: lnk,
+                link_type: lnk_type,
                 link_text: mat.as_str(),
             })
         })
@@ -225,14 +284,17 @@ impl<'a> Link<'a> {
 
     fn render_with_path<P: AsRef<Path>>(&self, base: P) -> Result<String> {
         let base = base.as_ref();
-        match self.link {
+        match self.link_type {
             // omit the escape char
             LinkType::Escaped => Ok((&self.link_text[1..]).to_owned()),
-            LinkType::IncludeRange(ref pat, ref range) => {
+            LinkType::Include(ref pat, ref range_or_anchor) => {
                 let target = base.join(pat);
 
-                file_to_string(&target)
-                    .map(|s| take_lines(&s, range.clone()))
+                fs::read_to_string(&target)
+                    .map(|s| match range_or_anchor {
+                        RangeOrAnchor::Range(range) => take_lines(&s, range.clone()),
+                        RangeOrAnchor::Anchor(anchor) => take_anchored_lines(&s, anchor),
+                    })
                     .chain_err(|| {
                         format!(
                             "Could not read file for link {} ({})",
@@ -241,11 +303,18 @@ impl<'a> Link<'a> {
                         )
                     })
             }
-            LinkType::IncludeRangeFrom(ref pat, ref range) => {
+            LinkType::RustdocInclude(ref pat, ref range_or_anchor) => {
                 let target = base.join(pat);
 
-                file_to_string(&target)
-                    .map(|s| take_lines(&s, range.clone()))
+                fs::read_to_string(&target)
+                    .map(|s| match range_or_anchor {
+                        RangeOrAnchor::Range(range) => {
+                            take_rustdoc_include_lines(&s, range.clone())
+                        }
+                        RangeOrAnchor::Anchor(anchor) => {
+                            take_rustdoc_include_anchored_lines(&s, anchor)
+                        }
+                    })
                     .chain_err(|| {
                         format!(
                             "Could not read file for link {} ({})",
@@ -254,39 +323,16 @@ impl<'a> Link<'a> {
                         )
                     })
             }
-            LinkType::IncludeRangeTo(ref pat, ref range) => {
-                let target = base.join(pat);
-
-                file_to_string(&target)
-                    .map(|s| take_lines(&s, range.clone()))
-                    .chain_err(|| {
-                        format!(
-                            "Could not read file for link {} ({})",
-                            self.link_text,
-                            target.display(),
-                        )
-                    })
-            }
-            LinkType::IncludeRangeFull(ref pat, _) => {
-                let target = base.join(pat);
-
-                file_to_string(&target).chain_err(|| {
-                    format!("Could not read file for link {} ({})",
-                            self.link_text,
-                            target.display())
-                })
-            }
             LinkType::Playpen(ref pat, ref attrs) => {
                 let target = base.join(pat);
 
-                let contents =
-                file_to_string(&target).chain_err(|| {
-                        format!(
-                            "Could not read file for link {} ({})",
-                            self.link_text,
-                            target.display()
-                        )
-                    })?;
+                let contents = fs::read_to_string(&target).chain_err(|| {
+                    format!(
+                        "Could not read file for link {} ({})",
+                        self.link_text,
+                        target.display()
+                    )
+                })?;
                 let ftype = if !attrs.is_empty() { "rust," } else { "rust" };
                 Ok(format!(
                     "```{}{}\n{}\n```\n",
@@ -313,7 +359,7 @@ impl<'a> Iterator for LinkIter<'a> {
     }
 }
 
-fn find_links(contents: &str) -> LinkIter {
+fn find_links(contents: &str) -> LinkIter<'_> {
     // lazily compute following regex
     // r"\\\{\{#.*\}\}|\{\{#([a-zA-Z0-9]+)\s*([a-zA-Z0-9_.\-:/\\\s]+)\}\}")?;
     lazy_static! {
@@ -322,11 +368,12 @@ fn find_links(contents: &str) -> LinkIter {
             \\\{\{\#.*\}\}             # match escaped link
             |                          # or
             \{\{\s*                    # link opening parens and whitespace
-            \#([a-zA-Z0-9]+)           # link type
+            \#([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"
-        ).unwrap();
+        )
+        .unwrap();
     }
     LinkIter(RE.captures_iter(contents))
 }
@@ -391,13 +438,13 @@ mod tests {
                 Link {
                     start_index: 22,
                     end_index: 42,
-                    link: LinkType::Playpen(PathBuf::from("file.rs"), vec![]),
+                    link_type: LinkType::Playpen(PathBuf::from("file.rs"), vec![]),
                     link_text: "{{#playpen file.rs}}",
                 },
                 Link {
                     start_index: 47,
                     end_index: 68,
-                    link: LinkType::Playpen(PathBuf::from("test.rs"), vec![]),
+                    link_type: LinkType::Playpen(PathBuf::from("test.rs"), vec![]),
                     link_text: "{{#playpen test.rs }}",
                 },
             ]
@@ -414,7 +461,10 @@ mod tests {
             vec![Link {
                 start_index: 22,
                 end_index: 48,
-                link: LinkType::IncludeRange(PathBuf::from("file.rs"), 9..20),
+                link_type: LinkType::Include(
+                    PathBuf::from("file.rs"),
+                    RangeOrAnchor::Range(LineRange::from(9..20))
+                ),
                 link_text: "{{#include file.rs:10:20}}",
             }]
         );
@@ -430,7 +480,10 @@ mod tests {
             vec![Link {
                 start_index: 22,
                 end_index: 45,
-                link: LinkType::IncludeRange(PathBuf::from("file.rs"), 9..10),
+                link_type: LinkType::Include(
+                    PathBuf::from("file.rs"),
+                    RangeOrAnchor::Range(LineRange::from(9..10))
+                ),
                 link_text: "{{#include file.rs:10}}",
             }]
         );
@@ -446,7 +499,10 @@ mod tests {
             vec![Link {
                 start_index: 22,
                 end_index: 46,
-                link: LinkType::IncludeRangeFrom(PathBuf::from("file.rs"), 9..),
+                link_type: LinkType::Include(
+                    PathBuf::from("file.rs"),
+                    RangeOrAnchor::Range(LineRange::from(9..))
+                ),
                 link_text: "{{#include file.rs:10:}}",
             }]
         );
@@ -462,7 +518,10 @@ mod tests {
             vec![Link {
                 start_index: 22,
                 end_index: 46,
-                link: LinkType::IncludeRangeTo(PathBuf::from("file.rs"), ..20),
+                link_type: LinkType::Include(
+                    PathBuf::from("file.rs"),
+                    RangeOrAnchor::Range(LineRange::from(..20))
+                ),
                 link_text: "{{#include file.rs::20}}",
             }]
         );
@@ -478,7 +537,10 @@ mod tests {
             vec![Link {
                 start_index: 22,
                 end_index: 44,
-                link: LinkType::IncludeRangeFull(PathBuf::from("file.rs"), ..),
+                link_type: LinkType::Include(
+                    PathBuf::from("file.rs"),
+                    RangeOrAnchor::Range(LineRange::from(..))
+                ),
                 link_text: "{{#include file.rs::}}",
             }]
         );
@@ -494,12 +556,34 @@ mod tests {
             vec![Link {
                 start_index: 22,
                 end_index: 42,
-                link: LinkType::IncludeRangeFull(PathBuf::from("file.rs"), ..),
+                link_type: LinkType::Include(
+                    PathBuf::from("file.rs"),
+                    RangeOrAnchor::Range(LineRange::from(..))
+                ),
                 link_text: "{{#include file.rs}}",
             }]
         );
     }
 
+    #[test]
+    fn test_find_links_with_anchor() {
+        let s = "Some random text with {{#include file.rs:anchor}}...";
+        let res = find_links(s).collect::<Vec<_>>();
+        println!("\nOUTPUT: {:?}\n", res);
+        assert_eq!(
+            res,
+            vec![Link {
+                start_index: 22,
+                end_index: 49,
+                link_type: LinkType::Include(
+                    PathBuf::from("file.rs"),
+                    RangeOrAnchor::Anchor(String::from("anchor"))
+                ),
+                link_text: "{{#include file.rs:anchor}}",
+            }]
+        );
+    }
+
     #[test]
     fn test_find_links_escaped_link() {
         let s = "Some random text with escaped playpen \\{{#playpen file.rs editable}} ...";
@@ -512,7 +596,7 @@ mod tests {
             vec![Link {
                 start_index: 38,
                 end_index: 68,
-                link: LinkType::Escaped,
+                link_type: LinkType::Escaped,
                 link_text: "\\{{#playpen file.rs editable}}",
             }]
         );
@@ -531,21 +615,17 @@ mod tests {
                 Link {
                     start_index: 38,
                     end_index: 68,
-                    link: LinkType::Playpen(
-                        PathBuf::from("file.rs"),
-                        vec!["editable"]
-                    ),
+                    link_type: LinkType::Playpen(PathBuf::from("file.rs"), vec!["editable"]),
                     link_text: "{{#playpen file.rs editable }}",
                 },
                 Link {
                     start_index: 89,
                     end_index: 136,
-                    link: LinkType::Playpen(
+                    link_type: LinkType::Playpen(
                         PathBuf::from("my.rs"),
                         vec!["editable", "no_run", "should_panic"],
                     ),
-                    link_text:
-                        "{{#playpen my.rs editable no_run should_panic}}",
+                    link_text: "{{#playpen my.rs editable no_run should_panic}}",
                 },
             ]
         );
@@ -565,7 +645,10 @@ mod tests {
             Link {
                 start_index: 38,
                 end_index: 58,
-                link: LinkType::IncludeRangeFull(PathBuf::from("file.rs"), ..),
+                link_type: LinkType::Include(
+                    PathBuf::from("file.rs"),
+                    RangeOrAnchor::Range(LineRange::from(..))
+                ),
                 link_text: "{{#include file.rs}}",
             }
         );
@@ -574,7 +657,7 @@ mod tests {
             Link {
                 start_index: 63,
                 end_index: 112,
-                link: LinkType::Escaped,
+                link_type: LinkType::Escaped,
                 link_text: "\\{{#contents are insignifficant in escaped link}}",
             }
         );
@@ -583,7 +666,7 @@ mod tests {
             Link {
                 start_index: 130,
                 end_index: 177,
-                link: LinkType::Playpen(
+                link_type: LinkType::Playpen(
                     PathBuf::from("my.rs"),
                     vec!["editable", "no_run", "should_panic"]
                 ),
@@ -592,4 +675,183 @@ mod tests {
         );
     }
 
+    #[test]
+    fn parse_without_colon_includes_all() {
+        let link_type = parse_include_path("arbitrary");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(RangeFull))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_nothing_after_colon_includes_all() {
+        let link_type = parse_include_path("arbitrary:");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(RangeFull))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_two_colons_includes_all() {
+        let link_type = parse_include_path("arbitrary::");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(RangeFull))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_garbage_after_two_colons_includes_all() {
+        let link_type = parse_include_path("arbitrary::NaN");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(RangeFull))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_one_number_after_colon_only_that_line() {
+        let link_type = parse_include_path("arbitrary:5");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(4..5))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_one_based_start_becomes_zero_based() {
+        let link_type = parse_include_path("arbitrary:1");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(0..1))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_zero_based_start_stays_zero_based_but_is_probably_an_error() {
+        let link_type = parse_include_path("arbitrary:0");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(0..1))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_start_only_range() {
+        let link_type = parse_include_path("arbitrary:5:");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(4..))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_start_with_garbage_interpreted_as_start_only_range() {
+        let link_type = parse_include_path("arbitrary:5:NaN");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(4..))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_end_only_range() {
+        let link_type = parse_include_path("arbitrary::5");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(..5))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_start_and_end_range() {
+        let link_type = parse_include_path("arbitrary:5:10");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(4..10))
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_negative_interpreted_as_anchor() {
+        let link_type = parse_include_path("arbitrary:-5");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Anchor("-5".to_string())
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_floating_point_interpreted_as_anchor() {
+        let link_type = parse_include_path("arbitrary:-5.7");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Anchor("-5.7".to_string())
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_anchor_followed_by_colon() {
+        let link_type = parse_include_path("arbitrary:some-anchor:this-gets-ignored");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Anchor("some-anchor".to_string())
+            )
+        );
+    }
+
+    #[test]
+    fn parse_with_more_than_three_colons_ignores_everything_after_third_colon() {
+        let link_type = parse_include_path("arbitrary:5:10:17:anything:");
+        assert_eq!(
+            link_type,
+            LinkType::Include(
+                PathBuf::from("arbitrary"),
+                RangeOrAnchor::Range(LineRange::from(4..10))
+            )
+        );
+    }
 }

src/preprocess/mod.rs

@@ -1,16 +1,16 @@
 //! Book preprocessing.
 
+pub use self::cmd::CmdPreprocessor;
 pub use self::index::IndexPreprocessor;
 pub use self::links::LinkPreprocessor;
-pub use self::cmd::CmdPreprocessor;
 
+mod cmd;
 mod index;
 mod links;
-mod cmd;
 
-use book::Book;
-use config::Config;
-use errors::*;
+use crate::book::Book;
+use crate::config::Config;
+use crate::errors::*;
 
 use std::path::PathBuf;
 
@@ -26,6 +26,7 @@ pub struct PreprocessorContext {
     pub renderer: String,
     /// The calling `mdbook` version.
     pub mdbook_version: String,
+    #[serde(skip)]
     __non_exhaustive: (),
 }
 
@@ -36,7 +37,7 @@ impl PreprocessorContext {
             root,
             config,
             renderer,
-            mdbook_version: ::MDBOOK_VERSION.to_string(),
+            mdbook_version: crate::MDBOOK_VERSION.to_string(),
             __non_exhaustive: (),
         }
     }

src/renderer/html_handlebars/hbs_renderer.rs

@@ -1,11 +1,12 @@
-use book::{Book, BookItem};
-use config::{Config, HtmlConfig, Playpen};
-use errors::*;
-use renderer::html_handlebars::helpers;
-use renderer::{RenderContext, Renderer};
-use theme::{self, playpen_editor, Theme};
-use utils;
+use crate::book::{Book, BookItem};
+use crate::config::{Config, HtmlConfig, Playpen};
+use crate::errors::*;
+use crate::renderer::html_handlebars::helpers;
+use crate::renderer::{RenderContext, Renderer};
+use crate::theme::{self, playpen_editor, Theme};
+use crate::utils;
 
+use std::borrow::Cow;
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::fs;
@@ -13,7 +14,6 @@ use std::path::{Path, PathBuf};
 
 use handlebars::Handlebars;
 use regex::{Captures, Regex};
-use serde_json;
 
 #[derive(Default)]
 pub struct HtmlHandlebars;
@@ -26,79 +26,82 @@ impl HtmlHandlebars {
     fn render_item(
         &self,
         item: &BookItem,
-        mut ctx: RenderItemContext,
+        mut ctx: RenderItemContext<'_>,
         print_content: &mut String,
     ) -> Result<()> {
         // FIXME: This should be made DRY-er and rely less on mutable state
-        match *item {
-            BookItem::Chapter(ref ch) => {
-                let content = ch.content.clone();
-                let content = utils::render_markdown(&content, ctx.html_config.curly_quotes);
-                print_content.push_str(&content);
+        if let BookItem::Chapter(ref ch) = *item {
+            let content = ch.content.clone();
+            let content = utils::render_markdown(&content, ctx.html_config.curly_quotes);
 
-                // Update the context with data for this file
-                let path = ch
-                    .path
-                    .to_str()
-                    .chain_err(|| "Could not convert path to str")?;
-                let filepath = Path::new(&ch.path).with_extension("html");
+            let fixed_content = utils::render_markdown_with_path(
+                &ch.content,
+                ctx.html_config.curly_quotes,
+                Some(&ch.path),
+            );
+            print_content.push_str(&fixed_content);
 
-                // "print.html" is used for the print page.
-                if ch.path == Path::new("print.md") {
-                    bail!(ErrorKind::ReservedFilenameError(ch.path.clone()));
-                };
+            // Update the context with data for this file
+            let path = ch
+                .path
+                .to_str()
+                .chain_err(|| "Could not convert path to str")?;
+            let filepath = Path::new(&ch.path).with_extension("html");
 
-                // Non-lexical lifetimes needed :'(
-                let title: String;
-                {
-                    let book_title = ctx
-                        .data
-                        .get("book_title")
-                        .and_then(serde_json::Value::as_str)
-                        .unwrap_or("");
-                    title = ch.name.clone() + " - " + book_title;
-                }
+            // "print.html" is used for the print page.
+            if ch.path == Path::new("print.md") {
+                bail!(ErrorKind::ReservedFilenameError(ch.path.clone()));
+            };
 
-                ctx.data.insert("path".to_owned(), json!(path));
-                ctx.data.insert("content".to_owned(), json!(content));
-                ctx.data.insert("chapter_title".to_owned(), json!(ch.name));
-                ctx.data.insert("title".to_owned(), json!(title));
-                ctx.data.insert(
-                    "path_to_root".to_owned(),
-                    json!(utils::fs::path_to_root(&ch.path)),
-                );
-
-                // Render the handlebars template with the data
-                debug!("Render template");
-                let rendered = ctx.handlebars.render("index", &ctx.data)?;
-
-                let rendered = self.post_process(rendered, &ctx.html_config.playpen);
-
-                // Write to file
-                debug!("Creating {}", filepath.display());
-                utils::fs::write_file(&ctx.destination, &filepath, rendered.as_bytes())?;
-
-                if ctx.is_index {
-                    ctx.data.insert("path".to_owned(), json!("index.html"));
-                    ctx.data.insert("path_to_root".to_owned(), json!(""));
-                    let rendered_index = ctx.handlebars.render("index", &ctx.data)?;
-                    let rendered_index =
-                        self.post_process(rendered_index, &ctx.html_config.playpen);
-                    debug!("Creating index.html from {}", path);
-                    utils::fs::write_file(
-                        &ctx.destination,
-                        "index.html",
-                        rendered_index.as_bytes(),
-                    )?;
-                }
+            // Non-lexical lifetimes needed :'(
+            let title: String;
+            {
+                let book_title = ctx
+                    .data
+                    .get("book_title")
+                    .and_then(serde_json::Value::as_str)
+                    .unwrap_or("");
+                title = ch.name.clone() + " - " + book_title;
+            }
+
+            ctx.data.insert("path".to_owned(), json!(path));
+            ctx.data.insert("content".to_owned(), json!(content));
+            ctx.data.insert("chapter_title".to_owned(), json!(ch.name));
+            ctx.data.insert("title".to_owned(), json!(title));
+            ctx.data.insert(
+                "path_to_root".to_owned(),
+                json!(utils::fs::path_to_root(&ch.path)),
+            );
+            if let Some(ref section) = ch.number {
+                ctx.data
+                    .insert("section".to_owned(), json!(section.to_string()));
+            }
+
+            // Render the handlebars template with the data
+            debug!("Render template");
+            let rendered = ctx.handlebars.render("index", &ctx.data)?;
+
+            let rendered = self.post_process(rendered, &ctx.html_config.playpen);
+
+            // Write to file
+            debug!("Creating {}", filepath.display());
+            utils::fs::write_file(&ctx.destination, &filepath, rendered.as_bytes())?;
+
+            if ctx.is_index {
+                ctx.data.insert("path".to_owned(), json!("index.md"));
+                ctx.data.insert("path_to_root".to_owned(), json!(""));
+                ctx.data.insert("is_index".to_owned(), json!("true"));
+                let rendered_index = ctx.handlebars.render("index", &ctx.data)?;
+                let rendered_index = self.post_process(rendered_index, &ctx.html_config.playpen);
+                debug!("Creating index.html from {}", path);
+                utils::fs::write_file(&ctx.destination, "index.html", rendered_index.as_bytes())?;
             }
-            _ => {}
         }
 
         Ok(())
     }
 
-    #[cfg_attr(feature = "cargo-clippy", allow(let_and_return))]
+    #[cfg_attr(feature = "cargo-clippy", allow(clippy::let_and_return))]
     fn post_process(&self, rendered: String, playpen_config: &Playpen) -> String {
         let rendered = build_header_links(&rendered);
         let rendered = fix_code_blocks(&rendered);
@@ -113,7 +116,7 @@ impl HtmlHandlebars {
         theme: &Theme,
         html_config: &HtmlConfig,
     ) -> Result<()> {
-        use utils::fs::write_file;
+        use crate::utils::fs::write_file;
 
         write_file(
             destination,
@@ -214,6 +217,7 @@ impl HtmlHandlebars {
         );
         handlebars.register_helper("previous", Box::new(helpers::navigation::previous));
         handlebars.register_helper("next", Box::new(helpers::navigation::next));
+        handlebars.register_helper("theme_option", Box::new(helpers::theme::theme_option));
     }
 
     /// Copy across any additional CSS and JavaScript files which the book
@@ -284,6 +288,11 @@ impl Renderer for HtmlHandlebars {
         let destination = &ctx.destination;
         let book = &ctx.book;
 
+        if destination.exists() {
+            utils::fs::remove_dir_content(destination)
+                .chain_err(|| "Unable to remove stale HTML output")?;
+        }
+
         trace!("render");
         let mut handlebars = Handlebars::new();
 
@@ -327,7 +336,7 @@ impl Renderer for HtmlHandlebars {
                 handlebars: &handlebars,
                 destination: destination.to_path_buf(),
                 data: data.clone(),
-                is_index: is_index,
+                is_index,
                 html_config: html_config.clone(),
             };
             self.render_item(item, ctx, &mut print_content)?;
@@ -378,10 +387,12 @@ fn make_data(
     html_config: &HtmlConfig,
 ) -> Result<serde_json::Map<String, serde_json::Value>> {
     trace!("make_data");
-    let html = config.html_config().unwrap_or_default();
 
     let mut data = serde_json::Map::new();
-    data.insert("language".to_owned(), json!("en"));
+    data.insert(
+        "language".to_owned(),
+        json!(config.book.language.clone().unwrap_or_default()),
+    );
     data.insert(
         "book_title".to_owned(),
         json!(config.book.title.clone().unwrap_or_default()),
@@ -395,19 +406,34 @@ fn make_data(
         data.insert("livereload".to_owned(), json!(livereload));
     }
 
+    let default_theme = match html_config.default_theme {
+        Some(ref theme) => theme.to_lowercase(),
+        None => "light".to_string(),
+    };
+    data.insert("default_theme".to_owned(), json!(default_theme));
+
+    let preferred_dark_theme = match html_config.preferred_dark_theme {
+        Some(ref theme) => theme.to_lowercase(),
+        None => default_theme,
+    };
+    data.insert(
+        "preferred_dark_theme".to_owned(),
+        json!(preferred_dark_theme),
+    );
+
     // Add google analytics tag
-    if let Some(ref ga) = config.html_config().and_then(|html| html.google_analytics) {
+    if let Some(ref ga) = html_config.google_analytics {
         data.insert("google_analytics".to_owned(), json!(ga));
     }
 
-    if html.mathjax_support {
+    if html_config.mathjax_support {
         data.insert("mathjax_support".to_owned(), json!(true));
     }
 
     // Add check to see if there is an additional style
-    if !html.additional_css.is_empty() {
+    if !html_config.additional_css.is_empty() {
         let mut css = Vec::new();
-        for style in &html.additional_css {
+        for style in &html_config.additional_css {
             match style.strip_prefix(root) {
                 Ok(p) => css.push(p.to_str().expect("Could not convert to str")),
                 Err(_) => css.push(style.to_str().expect("Could not convert to str")),
@@ -417,26 +443,29 @@ fn make_data(
     }
 
     // Add check to see if there is an additional script
-    if !html.additional_js.is_empty() {
+    if !html_config.additional_js.is_empty() {
         let mut js = Vec::new();
-        for script in &html.additional_js {
+        for script in &html_config.additional_js {
             match script.strip_prefix(root) {
                 Ok(p) => js.push(p.to_str().expect("Could not convert to str")),
-                Err(_) => js.push(
-                    script
-                        .file_name()
-                        .expect("File has a file name")
-                        .to_str()
-                        .expect("Could not convert to str"),
-                ),
+                Err(_) => js.push(script.to_str().expect("Could not convert to str")),
             }
         }
         data.insert("additional_js".to_owned(), json!(js));
     }
 
-    if html.playpen.editable && html.playpen.copy_js {
+    if html_config.playpen.editable && html_config.playpen.copy_js {
         data.insert("playpen_js".to_owned(), json!(true));
+        if html_config.playpen.line_numbers {
+            data.insert("playpen_line_numbers".to_owned(), json!(true));
+        }
     }
+    if html_config.playpen.copyable {
+        data.insert("playpen_copyable".to_owned(), json!(true));
+    }
+
+    data.insert("fold_enable".to_owned(), json!((html_config.fold.enable)));
+    data.insert("fold_level".to_owned(), json!((html_config.fold.level)));
 
     let search = html_config.search.clone();
     if cfg!(feature = "search") {
@@ -454,6 +483,16 @@ fn make_data(
         )
     }
 
+    if let Some(ref git_repository_url) = html_config.git_repository_url {
+        data.insert("git_repository_url".to_owned(), json!(git_repository_url));
+    }
+
+    let git_repository_icon = match html_config.git_repository_icon {
+        Some(ref git_repository_icon) => git_repository_icon,
+        None => "fa-github",
+    };
+    data.insert("git_repository_icon".to_owned(), json!(git_repository_icon));
+
     let mut chapters = vec![];
 
     for item in book.iter() {
@@ -466,6 +505,11 @@ fn make_data(
                     chapter.insert("section".to_owned(), json!(section.to_string()));
                 }
 
+                chapter.insert(
+                    "has_sub_items".to_owned(),
+                    json!((!ch.sub_items.is_empty()).to_string()),
+                );
+
                 chapter.insert("name".to_owned(), json!(ch.name));
                 let path = ch
                     .path
@@ -487,25 +531,26 @@ fn make_data(
     Ok(data)
 }
 
-/// Goes through the rendered HTML, making sure all header tags are wrapped in
-/// an anchor so people can link to sections directly.
+/// Goes through the rendered HTML, making sure all header tags have
+/// an anchor respectively so people can link to sections directly.
 fn build_header_links(html: &str) -> String {
     let regex = Regex::new(r"<h(\d)>(.*?)</h\d>").unwrap();
     let mut id_counter = HashMap::new();
 
     regex
-        .replace_all(html, |caps: &Captures| {
+        .replace_all(html, |caps: &Captures<'_>| {
             let level = caps[1]
                 .parse()
                 .expect("Regex should ensure we only ever get numbers here");
 
-            wrap_header_with_link(level, &caps[2], &mut id_counter)
-        }).into_owned()
+            insert_link_into_header(level, &caps[2], &mut id_counter)
+        })
+        .into_owned()
 }
 
-/// Wraps a single header tag with a link, making sure each tag gets its own
+/// Insert a sinle link into a header, making sure each link gets its own
 /// unique ID by appending an auto-incremented number (if necessary).
-fn wrap_header_with_link(
+fn insert_link_into_header(
     level: usize,
     content: &str,
     id_counter: &mut HashMap<String, usize>,
@@ -522,7 +567,7 @@ fn wrap_header_with_link(
     *id_count += 1;
 
     format!(
-        r##"<a class="header" href="#{id}" id="{id}"><h{level}>{text}</h{level}></a>"##,
+        r##"<h{level}><a class="header" href="#{id}" id="{id}">{text}</a></h{level}>"##,
         level = level,
         id = id,
         text = content
@@ -540,7 +585,7 @@ fn wrap_header_with_link(
 fn fix_code_blocks(html: &str) -> String {
     let regex = Regex::new(r##"<code([^>]+)class="([^"]+)"([^>]*)>"##).unwrap();
     regex
-        .replace_all(html, |caps: &Captures| {
+        .replace_all(html, |caps: &Captures<'_>| {
             let before = &caps[1];
             let classes = &caps[2].replace(",", " ");
             let after = &caps[3];
@@ -551,43 +596,87 @@ fn fix_code_blocks(html: &str) -> String {
                 classes = classes,
                 after = after
             )
-        }).into_owned()
+        })
+        .into_owned()
 }
 
 fn add_playpen_pre(html: &str, playpen_config: &Playpen) -> String {
     let regex = Regex::new(r##"((?s)<code[^>]?class="([^"]+)".*?>(.*?)</code>)"##).unwrap();
     regex
-        .replace_all(html, |caps: &Captures| {
+        .replace_all(html, |caps: &Captures<'_>| {
             let text = &caps[1];
             let classes = &caps[2];
             let code = &caps[3];
 
-            if (classes.contains("language-rust")
-                && !classes.contains("ignore")
-                && !classes.contains("noplaypen"))
-                || classes.contains("mdbook-runnable")
-            {
-                // wrap the contents in an external pre block
-                if playpen_config.editable && classes.contains("editable")
-                    || text.contains("fn main")
-                    || text.contains("quick_main!")
+            if classes.contains("language-rust") {
+                if (!classes.contains("ignore") && !classes.contains("noplaypen"))
+                    || classes.contains("mdbook-runnable")
                 {
-                    format!("<pre class=\"playpen\">{}</pre>", text)
-                } else {
-                    // we need to inject our own main
-                    let (attrs, code) = partition_source(code);
-
+                    // wrap the contents in an external pre block
                     format!(
-                        "<pre class=\"playpen\"><code class=\"{}\">\n# \
-                         #![allow(unused_variables)]\n{}#fn main() {{\n{}#}}</code></pre>",
-                        classes, attrs, code
+                        "<pre class=\"playpen\"><code class=\"{}\">{}</code></pre>",
+                        classes,
+                        {
+                            let content: Cow<'_, str> = if playpen_config.editable
+                                && classes.contains("editable")
+                                || text.contains("fn main")
+                                || text.contains("quick_main!")
+                            {
+                                code.into()
+                            } else {
+                                // we need to inject our own main
+                                let (attrs, code) = partition_source(code);
+
+                                format!(
+                                    "\n# #![allow(unused_variables)]\n{}#fn main() {{\n{}#}}",
+                                    attrs, code
+                                )
+                                .into()
+                            };
+                            hide_lines(&content)
+                        }
                     )
+                } else {
+                    format!("<code class=\"{}\">{}</code>", classes, hide_lines(code))
                 }
             } else {
                 // not language-rust, so no-op
                 text.to_owned()
             }
-        }).into_owned()
+        })
+        .into_owned()
+}
+
+lazy_static! {
+    static ref BORING_LINES_REGEX: Regex = Regex::new(r"^(\s*)#(.?)(.*)$").unwrap();
+}
+
+fn hide_lines(content: &str) -> String {
+    let mut result = String::with_capacity(content.len());
+    for line in content.lines() {
+        if let Some(caps) = BORING_LINES_REGEX.captures(line) {
+            if &caps[2] == "#" {
+                result += &caps[1];
+                result += &caps[2];
+                result += &caps[3];
+                result += "\n";
+                continue;
+            } else if &caps[2] != "!" && &caps[2] != "[" {
+                result += "<span class=\"boring\">";
+                result += &caps[1];
+                if &caps[2] != " " {
+                    result += &caps[2];
+                }
+                result += &caps[3];
+                result += "\n";
+                result += "</span>";
+                continue;
+            }
+        }
+        result += line;
+        result += "\n";
+    }
+    result
 }
 
 fn partition_source(s: &str) -> (String, String) {
@@ -597,7 +686,7 @@ fn partition_source(s: &str) -> (String, String) {
 
     for line in s.lines() {
         let trimline = line.trim();
-        let header = trimline.chars().all(|c| c.is_whitespace()) || trimline.starts_with("#![");
+        let header = trimline.chars().all(char::is_whitespace) || trimline.starts_with("#![");
         if !header || after_header {
             after_header = true;
             after.push_str(line);
@@ -628,27 +717,27 @@ mod tests {
         let inputs = vec![
             (
                 "blah blah <h1>Foo</h1>",
-                r##"blah blah <a class="header" href="#foo" id="foo"><h1>Foo</h1></a>"##,
+                r##"blah blah <h1><a class="header" href="#foo" id="foo">Foo</a></h1>"##,
             ),
             (
                 "<h1>Foo</h1>",
-                r##"<a class="header" href="#foo" id="foo"><h1>Foo</h1></a>"##,
+                r##"<h1><a class="header" href="#foo" id="foo">Foo</a></h1>"##,
             ),
             (
                 "<h3>Foo^bar</h3>",
-                r##"<a class="header" href="#foobar" id="foobar"><h3>Foo^bar</h3></a>"##,
+                r##"<h3><a class="header" href="#foobar" id="foobar">Foo^bar</a></h3>"##,
             ),
             (
                 "<h4></h4>",
-                r##"<a class="header" href="#" id=""><h4></h4></a>"##,
+                r##"<h4><a class="header" href="#" id=""></a></h4>"##,
             ),
             (
                 "<h4><em>Hï</em></h4>",
-                r##"<a class="header" href="#hï" id="hï"><h4><em>Hï</em></h4></a>"##,
+                r##"<h4><a class="header" href="#hï" id="hï"><em>Hï</em></a></h4>"##,
             ),
             (
                 "<h1>Foo</h1><h3>Foo</h3>",
-                r##"<a class="header" href="#foo" id="foo"><h1>Foo</h1></a><a class="header" href="#foo-1" id="foo-1"><h3>Foo</h3></a>"##,
+                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>"##,
             ),
         ];
 
@@ -657,4 +746,34 @@ mod tests {
             assert_eq!(got, should_be);
         }
     }
+
+    #[test]
+    fn add_playpen() {
+        let inputs = [
+          ("<code class=\"language-rust\">x()</code>",
+           "<pre class=\"playpen\"><code class=\"language-rust\">\n<span class=\"boring\">#![allow(unused_variables)]\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=\"playpen\"><code class=\"language-rust\">fn main() {}\n</code></pre>"),
+          ("<code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code>",
+           "<pre class=\"playpen\"><code class=\"language-rust editable\">let s = \"foo\n<span class=\"boring\"> bar\n</span>\";\n</code></pre>"),
+          ("<code class=\"language-rust editable\">let s = \"foo\n ## bar\n\";</code>",
+           "<pre class=\"playpen\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n\";\n</code></pre>"),
+          ("<code class=\"language-rust editable\">let s = \"foo\n # bar\n#\n\";</code>",
+           "<pre class=\"playpen\"><code class=\"language-rust editable\">let s = \"foo\n<span class=\"boring\"> bar\n</span><span class=\"boring\">\n</span>\";\n</code></pre>"),
+          ("<code class=\"language-rust ignore\">let s = \"foo\n # bar\n\";</code>",
+           "<code class=\"language-rust ignore\">let s = \"foo\n<span class=\"boring\"> bar\n</span>\";\n</code>"),
+          ("<code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code>",
+           "<pre class=\"playpen\"><code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]\n</code></pre>"),
+        ];
+        for (src, should_be) in &inputs {
+            let got = add_playpen_pre(
+                src,
+                &Playpen {
+                    editable: true,
+                    ..Playpen::default()
+                },
+            );
+            assert_eq!(&*got, *should_be);
+        }
+    }
 }

src/renderer/html_handlebars/helpers/mod.rs

@@ -1,2 +1,3 @@
 pub mod navigation;
+pub mod theme;
 pub mod toc;

src/renderer/html_handlebars/helpers/navigation.rs

@@ -2,9 +2,8 @@ use std::collections::BTreeMap;
 use std::path::Path;
 
 use handlebars::{Context, Handlebars, Helper, Output, RenderContext, RenderError, Renderable};
-use serde_json;
 
-use utils;
+use crate::utils;
 
 type StringMap = BTreeMap<String, String>;
 
@@ -18,13 +17,13 @@ impl Target {
     /// Returns target if found.
     fn find(
         &self,
-        base_path: &String,
-        current_path: &String,
+        base_path: &str,
+        current_path: &str,
         current_item: &StringMap,
         previous_item: &StringMap,
     ) -> Result<Option<StringMap>, RenderError> {
-        match self {
-            &Target::Next => {
+        match *self {
+            Target::Next => {
                 let previous_path = previous_item
                     .get("path")
                     .ok_or_else(|| RenderError::new("No path found for chapter in JSON data"))?;
@@ -34,7 +33,7 @@ impl Target {
                 }
             }
 
-            &Target::Previous => {
+            Target::Previous => {
                 if current_path == base_path {
                     return Ok(Some(previous_item.clone()));
                 }
@@ -47,22 +46,44 @@ impl Target {
 
 fn find_chapter(
     ctx: &Context,
-    rc: &mut RenderContext,
+    rc: &mut RenderContext<'_>,
     target: Target,
 ) -> Result<Option<StringMap>, RenderError> {
     debug!("Get data from context");
 
-    let chapters = rc.evaluate_absolute(ctx, "chapters", true).and_then(|c| {
-        serde_json::value::from_value::<Vec<StringMap>>(c.clone())
+    let chapters = rc.evaluate(ctx, "@root/chapters").and_then(|c| {
+        serde_json::value::from_value::<Vec<StringMap>>(c.as_json().clone())
             .map_err(|_| RenderError::new("Could not decode the JSON data"))
     })?;
 
     let base_path = rc
-        .evaluate_absolute(ctx, "path", true)?
+        .evaluate(ctx, "@root/path")?
+        .as_json()
         .as_str()
         .ok_or_else(|| RenderError::new("Type error for `path`, string expected"))?
         .replace("\"", "");
 
+    if !rc.evaluate(ctx, "@root/is_index")?.is_missing() {
+        // Special case for index.md which may be a synthetic page.
+        // Target::find won't match because there is no page with the path
+        // "index.md" (unless there really is an index.md in SUMMARY.md).
+        match target {
+            Target::Previous => return Ok(None),
+            Target::Next => match chapters
+                .iter()
+                .filter(|chapter| {
+                    // Skip things like "spacer"
+                    chapter.contains_key("path")
+                })
+                .skip(1)
+                .next()
+            {
+                Some(chapter) => return Ok(Some(chapter.clone())),
+                None => return Ok(None),
+            },
+        }
+    }
+
     let mut previous: Option<StringMap> = None;
 
     debug!("Search for chapter");
@@ -86,18 +107,19 @@ fn find_chapter(
 }
 
 fn render(
-    _h: &Helper,
+    _h: &Helper<'_, '_>,
     r: &Handlebars,
     ctx: &Context,
-    rc: &mut RenderContext,
-    out: &mut Output,
+    rc: &mut RenderContext<'_>,
+    out: &mut dyn Output,
     chapter: &StringMap,
 ) -> Result<(), RenderError> {
     trace!("Creating BTreeMap to inject in context");
 
     let mut context = BTreeMap::new();
     let base_path = rc
-        .evaluate_absolute(ctx, "path", false)?
+        .evaluate(ctx, "@root/path")?
+        .as_json()
         .as_str()
         .ok_or_else(|| RenderError::new("Type error for `path`, string expected"))?
         .replace("\"", "");
@@ -137,11 +159,11 @@ fn render(
 }
 
 pub fn previous(
-    _h: &Helper,
+    _h: &Helper<'_, '_>,
     r: &Handlebars,
     ctx: &Context,
-    rc: &mut RenderContext,
-    out: &mut Output,
+    rc: &mut RenderContext<'_>,
+    out: &mut dyn Output,
 ) -> Result<(), RenderError> {
     trace!("previous (handlebars helper)");
 
@@ -153,11 +175,11 @@ pub fn previous(
 }
 
 pub fn next(
-    _h: &Helper,
+    _h: &Helper<'_, '_>,
     r: &Handlebars,
     ctx: &Context,
-    rc: &mut RenderContext,
-    out: &mut Output,
+    rc: &mut RenderContext<'_>,
+    out: &mut dyn Output,
 ) -> Result<(), RenderError> {
     trace!("next (handlebars helper)");
 
@@ -172,29 +194,29 @@ pub fn next(
 mod tests {
     use super::*;
 
-    static TEMPLATE: &'static str =
+    static TEMPLATE: &str =
         "{{#previous}}{{title}}: {{link}}{{/previous}}|{{#next}}{{title}}: {{link}}{{/next}}";
 
     #[test]
     fn test_next_previous() {
         let data = json!({
-         "name": "two",
-         "path": "two.path",
-         "chapters": [
-            {
-               "name": "one",
-               "path": "one.path"
-            },
-            {
-               "name": "two",
-               "path": "two.path",
-            },
-            {
-               "name": "three",
-               "path": "three.path"
-            }
-         ]
-      });
+           "name": "two",
+           "path": "two.path",
+           "chapters": [
+              {
+                 "name": "one",
+                 "path": "one.path"
+              },
+              {
+                 "name": "two",
+                 "path": "two.path",
+              },
+              {
+                 "name": "three",
+                 "path": "three.path"
+              }
+           ]
+        });
 
         let mut h = Handlebars::new();
         h.register_helper("previous", Box::new(previous));
@@ -209,23 +231,23 @@ mod tests {
     #[test]
     fn test_first() {
         let data = json!({
-         "name": "one",
-         "path": "one.path",
-         "chapters": [
-            {
-               "name": "one",
-               "path": "one.path"
-            },
-            {
-               "name": "two",
-               "path": "two.path",
-            },
-            {
-               "name": "three",
-               "path": "three.path"
-            }
-         ]
-      });
+           "name": "one",
+           "path": "one.path",
+           "chapters": [
+              {
+                 "name": "one",
+                 "path": "one.path"
+              },
+              {
+                 "name": "two",
+                 "path": "two.path",
+              },
+              {
+                 "name": "three",
+                 "path": "three.path"
+              }
+           ]
+        });
 
         let mut h = Handlebars::new();
         h.register_helper("previous", Box::new(previous));
@@ -239,23 +261,23 @@ mod tests {
     #[test]
     fn test_last() {
         let data = json!({
-         "name": "three",
-         "path": "three.path",
-         "chapters": [
-            {
-               "name": "one",
-               "path": "one.path"
-            },
-            {
-               "name": "two",
-               "path": "two.path",
-            },
-            {
-               "name": "three",
-               "path": "three.path"
-            }
-         ]
-      });
+           "name": "three",
+           "path": "three.path",
+           "chapters": [
+              {
+                 "name": "one",
+                 "path": "one.path"
+              },
+              {
+                 "name": "two",
+                 "path": "two.path",
+              },
+              {
+                 "name": "three",
+                 "path": "three.path"
+              }
+           ]
+        });
 
         let mut h = Handlebars::new();
         h.register_helper("previous", Box::new(previous));

src/renderer/html_handlebars/helpers/theme.rs

@@ -0,0 +1,28 @@
+use handlebars::{Context, Handlebars, Helper, Output, RenderContext, RenderError};
+
+pub fn theme_option(
+    h: &Helper<'_, '_>,
+    _r: &Handlebars,
+    ctx: &Context,
+    rc: &mut RenderContext<'_>,
+    out: &mut dyn Output,
+) -> Result<(), RenderError> {
+    trace!("theme_option (handlebars helper)");
+
+    let param = h.param(0).and_then(|v| v.value().as_str()).ok_or_else(|| {
+        RenderError::new("Param 0 with String type is required for theme_option helper.")
+    })?;
+
+    let default_theme = rc.evaluate(ctx, "@root/default_theme")?;
+    let default_theme_name = default_theme
+        .as_json()
+        .as_str()
+        .ok_or_else(|| RenderError::new("Type error for `default_theme`, string expected"))?;
+
+    out.write(param)?;
+    if param.to_lowercase() == default_theme_name.to_lowercase() {
+        out.write(" (default)")?;
+    }
+
+    Ok(())
+}

src/renderer/html_handlebars/helpers/toc.rs

@@ -1,11 +1,10 @@
 use std::collections::BTreeMap;
 use std::path::Path;
 
-use utils;
+use crate::utils;
 
 use handlebars::{Context, Handlebars, Helper, HelperDef, Output, RenderContext, RenderError};
-use pulldown_cmark::{html, Event, Parser, Tag};
-use serde_json;
+use pulldown_cmark::{html, Event, Parser};
 
 // Handlebars helper to construct TOC
 #[derive(Clone, Copy)]
@@ -16,25 +15,49 @@ pub struct RenderToc {
 impl HelperDef for RenderToc {
     fn call<'reg: 'rc, 'rc>(
         &self,
-        _h: &Helper,
-        _: &Handlebars,
-        ctx: &Context,
-        rc: &mut RenderContext,
-        out: &mut Output,
+        _h: &Helper<'reg, 'rc>,
+        _r: &'reg Handlebars,
+        ctx: &'rc Context,
+        rc: &mut RenderContext<'reg>,
+        out: &mut dyn Output,
     ) -> Result<(), RenderError> {
         // get value from context data
         // rc.get_path() is current json parent path, you should always use it like this
         // param is the key of value you want to display
-        let chapters = rc.evaluate_absolute(ctx, "chapters", true).and_then(|c| {
-            serde_json::value::from_value::<Vec<BTreeMap<String, String>>>(c.clone())
+        let chapters = rc.evaluate(ctx, "@root/chapters").and_then(|c| {
+            serde_json::value::from_value::<Vec<BTreeMap<String, String>>>(c.as_json().clone())
                 .map_err(|_| RenderError::new("Could not decode the JSON data"))
         })?;
-        let current = rc
-            .evaluate_absolute(ctx, "path", true)?
+        let current_path = rc
+            .evaluate(ctx, "@root/path")?
+            .as_json()
             .as_str()
-            .ok_or_else(|| RenderError::new("Type error for `path`, string expected"))?
+            .ok_or(RenderError::new("Type error for `path`, string expected"))?
             .replace("\"", "");
 
+        let current_section = rc
+            .evaluate(ctx, "@root/section")?
+            .as_json()
+            .as_str()
+            .map(str::to_owned)
+            .unwrap_or_default();
+
+        let fold_enable = rc
+            .evaluate(ctx, "@root/fold_enable")?
+            .as_json()
+            .as_bool()
+            .ok_or(RenderError::new(
+                "Type error for `fold_enable`, bool expected",
+            ))?;
+
+        let fold_level = rc
+            .evaluate(ctx, "@root/fold_level")?
+            .as_json()
+            .as_u64()
+            .ok_or(RenderError::new(
+                "Type error for `fold_level`, u64 expected",
+            ))?;
+
         out.write("<ol class=\"chapter\">")?;
 
         let mut current_level = 1;
@@ -46,10 +69,23 @@ impl HelperDef for RenderToc {
                 continue;
             }
 
-            let level = if let Some(s) = item.get("section") {
-                s.matches('.').count()
+            let (section, level) = if let Some(s) = item.get("section") {
+                (s.as_str(), s.matches('.').count())
             } else {
-                1
+                ("", 1)
+            };
+
+            let is_expanded = {
+                if !fold_enable {
+                    // Disable fold. Expand all chapters.
+                    true
+                } else if !section.is_empty() && current_section.starts_with(section) {
+                    // The section is ancestor or the current section itself.
+                    true
+                } else {
+                    // Levels that are larger than this would be folded.
+                    level - 1 < fold_level as usize
+                }
             };
 
             if level > current_level {
@@ -58,20 +94,16 @@ impl HelperDef for RenderToc {
                     out.write("<ol class=\"section\">")?;
                     current_level += 1;
                 }
-                out.write("<li>")?;
+                write_li_open_tag(out, is_expanded, false)?;
             } else if level < current_level {
                 while level < current_level {
                     out.write("</ol>")?;
                     out.write("</li>")?;
                     current_level -= 1;
                 }
-                out.write("<li>")?;
+                write_li_open_tag(out, is_expanded, false)?;
             } else {
-                out.write("<li")?;
-                if item.get("section").is_none() {
-                    out.write(" class=\"affix\"")?;
-                }
-                out.write(">")?;
+                write_li_open_tag(out, is_expanded, item.get("section").is_none())?;
             }
 
             // Link
@@ -87,11 +119,11 @@ impl HelperDef for RenderToc {
                         .replace("\\", "/");
 
                     // Add link
-                    out.write(&utils::fs::path_to_root(&current))?;
+                    out.write(&utils::fs::path_to_root(&current_path))?;
                     out.write(&tmp)?;
                     out.write("\"")?;
 
-                    if path == &current {
+                    if path == &current_path {
                         out.write(" class=\"active\"")?;
                     }
 
@@ -118,10 +150,7 @@ impl HelperDef for RenderToc {
 
                 // filter all events that are not inline code blocks
                 let parser = Parser::new(name).filter(|event| match *event {
-                    Event::Start(Tag::Code)
-                    | Event::End(Tag::Code)
-                    | Event::InlineHtml(_)
-                    | Event::Text(_) => true,
+                    Event::Code(_) | Event::Html(_) | Event::Text(_) => true,
                     _ => false,
                 });
 
@@ -137,6 +166,13 @@ impl HelperDef for RenderToc {
                 out.write("</a>")?;
             }
 
+            // Render expand/collapse toggle
+            if let Some(flag) = item.get("has_sub_items") {
+                let has_sub_items = flag.parse::<bool>().unwrap_or_default();
+                if fold_enable && has_sub_items {
+                    out.write("<a class=\"toggle\"><div>❱</div></a>")?;
+                }
+            }
             out.write("</li>")?;
         }
         while current_level > 1 {
@@ -149,3 +185,19 @@ impl HelperDef for RenderToc {
         Ok(())
     }
 }
+
+fn write_li_open_tag(
+    out: &mut dyn Output,
+    is_expanded: bool,
+    is_affix: bool,
+) -> Result<(), std::io::Error> {
+    let mut li = String::from("<li class=\"");
+    if is_expanded {
+        li.push_str("expanded ");
+    }
+    if is_affix {
+        li.push_str("affix ");
+    }
+    li.push_str("\">");
+    out.write(&li)
+}

src/renderer/html_handlebars/search.rs

@@ -1,19 +1,15 @@
-extern crate ammonia;
-extern crate elasticlunr;
-
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 use std::path::Path;
 
-use self::elasticlunr::Index;
+use elasticlunr::Index;
 use pulldown_cmark::*;
-use serde_json;
 
-use book::{Book, BookItem};
-use config::Search;
-use errors::*;
-use theme::searcher;
-use utils;
+use crate::book::{Book, BookItem};
+use crate::config::Search;
+use crate::errors::*;
+use crate::theme::searcher;
+use crate::utils;
 
 /// Creates all files required for search.
 pub fn create_files(search_config: &Search, destination: &Path, book: &Book) -> Result<()> {
@@ -35,7 +31,7 @@ pub fn create_files(search_config: &Search, destination: &Path, book: &Book) ->
         utils::fs::write_file(
             destination,
             "searchindex.js",
-            format!("window.search = {};", index).as_bytes(),
+            format!("Object.assign(window.search, {});", index).as_bytes(),
         )?;
         utils::fs::write_file(destination, "searcher.js", searcher::JS)?;
         utils::fs::write_file(destination, "mark.min.js", searcher::MARK_JS)?;
@@ -54,7 +50,7 @@ fn add_doc(
     section_id: &Option<String>,
     items: &[&str],
 ) {
-    let url = if let &Some(ref id) = section_id {
+    let url = if let Some(ref id) = *section_id {
         Cow::Owned(format!("{}#{}", anchor_base, id))
     } else {
         Cow::Borrowed(anchor_base)
@@ -74,8 +70,8 @@ fn render_item(
     doc_urls: &mut Vec<String>,
     item: &BookItem,
 ) -> Result<()> {
-    let chapter = match item {
-        &BookItem::Chapter(ref ch) => ch,
+    let chapter = match *item {
+        BookItem::Chapter(ref ch) => ch,
         _ => return Ok(()),
     };
 
@@ -85,24 +81,21 @@ fn render_item(
         .chain_err(|| "Could not convert HTML path to str")?;
     let anchor_base = utils::fs::normalize_path(filepath);
 
-    let mut opts = Options::empty();
-    opts.insert(OPTION_ENABLE_TABLES);
-    opts.insert(OPTION_ENABLE_FOOTNOTES);
-    let p = Parser::new_ext(&chapter.content, opts);
+    let mut p = utils::new_cmark_parser(&chapter.content).peekable();
 
-    let mut in_header = false;
-    let max_section_depth = search_config.heading_split_level as i32;
+    let mut in_heading = false;
+    let max_section_depth = u32::from(search_config.heading_split_level);
     let mut section_id = None;
     let mut heading = String::new();
     let mut body = String::new();
     let mut breadcrumbs = chapter.parent_names.clone();
     let mut footnote_numbers = HashMap::new();
 
-    for event in p {
+    while let Some(event) = p.next() {
         match event {
-            Event::Start(Tag::Header(i)) if i <= max_section_depth => {
-                if heading.len() > 0 {
-                    // Section finished, the next header is following now
+            Event::Start(Tag::Heading(i)) if i <= max_section_depth => {
+                if !heading.is_empty() {
+                    // Section finished, the next heading is following now
                     // Write the data to the index, and clear it for the next section
                     add_doc(
                         index,
@@ -117,10 +110,10 @@ fn render_item(
                     breadcrumbs.pop();
                 }
 
-                in_header = true;
+                in_heading = true;
             }
-            Event::End(Tag::Header(i)) if i <= max_section_depth => {
-                in_header = false;
+            Event::End(Tag::Heading(i)) if i <= max_section_depth => {
+                in_heading = false;
                 section_id = Some(utils::id_from_content(&heading));
                 breadcrumbs.push(heading.clone());
             }
@@ -128,34 +121,45 @@ fn render_item(
                 let number = footnote_numbers.len() + 1;
                 footnote_numbers.entry(name).or_insert(number);
             }
-            Event::Start(_) | Event::End(_) | Event::SoftBreak | Event::HardBreak => {
+            Event::Html(html) => {
+                let mut html_block = html.into_string();
+
+                // As of pulldown_cmark 0.6, html events are no longer contained
+                // 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);
+                    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
                 // to ensure words don't get merged together
-                if in_header {
+                if in_heading {
                     heading.push(' ');
                 } else {
                     body.push(' ');
                 }
             }
-            Event::Text(text) => {
-                if in_header {
+            Event::Text(text) | Event::Code(text) => {
+                if in_heading {
                     heading.push_str(&text);
                 } else {
                     body.push_str(&text);
                 }
             }
-            Event::Html(html) | Event::InlineHtml(html) => {
-                body.push_str(&clean_html(&html));
-            }
             Event::FootnoteReference(name) => {
                 let len = footnote_numbers.len() + 1;
                 let number = footnote_numbers.entry(name).or_insert(len);
                 body.push_str(&format!(" [{}] ", number));
             }
+            Event::TaskListMarker(_checked) => {}
         }
     }
 
-    if heading.len() > 0 {
+    if !heading.is_empty() {
         // Make sure the last section is added to the index
         add_doc(
             index,
@@ -170,7 +174,7 @@ fn render_item(
 }
 
 fn write_to_json(index: Index, search_config: &Search, doc_urls: Vec<String>) -> Result<String> {
-    use self::elasticlunr::config::{SearchBool, SearchOptions, SearchOptionsField};
+    use elasticlunr::config::{SearchBool, SearchOptions, SearchOptionsField};
     use std::collections::BTreeMap;
 
     #[derive(Serialize)]

src/renderer/markdown_renderer.rs

@@ -0,0 +1,46 @@
+use crate::book::BookItem;
+use crate::errors::*;
+use crate::renderer::{RenderContext, Renderer};
+use crate::utils;
+
+use std::fs;
+
+#[derive(Default)]
+/// A renderer to output the Markdown after the preprocessors have run. Mostly useful
+/// when debugging preprocessors.
+pub struct MarkdownRenderer;
+
+impl MarkdownRenderer {
+    /// Create a new `MarkdownRenderer` instance.
+    pub fn new() -> Self {
+        MarkdownRenderer
+    }
+}
+
+impl Renderer for MarkdownRenderer {
+    fn name(&self) -> &str {
+        "markdown"
+    }
+
+    fn render(&self, ctx: &RenderContext) -> Result<()> {
+        let destination = &ctx.destination;
+        let book = &ctx.book;
+
+        if destination.exists() {
+            utils::fs::remove_dir_content(destination)
+                .chain_err(|| "Unable to remove stale Markdown output")?;
+        }
+
+        trace!("markdown render");
+        for item in book.iter() {
+            if let BookItem::Chapter(ref ch) = *item {
+                utils::fs::write_file(&ctx.destination, &ch.path, ch.content.as_bytes())?;
+            }
+        }
+
+        fs::create_dir_all(&destination)
+            .chain_err(|| "Unexpected error when constructing destination path")?;
+
+        Ok(())
+    }
+}

src/renderer/mod.rs

@@ -8,23 +8,24 @@
 //!
 //! The definition for [RenderContext] may be useful though.
 //!
-//! [For Developers]: https://rust-lang-nursery.github.io/mdBook/lib/index.html
+//! [For Developers]: https://rust-lang.github.io/mdBook/for_developers/index.html
 //! [RenderContext]: struct.RenderContext.html
 
 pub use self::html_handlebars::HtmlHandlebars;
+pub use self::markdown_renderer::MarkdownRenderer;
 
 mod html_handlebars;
+mod markdown_renderer;
 
-use serde_json;
 use shlex::Shlex;
 use std::fs;
 use std::io::{self, Read};
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 
-use book::Book;
-use config::Config;
-use errors::*;
+use crate::book::Book;
+use crate::config::Config;
+use crate::errors::*;
 
 /// An arbitrary `mdbook` backend.
 ///
@@ -64,6 +65,7 @@ pub struct RenderContext {
     /// renderers to cache intermediate results, this directory is not
     /// guaranteed to be empty or even exist.
     pub destination: PathBuf,
+    #[serde(skip)]
     __non_exhaustive: (),
 }
 
@@ -75,9 +77,9 @@ impl RenderContext {
         Q: Into<PathBuf>,
     {
         RenderContext {
-            book: book,
-            config: config,
-            version: ::MDBOOK_VERSION.to_string(),
+            book,
+            config,
+            version: crate::MDBOOK_VERSION.to_string(),
             root: root.into(),
             destination: destination.into(),
             __non_exhaustive: (),

src/theme/ayu-highlight.css

@@ -69,3 +69,11 @@ Original by Dempfi (https://github.com/dempfi/ayu)
 .hljs-strong {
   font-weight: bold;
 }
+
+.hljs-addition {
+  color: #91b362;
+}
+
+.hljs-deletion {
+  color: #d96c75;
+}

src/theme/book.js

@@ -16,9 +16,6 @@ function playpen_text(playpen) {
 }
 
 (function codeSnippets() {
-    // Hide Rust code lines prepended with a specific character
-    var hiding_character = "#";
-
     function fetch_with_timeout(url, options, timeout = 6000) {
         return Promise.race([
             fetch(url, options),
@@ -55,6 +52,15 @@ function playpen_text(playpen) {
                 editor.addEventListener("change", function (e) {
                     update_play_button(playpen_block, playground_crates);
                 });
+                // add Ctrl-Enter command to execute rust code
+                editor.commands.addCommand({
+                    name: "run",
+                    bindKey: {
+                        win: "Ctrl-Enter",
+                        mac: "Ctrl-Enter"
+                    },
+                    exec: _editor => run_rust_code(playpen_block)
+                });
             }
         }
     }
@@ -101,11 +107,15 @@ function playpen_text(playpen) {
         }
 
         let text = playpen_text(code_block);
+        let classes = code_block.querySelector('code').classList;
+        let has_2018 = classes.contains("edition2018");
+        let edition = has_2018 ? "2018" : "2015";
 
         var params = {
             version: "stable",
             optimize: "0",
-            code: text
+            code: text,
+            edition: edition
         };
 
         if (text.indexOf("#![feature") !== -1) {
@@ -157,95 +167,59 @@ function playpen_text(playpen) {
 
     Array.from(document.querySelectorAll("code.language-rust")).forEach(function (block) {
 
-        var code_block = block;
-        var pre_block = block.parentNode;
-        // hide lines
-        var lines = code_block.innerHTML.split("\n");
-        var first_non_hidden_line = false;
-        var lines_hidden = false;
-        var trimmed_line = "";
-
-        for (var n = 0; n < lines.length; n++) {
-            trimmed_line = lines[n].trim();
-            if (trimmed_line[0] == hiding_character && trimmed_line[1] != hiding_character) {
-                if (first_non_hidden_line) {
-                    lines[n] = "<span class=\"hidden\">" + "\n" + lines[n].replace(/(\s*)# ?/, "$1") + "</span>";
-                }
-                else {
-                    lines[n] = "<span class=\"hidden\">" + lines[n].replace(/(\s*)# ?/, "$1") + "\n" + "</span>";
-                }
-                lines_hidden = true;
-            }
-            else if (first_non_hidden_line) {
-                lines[n] = "\n" + lines[n];
-            }
-            else {
-                first_non_hidden_line = true;
-            }
-            if (trimmed_line[0] == hiding_character && trimmed_line[1] == hiding_character) {
-                lines[n] = lines[n].replace("##", "#")
-            }
-        }
-        code_block.innerHTML = lines.join("");
-
+        var lines = Array.from(block.querySelectorAll('.boring'));
         // If no lines were hidden, return
-        if (!lines_hidden) { return; }
+        if (!lines.length) { return; }
+        block.classList.add("hide-boring");
 
         var buttons = document.createElement('div');
         buttons.className = 'buttons';
         buttons.innerHTML = "<button class=\"fa fa-expand\" title=\"Show hidden lines\" aria-label=\"Show hidden lines\"></button>";
 
         // add expand button
+        var pre_block = block.parentNode;
         pre_block.insertBefore(buttons, pre_block.firstChild);
 
         pre_block.querySelector('.buttons').addEventListener('click', function (e) {
             if (e.target.classList.contains('fa-expand')) {
-                var lines = pre_block.querySelectorAll('span.hidden');
-
                 e.target.classList.remove('fa-expand');
                 e.target.classList.add('fa-compress');
                 e.target.title = 'Hide lines';
                 e.target.setAttribute('aria-label', e.target.title);
 
-                Array.from(lines).forEach(function (line) {
-                    line.classList.remove('hidden');
-                    line.classList.add('unhidden');
-                });
+                block.classList.remove('hide-boring');
             } else if (e.target.classList.contains('fa-compress')) {
-                var lines = pre_block.querySelectorAll('span.unhidden');
-
                 e.target.classList.remove('fa-compress');
                 e.target.classList.add('fa-expand');
                 e.target.title = 'Show hidden lines';
                 e.target.setAttribute('aria-label', e.target.title);
 
-                Array.from(lines).forEach(function (line) {
-                    line.classList.remove('unhidden');
-                    line.classList.add('hidden');
-                });
+                block.classList.add('hide-boring');
             }
         });
     });
 
-    Array.from(document.querySelectorAll('pre code')).forEach(function (block) {
-        var pre_block = block.parentNode;
-        if (!pre_block.classList.contains('playpen')) {
-            var buttons = pre_block.querySelector(".buttons");
-            if (!buttons) {
-                buttons = document.createElement('div');
-                buttons.className = 'buttons';
-                pre_block.insertBefore(buttons, pre_block.firstChild);
+    if (window.playpen_copyable) {
+        Array.from(document.querySelectorAll('pre code')).forEach(function (block) {
+            var pre_block = block.parentNode;
+            if (!pre_block.classList.contains('playpen')) {
+                var buttons = pre_block.querySelector(".buttons");
+                if (!buttons) {
+                    buttons = document.createElement('div');
+                    buttons.className = 'buttons';
+                    pre_block.insertBefore(buttons, pre_block.firstChild);
+                }
+
+                var clipButton = document.createElement('button');
+                clipButton.className = 'fa fa-copy clip-button';
+                clipButton.title = 'Copy to clipboard';
+                clipButton.setAttribute('aria-label', clipButton.title);
+                clipButton.innerHTML = '<i class=\"tooltiptext\"></i>';
+
+                buttons.insertBefore(clipButton, buttons.firstChild);
             }
-
-            var clipButton = document.createElement('button');
-            clipButton.className = 'fa fa-copy clip-button';
-            clipButton.title = 'Copy to clipboard';
-            clipButton.setAttribute('aria-label', clipButton.title);
-            clipButton.innerHTML = '<i class=\"tooltiptext\"></i>';
-
-            buttons.insertBefore(clipButton, buttons.firstChild);
-        }
-    });
+        });
+    }
 
     // Process playpen code blocks
     Array.from(document.querySelectorAll(".playpen")).forEach(function (pre_block) {
@@ -263,19 +237,21 @@ function playpen_text(playpen) {
         runCodeButton.title = 'Run this code';
         runCodeButton.setAttribute('aria-label', runCodeButton.title);
 
-        var copyCodeClipboardButton = document.createElement('button');
-        copyCodeClipboardButton.className = 'fa fa-copy clip-button';
-        copyCodeClipboardButton.innerHTML = '<i class="tooltiptext"></i>';
-        copyCodeClipboardButton.title = 'Copy to clipboard';
-        copyCodeClipboardButton.setAttribute('aria-label', copyCodeClipboardButton.title);
-
         buttons.insertBefore(runCodeButton, buttons.firstChild);
-        buttons.insertBefore(copyCodeClipboardButton, buttons.firstChild);
-
         runCodeButton.addEventListener('click', function (e) {
             run_rust_code(pre_block);
         });
 
+        if (window.playpen_copyable) {
+            var copyCodeClipboardButton = document.createElement('button');
+            copyCodeClipboardButton.className = 'fa fa-copy clip-button';
+            copyCodeClipboardButton.innerHTML = '<i class="tooltiptext"></i>';
+            copyCodeClipboardButton.title = 'Copy to clipboard';
+            copyCodeClipboardButton.setAttribute('aria-label', copyCodeClipboardButton.title);
+
+            buttons.insertBefore(copyCodeClipboardButton, buttons.firstChild);
+        }
+
         let code_block = pre_block.querySelector("code");
         if (window.ace && code_block.classList.contains("editable")) {
             var undoChangesButton = document.createElement('button');
@@ -317,7 +293,7 @@ function playpen_text(playpen) {
         themeToggleButton.focus();
     }
 
-    function set_theme(theme) {
+    function set_theme(theme, store = true) {
         let ace_theme;
 
         if (theme == 'coal' || theme == 'navy') {
@@ -330,13 +306,11 @@ function playpen_text(playpen) {
             stylesheets.ayuHighlight.disabled = false;
             stylesheets.tomorrowNight.disabled = true;
             stylesheets.highlight.disabled = true;
-
             ace_theme = "ace/theme/tomorrow_night";
         } else {
             stylesheets.ayuHighlight.disabled = true;
             stylesheets.tomorrowNight.disabled = true;
             stylesheets.highlight.disabled = false;
-
             ace_theme = "ace/theme/dawn";
         }
 
@@ -352,11 +326,12 @@ function playpen_text(playpen) {
 
         var previousTheme;
         try { previousTheme = localStorage.getItem('mdbook-theme'); } catch (e) { }
-        if (previousTheme === null || previousTheme === undefined) { previousTheme = 'light'; }
+        if (previousTheme === null || previousTheme === undefined) { previousTheme = default_theme; }
 
-        try { localStorage.setItem('mdbook-theme', theme); } catch (e) { }
+        if (store) {
+            try { localStorage.setItem('mdbook-theme', theme); } catch (e) { }
+        }
 
-        document.body.className = theme;
         html.classList.remove(previousTheme);
         html.classList.add(theme);
     }
@@ -364,9 +339,9 @@ function playpen_text(playpen) {
     // Set theme
     var theme;
     try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
-    if (theme === null || theme === undefined) { theme = 'light'; }
+    if (theme === null || theme === undefined) { theme = default_theme; }
 
-    set_theme(theme);
+    set_theme(theme, false);
 
     themeToggleButton.addEventListener('click', function () {
         if (themePopup.style.display === 'block') {
@@ -388,7 +363,7 @@ function playpen_text(playpen) {
         }
     });
 
-    // Should not be needed, but it works around an issue on macOS & iOS: https://github.com/rust-lang-nursery/mdBook/issues/628
+    // Should not be needed, but it works around an issue on macOS & iOS: https://github.com/rust-lang/mdBook/issues/628
     document.addEventListener('click', function(e) {
         if (themePopup.style.display === 'block' && !themeToggleButton.contains(e.target) && !themePopup.contains(e.target)) {
             hideThemes();
@@ -433,8 +408,10 @@ function playpen_text(playpen) {
 (function sidebar() {
     var html = document.querySelector("html");
     var sidebar = document.getElementById("sidebar");
+    var sidebarScrollBox = document.getElementById("sidebar-scrollbox");
     var sidebarLinks = document.querySelectorAll('#sidebar a');
     var sidebarToggleButton = document.getElementById("sidebar-toggle");
+    var sidebarResizeHandle = document.getElementById("sidebar-resize-handle");
     var firstContact = null;
 
     function showSidebar() {
@@ -448,6 +425,17 @@ function playpen_text(playpen) {
         try { localStorage.setItem('mdbook-sidebar', 'visible'); } catch (e) { }
     }
 
+
+    var sidebarAnchorToggles = document.querySelectorAll('#sidebar a.toggle');
+
+    function toggleSection(ev) {
+        ev.currentTarget.parentElement.classList.toggle('expanded');
+    }
+
+    Array.from(sidebarAnchorToggles).forEach(function (el) {
+        el.addEventListener('click', toggleSection);
+    });
+
     function hideSidebar() {
         html.classList.remove('sidebar-visible')
         html.classList.add('sidebar-hidden');
@@ -474,6 +462,23 @@ function playpen_text(playpen) {
         }
     });
 
+    sidebarResizeHandle.addEventListener('mousedown', initResize, false);
+
+    function initResize(e) {
+        window.addEventListener('mousemove', resize, false);
+        window.addEventListener('mouseup', stopResize, false);
+        html.classList.add('sidebar-resizing');
+    }
+    function resize(e) {
+        document.documentElement.style.setProperty('--sidebar-width', (e.clientX - sidebar.offsetLeft) + 'px');
+    }
+    //on mouseup remove windows functions mousemove & mouseup
+    function stopResize(e) {
+        html.classList.remove('sidebar-resizing');
+        window.removeEventListener('mousemove', resize, false);
+        window.removeEventListener('mouseup', stopResize, false);
+    }
+
     document.addEventListener('touchstart', function (e) {
         firstContact = {
             x: e.touches[0].clientX,
@@ -502,7 +507,7 @@ function playpen_text(playpen) {
     // Scroll sidebar to current active section
     var activeSection = sidebar.querySelector(".active");
     if (activeSection) {
-        sidebar.scrollTop = activeSection.offsetTop;
+        sidebarScrollBox.scrollTop = activeSection.offsetTop;
     }
 })();
 
@@ -543,7 +548,7 @@ function playpen_text(playpen) {
         elem.className = 'fa fa-copy tooltipped';
     }
 
-    var clipboardSnippets = new Clipboard('.clip-button', {
+    var clipboardSnippets = new ClipboardJS('.clip-button', {
         text: function (trigger) {
             hideTooltip(trigger);
             let playpen = trigger.closest("pre");
@@ -595,6 +600,6 @@ function playpen_text(playpen) {
             menu.classList.remove('bordered');
         }
 
-        previousScrollTop = document.scrollingElement.scrollTop;
+        previousScrollTop = Math.max(document.scrollingElement.scrollTop, 0);
     }, { passive: true });
 })();

src/theme/css/chrome.css

@@ -8,7 +8,9 @@
 ::-webkit-scrollbar-thumb {
     background: var(--scrollbar);
 }
-
+html {
+    scrollbar-color: var(--scrollbar) var(--bg);
+}
 #searchresults a,
 .content a:link,
 a:visited,
@@ -43,7 +45,7 @@ a > .hljs {
     position: relative;
     padding: 0 8px;
     z-index: 10;
-    line-height: 50px;
+    line-height: var(--menu-bar-height);
     cursor: pointer;
     transition: color 0.5s;
 }
@@ -63,27 +65,30 @@ a > .hljs {
     margin: 0;
 }
 
-#print-button {
+.right-buttons {
     margin: 0 15px;
 }
+.right-buttons a {
+    text-decoration: none;
+}
 
 html:not(.sidebar-visible) #menu-bar:not(:hover).folded > #menu-bar-sticky-container {
-    transform: translateY(-60px);
+    transform: translateY(calc(-10px - var(--menu-bar-height)));
 }
 
 .left-buttons {
     display: flex;
     margin: 0 5px;
 }
-.no-js .left-buttons { 
+.no-js .left-buttons {
     display: none;
 }
 
 .menu-title {
     display: inline-block;
     font-weight: 200;
-    font-size: 20px;
-    line-height: 50px;
+    font-size: 2rem;
+    line-height: var(--menu-bar-height);
     text-align: center;
     margin: 0;
     flex: 1;
@@ -121,7 +126,7 @@ html:not(.sidebar-visible) #menu-bar:not(:hover).folded > #menu-bar-sticky-conta
     text-decoration: none;
 
     position: fixed;
-    top: 50px; /* Height of menu-bar */
+    top: 0;
     bottom: 0;
     margin: 0;
     max-width: 150px;
@@ -132,17 +137,21 @@ html:not(.sidebar-visible) #menu-bar:not(:hover).folded > #menu-bar-sticky-conta
     align-content: center;
     flex-direction: column;
 
-    transition: color 0.5s;
+    transition: color 0.5s, background-color 0.5s;
 }
 
-.nav-chapters:hover { text-decoration: none; }
+.nav-chapters:hover {
+    text-decoration: none;
+    background-color: var(--theme-hover);
+    transition: background-color 0.15s, color 0.15s;
+}
 
 .nav-wrapper {
     margin-top: 50px;
     display: none;
 }
 
-.mobile-nav-chapters { 
+.mobile-nav-chapters {
     font-size: 2.5em;
     text-align: center;
     text-decoration: none;
@@ -173,11 +182,14 @@ html:not(.sidebar-visible) #menu-bar:not(:hover).folded > #menu-bar-sticky-conta
 /* Inline code */
 
 :not(pre) > .hljs {
-    display: inline-block;
-    vertical-align: middle;
+    display: inline;
     padding: 0.1em 0.3em;
     border-radius: 3px;
+}
+
+:not(pre):not(a) > .hljs {
     color: var(--inline-code-color);
+    overflow-x: initial;
 }
 
 a:hover > .hljs {
@@ -298,8 +310,6 @@ ul#searchresults span.teaser em {
     top: 0;
     bottom: 0;
     width: var(--sidebar-width);
-    overflow-y: auto;
-    padding: 10px 10px;
     font-size: 0.875em;
     box-sizing: border-box;
     -webkit-overflow-scrolling: touch;
@@ -307,12 +317,39 @@ ul#searchresults span.teaser em {
     background-color: var(--sidebar-bg);
     color: var(--sidebar-fg);
 }
-.js .sidebar {
+.sidebar-resizing {
+    -moz-user-select: none;
+    -webkit-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+.js:not(.sidebar-resizing) .sidebar {
     transition: transform 0.3s; /* Animation: slide away */
 }
 .sidebar code {
     line-height: 2em;
 }
+.sidebar .sidebar-scrollbox {
+    overflow-y: auto;
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    padding: 10px 10px;
+}
+.sidebar .sidebar-resize-handle {
+    position: absolute;
+    cursor: col-resize;
+    width: 0;
+    right: 0;
+    top: 0;
+    bottom: 0;
+}
+.js .sidebar .sidebar-resize-handle {
+    cursor: col-resize;
+    width: 5px;
+}
 .sidebar-hidden .sidebar {
     transform: translateX(calc(0px - var(--sidebar-width)));
 }
@@ -338,22 +375,52 @@ ul#searchresults span.teaser em {
     padding-left: 0;
     line-height: 2.2em;
 }
+
+.chapter ol {
+    width: 100%;
+}
+
 .chapter li {
+    display: flex;
     color: var(--sidebar-non-existant);
 }
 .chapter li a {
-    color: var(--sidebar-fg);
     display: block;
     padding: 0;
     text-decoration: none;
+    color: var(--sidebar-fg);
 }
-.chapter li a:hover { text-decoration: none }
-.chapter li .active,
-a:hover {
-    /* Animate color change */
+
+.chapter li a:hover {
     color: var(--sidebar-active);
 }
 
+.chapter li a.active {
+    color: var(--sidebar-active);
+}
+
+.chapter li > a.toggle {
+    cursor: pointer;
+    display: block;
+    margin-left: auto;
+    padding: 0 10px;
+    user-select: none;
+    opacity: 0.68;
+}
+
+.chapter li > a.toggle div {
+    transition: transform 0.5s;
+}
+
+/* collapse the section */
+.chapter li:not(.expanded) + li > ol {
+    display: none;
+}
+
+.chapter li.expanded > a.toggle div {
+    transform: rotate(90deg);
+}
+
 .spacer {
     width: 100%;
     height: 3px;
@@ -363,7 +430,7 @@ a:hover {
     background-color: var(--sidebar-spacer);
 }
 
-@media (-moz-touch-enabled: 1), (pointer: coarse) { 
+@media (-moz-touch-enabled: 1), (pointer: coarse) {
     .chapter li a { padding: 5px 0; }
     .spacer { margin: 10px 0; }
 }
@@ -379,7 +446,7 @@ a:hover {
 .theme-popup {
     position: absolute;
     left: 10px;
-    top: 50px;
+    top: var(--menu-bar-height);
     z-index: 1000;
     border-radius: 4px;
     font-size: 0.7em;

src/theme/css/general.css

@@ -2,6 +2,11 @@
 
 @import 'variables.css';
 
+:root {
+    /* Browser default font-size is 16px, this way 1 rem = 10px */
+    font-size: 62.5%;
+}
+
 html {
     font-family: "Open Sans", sans-serif;
     color: var(--fg);
@@ -11,39 +16,47 @@ html {
 
 body {
     margin: 0;
-    font-size: 1rem;
+    font-size: 1.6rem;
     overflow-x: hidden;
 }
 
 code {
-    font-family: "Source Code Pro", Consolas, "Ubuntu Mono", Menlo, "DejaVu Sans Mono", monospace, monospace;
+    font-family: "Source Code Pro", Consolas, "Ubuntu Mono", Menlo, "DejaVu Sans Mono", monospace, monospace !important;
     font-size: 0.875em; /* please adjust the ace font size accordingly in editor.js */
 }
 
 .left { float: left; }
 .right { float: right; }
+.boring { opacity: 0.6; }
+.hide-boring .boring { display: none; }
 .hidden { display: none; }
-.play-button.hidden { display: none; }
 
 h2, h3 { margin-top: 2.5em; }
 h4, h5 { margin-top: 2em; }
 
 .header + .header h3,
 .header + .header h4,
-.header + .header h5 { 
+.header + .header h5 {
     margin-top: 1em;
 }
 
-a.header:target h1:before,
-a.header:target h2:before,
-a.header:target h3:before,
-a.header:target h4:before {
+h1 a.header:target::before,
+h2 a.header:target::before,
+h3 a.header:target::before,
+h4 a.header: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 {
+    scroll-margin-top: calc(var(--menu-bar-height) + 0.5em);
+}
+
 .page {
     outline: 0;
     padding: 0 var(--page-padding);
@@ -51,7 +64,7 @@ a.header:target h4:before {
 .page-wrapper {
     box-sizing: border-box;
 }
-.js .page-wrapper {
+.js:not(.sidebar-resizing) .page-wrapper {
     transition: margin-left 0.3s ease, transform 0.3s ease; /* Animation: slide away */
 }
 
@@ -92,6 +105,9 @@ table thead td {
     font-weight: 700;
     border: none;
 }
+table thead th {
+    padding: 3px 20px;
+}
 table thead tr {
     border: 1px var(--table-header-bg) solid;
 }
@@ -141,4 +157,3 @@ blockquote {
 .tooltipped .tooltiptext {
     visibility: visible;
 }
-  

src/theme/css/variables.css

@@ -5,6 +5,7 @@
     --sidebar-width: 300px;
     --page-padding: 15px;
     --content-max-width: 750px;
+    --menu-bar-height: 50px;
 }
 
 /* Themes */
@@ -208,3 +209,45 @@
     --searchresults-li-bg: #dec2a2;
     --search-mark-bg: #e69f67;
 }
+
+@media (prefers-color-scheme: dark) {
+    .light.no-js {
+        --bg: hsl(200, 7%, 8%);
+        --fg: #98a3ad;
+
+        --sidebar-bg: #292c2f;
+        --sidebar-fg: #a1adb8;
+        --sidebar-non-existant: #505254;
+        --sidebar-active: #3473ad;
+        --sidebar-spacer: #393939;
+
+        --scrollbar: var(--sidebar-fg);
+
+        --icons: #43484d;
+        --icons-hover: #b3c0cc;
+
+        --links: #2b79a2;
+
+        --inline-code-color: #c5c8c6;;
+
+        --theme-popup-bg: #141617;
+        --theme-popup-border: #43484d;
+        --theme-hover: #1f2124;
+
+        --quote-bg: hsl(234, 21%, 18%);
+        --quote-border: hsl(234, 21%, 23%);
+
+        --table-border-color: hsl(200, 7%, 13%);
+        --table-header-bg: hsl(200, 7%, 28%);
+        --table-alternate-bg: hsl(200, 7%, 11%);
+
+        --searchbar-border-color: #aaa;
+        --searchbar-bg: #b7b7b7;
+        --searchbar-fg: #000;
+        --searchbar-shadow-color: #aaa;
+        --searchresults-header-fg: #666;
+        --searchresults-border-color: #98a3ad;
+        --searchresults-li-bg: #2b2b2f;
+        --search-mark-bg: #355c7d;
+    }
+}

src/theme/highlight.css

@@ -67,3 +67,13 @@
 .hljs-strong {
   font-weight: bold;
 }
+
+.hljs-addition {
+  color: #22863a;
+  background-color: #f0fff4;
+}
+
+.hljs-deletion {
+  color: #b31d28;
+  background-color: #ffeef0;
+}

src/theme/index.hbs

@@ -1,9 +1,13 @@
 <!DOCTYPE HTML>
-<html lang="{{ language }}" class="sidebar-visible no-js">
+<html lang="{{ language }}" class="sidebar-visible no-js {{ default_theme }}">
     <head>
         <!-- Book generated using mdBook -->
         <meta charset="UTF-8">
         <title>{{ title }}</title>
+        {{#if is_print }}
+        <meta name="robots" content="noindex" />
+        {{/if}}
+
         <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
         <meta name="description" content="{{ description }}">
         <meta name="viewport" content="width=device-width, initial-scale=1">
@@ -35,9 +39,12 @@
         <script async type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
         {{/if}}
     </head>
-    <body class="light">
+    <body>
         <!-- Provide site root to javascript -->
-        <script type="text/javascript">var path_to_root = "{{ path_to_root }}";</script>
+        <script type="text/javascript">
+            var path_to_root = "{{ path_to_root }}";
+            var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "{{ preferred_dark_theme }}" : "{{ default_theme }}";
+        </script>
 
         <!-- Work around some values being stored in localStorage wrapped in quotes -->
         <script type="text/javascript">
@@ -58,10 +65,13 @@
         <!-- Set the theme before any content is loaded, prevents flash -->
         <script type="text/javascript">
             var theme;
-            try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { } 
-            if (theme === null || theme === undefined) { theme = 'light'; }
-            document.body.className = theme;
-            document.querySelector('html').className = theme + ' js';
+            try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
+            if (theme === null || theme === undefined) { theme = default_theme; }
+            var html = document.querySelector('html');
+            html.classList.remove('no-js')
+            html.classList.remove('{{ default_theme }}')
+            html.classList.add(theme);
+            html.classList.add('js');
         </script>
 
         <!-- Hide / unhide sidebar before it is displayed -->
@@ -77,7 +87,10 @@
         </script>
 
         <nav id="sidebar" class="sidebar" aria-label="Table of contents">
-            {{#toc}}{{/toc}}
+            <div id="sidebar-scrollbox" class="sidebar-scrollbox">
+                {{#toc}}{{/toc}}
+            </div>
+            <div id="sidebar-resize-handle" class="sidebar-resize-handle"></div>
         </nav>
 
         <div id="page-wrapper" class="page-wrapper">
@@ -94,11 +107,11 @@
                                 <i class="fa fa-paint-brush"></i>
                             </button>
                             <ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
-                                <li role="none"><button role="menuitem" class="theme" id="light">Light <span class="default">(default)</span></button></li>
-                                <li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
-                                <li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
-                                <li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
-                                <li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
+                                <li role="none"><button role="menuitem" class="theme" id="light">{{ theme_option "Light" }}</button></li>
+                                <li role="none"><button role="menuitem" class="theme" id="rust">{{ theme_option "Rust" }}</button></li>
+                                <li role="none"><button role="menuitem" class="theme" id="coal">{{ theme_option "Coal" }}</button></li>
+                                <li role="none"><button role="menuitem" class="theme" id="navy">{{ theme_option "Navy" }}</button></li>
+                                <li role="none"><button role="menuitem" class="theme" id="ayu">{{ theme_option "Ayu" }}</button></li>
                             </ul>
                             {{#if search_enabled}}
                             <button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
@@ -107,12 +120,17 @@
                             {{/if}}
                         </div>
 
-                        <h1 class="menu-title">{{ book_title }}</h1> 
+                        <h1 class="menu-title">{{ book_title }}</h1>
 
                         <div class="right-buttons">
                             <a href="{{ path_to_root }}print.html" title="Print this book" aria-label="Print this book">
                                 <i id="print-button" class="fa fa-print"></i>
                             </a>
+                            {{#if git_repository_url}}
+                            <a href="{{git_repository_url}}" title="Git repository" aria-label="Git repository">
+                                <i id="git-repository-button" class="fa {{git_repository_icon}}"></i>
+                            </a>
+                            {{/if}}
                         </div>
                     </div>
                 </div>
@@ -215,6 +233,18 @@
         </script>
         {{/if}}
 
+        {{#if playpen_line_numbers}}
+        <script type="text/javascript">
+            window.playpen_line_numbers = true;
+        </script>
+        {{/if}}
+        
+        {{#if playpen_copyable}}
+        <script type="text/javascript">
+            window.playpen_copyable = true;
+        </script>
+        {{/if}}
+
         {{#if playpen_js}}
         <script src="{{ path_to_root }}ace.js" type="text/javascript" charset="utf-8"></script>
         <script src="{{ path_to_root }}editor.js" type="text/javascript" charset="utf-8"></script>

src/theme/mod.rs

@@ -9,33 +9,29 @@ use std::fs::File;
 use std::io::Read;
 use std::path::Path;
 
-use errors::*;
+use crate::errors::*;
 
-pub static INDEX: &'static [u8] = include_bytes!("index.hbs");
-pub static HEADER: &'static [u8] = include_bytes!("header.hbs");
-pub static CHROME_CSS: &'static [u8] = include_bytes!("css/chrome.css");
-pub static GENERAL_CSS: &'static [u8] = include_bytes!("css/general.css");
-pub static PRINT_CSS: &'static [u8] = include_bytes!("css/print.css");
-pub static VARIABLES_CSS: &'static [u8] = include_bytes!("css/variables.css");
-pub static FAVICON: &'static [u8] = include_bytes!("favicon.png");
-pub static JS: &'static [u8] = include_bytes!("book.js");
-pub static HIGHLIGHT_JS: &'static [u8] = include_bytes!("highlight.js");
-pub static TOMORROW_NIGHT_CSS: &'static [u8] = include_bytes!("tomorrow-night.css");
-pub static HIGHLIGHT_CSS: &'static [u8] = include_bytes!("highlight.css");
-pub static AYU_HIGHLIGHT_CSS: &'static [u8] = include_bytes!("ayu-highlight.css");
-pub static CLIPBOARD_JS: &'static [u8] = include_bytes!("clipboard.min.js");
-pub static FONT_AWESOME: &'static [u8] = include_bytes!("FontAwesome/css/font-awesome.min.css");
-pub static FONT_AWESOME_EOT: &'static [u8] =
-    include_bytes!("FontAwesome/fonts/fontawesome-webfont.eot");
-pub static FONT_AWESOME_SVG: &'static [u8] =
-    include_bytes!("FontAwesome/fonts/fontawesome-webfont.svg");
-pub static FONT_AWESOME_TTF: &'static [u8] =
-    include_bytes!("FontAwesome/fonts/fontawesome-webfont.ttf");
-pub static FONT_AWESOME_WOFF: &'static [u8] =
-    include_bytes!("FontAwesome/fonts/fontawesome-webfont.woff");
-pub static FONT_AWESOME_WOFF2: &'static [u8] =
+pub static INDEX: &[u8] = include_bytes!("index.hbs");
+pub static HEADER: &[u8] = include_bytes!("header.hbs");
+pub static CHROME_CSS: &[u8] = include_bytes!("css/chrome.css");
+pub static GENERAL_CSS: &[u8] = include_bytes!("css/general.css");
+pub static PRINT_CSS: &[u8] = include_bytes!("css/print.css");
+pub static VARIABLES_CSS: &[u8] = include_bytes!("css/variables.css");
+pub static FAVICON: &[u8] = include_bytes!("favicon.png");
+pub static JS: &[u8] = include_bytes!("book.js");
+pub static HIGHLIGHT_JS: &[u8] = include_bytes!("highlight.js");
+pub static TOMORROW_NIGHT_CSS: &[u8] = include_bytes!("tomorrow-night.css");
+pub static HIGHLIGHT_CSS: &[u8] = include_bytes!("highlight.css");
+pub static AYU_HIGHLIGHT_CSS: &[u8] = include_bytes!("ayu-highlight.css");
+pub static CLIPBOARD_JS: &[u8] = include_bytes!("clipboard.min.js");
+pub static FONT_AWESOME: &[u8] = include_bytes!("FontAwesome/css/font-awesome.min.css");
+pub static FONT_AWESOME_EOT: &[u8] = include_bytes!("FontAwesome/fonts/fontawesome-webfont.eot");
+pub static FONT_AWESOME_SVG: &[u8] = include_bytes!("FontAwesome/fonts/fontawesome-webfont.svg");
+pub static FONT_AWESOME_TTF: &[u8] = include_bytes!("FontAwesome/fonts/fontawesome-webfont.ttf");
+pub static FONT_AWESOME_WOFF: &[u8] = include_bytes!("FontAwesome/fonts/fontawesome-webfont.woff");
+pub static FONT_AWESOME_WOFF2: &[u8] =
     include_bytes!("FontAwesome/fonts/fontawesome-webfont.woff2");
-pub static FONT_AWESOME_OTF: &'static [u8] = include_bytes!("FontAwesome/fonts/FontAwesome.otf");
+pub static FONT_AWESOME_OTF: &[u8] = include_bytes!("FontAwesome/fonts/FontAwesome.otf");
 
 /// The `Theme` struct should be used instead of the static variables because
 /// the `new()` method will look if the user has a theme directory in their

src/theme/playpen_editor/editor.js

@@ -6,14 +6,16 @@ window.editors = [];
     }
 
     Array.from(document.querySelectorAll('.editable')).forEach(function(editable) {
+        let display_line_numbers = window.playpen_line_numbers || false;
+
         let editor = ace.edit(editable);
             editor.setOptions({
             highlightActiveLine: false,
             showPrintMargin: false,
-            showLineNumbers: false,
-            showGutter: false,
+            showLineNumbers: display_line_numbers,
+            showGutter: display_line_numbers,
             maxLines: Infinity,
-            fontSize: "0.875em" // please adjust the font size of the code in general.styl
+            fontSize: "0.875em" // please adjust the font size of the code in general.css
         });
 
         editor.$blockScrolling = Infinity;

src/theme/playpen_editor/mod.rs

@@ -1,7 +1,7 @@
 //! Theme dependencies for the playpen editor.
 
-pub static JS: &'static [u8] = include_bytes!("editor.js");
-pub static ACE_JS: &'static [u8] = include_bytes!("ace.js");
-pub static MODE_RUST_JS: &'static [u8] = include_bytes!("mode-rust.js");
-pub static THEME_DAWN_JS: &'static [u8] = include_bytes!("theme-dawn.js");
-pub static THEME_TOMORROW_NIGHT_JS: &'static [u8] = include_bytes!("theme-tomorrow_night.js");
+pub static JS: &[u8] = include_bytes!("editor.js");
+pub static ACE_JS: &[u8] = include_bytes!("ace.js");
+pub static MODE_RUST_JS: &[u8] = include_bytes!("mode-rust.js");
+pub static THEME_DAWN_JS: &[u8] = include_bytes!("theme-dawn.js");
+pub static THEME_TOMORROW_NIGHT_JS: &[u8] = include_bytes!("theme-tomorrow_night.js");

src/theme/playpen_editor/theme-dawn.js

@@ -1 +1,7 @@
-ace.define("ace/theme/dawn",["require","exports","module","ace/lib/dom"],function(e,t,n){t.isDark=!1,t.cssClass="ace-dawn",t.cssText=".ace-dawn .ace_gutter {background: #ebebeb;color: #333}.ace-dawn .ace_print-margin {width: 1px;background: #e8e8e8}.ace-dawn {background-color: #F9F9F9;color: #080808}.ace-dawn .ace_cursor {color: #000000}.ace-dawn .ace_marker-layer .ace_selection {background: rgba(39, 95, 255, 0.30)}.ace-dawn.ace_multiselect .ace_selection.ace_start {box-shadow: 0 0 3px 0px #F9F9F9;}.ace-dawn .ace_marker-layer .ace_step {background: rgb(255, 255, 0)}.ace-dawn .ace_marker-layer .ace_bracket {margin: -1px 0 0 -1px;border: 1px solid rgba(75, 75, 126, 0.50)}.ace-dawn .ace_marker-layer .ace_active-line {background: rgba(36, 99, 180, 0.12)}.ace-dawn .ace_gutter-active-line {background-color : #dcdcdc}.ace-dawn .ace_marker-layer .ace_selected-word {border: 1px solid rgba(39, 95, 255, 0.30)}.ace-dawn .ace_invisible {color: rgba(75, 75, 126, 0.50)}.ace-dawn .ace_keyword,.ace-dawn .ace_meta {color: #794938}.ace-dawn .ace_constant,.ace-dawn .ace_constant.ace_character,.ace-dawn .ace_constant.ace_character.ace_escape,.ace-dawn .ace_constant.ace_other {color: #811F24}.ace-dawn .ace_invalid.ace_illegal {text-decoration: underline;font-style: italic;color: #F8F8F8;background-color: #B52A1D}.ace-dawn .ace_invalid.ace_deprecated {text-decoration: underline;font-style: italic;color: #B52A1D}.ace-dawn .ace_support {color: #691C97}.ace-dawn .ace_support.ace_constant {color: #B4371F}.ace-dawn .ace_fold {background-color: #794938;border-color: #080808}.ace-dawn .ace_list,.ace-dawn .ace_markup.ace_list,.ace-dawn .ace_support.ace_function {color: #693A17}.ace-dawn .ace_storage {font-style: italic;color: #A71D5D}.ace-dawn .ace_string {color: #0B6125}.ace-dawn .ace_string.ace_regexp {color: #CF5628}.ace-dawn .ace_comment {font-style: italic;color: #5A525F}.ace-dawn .ace_heading,.ace-dawn .ace_markup.ace_heading {color: #19356D}.ace-dawn .ace_variable {color: #234A97}.ace-dawn .ace_indent-guide {background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAEklEQVQImWNgYGBgYLh/5+x/AAizA4hxNNsZAAAAAElFTkSuQmCC) right repeat-y}";var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass)})
+ace.define("ace/theme/dawn",["require","exports","module","ace/lib/dom"],function(e,t,n){t.isDark=!1,t.cssClass="ace-dawn",t.cssText=".ace-dawn .ace_gutter {background: #ebebeb;color: #333}.ace-dawn .ace_print-margin {width: 1px;background: #e8e8e8}.ace-dawn {background-color: #F9F9F9;color: #080808}.ace-dawn .ace_cursor {color: #000000}.ace-dawn .ace_marker-layer .ace_selection {background: rgba(39, 95, 255, 0.30)}.ace-dawn.ace_multiselect .ace_selection.ace_start {box-shadow: 0 0 3px 0px #F9F9F9;}.ace-dawn .ace_marker-layer .ace_step {background: rgb(255, 255, 0)}.ace-dawn .ace_marker-layer .ace_bracket {margin: -1px 0 0 -1px;border: 1px solid rgba(75, 75, 126, 0.50)}.ace-dawn .ace_marker-layer .ace_active-line {background: rgba(36, 99, 180, 0.12)}.ace-dawn .ace_gutter-active-line {background-color : #dcdcdc}.ace-dawn .ace_marker-layer .ace_selected-word {border: 1px solid rgba(39, 95, 255, 0.30)}.ace-dawn .ace_invisible {color: rgba(75, 75, 126, 0.50)}.ace-dawn .ace_keyword,.ace-dawn .ace_meta {color: #794938}.ace-dawn .ace_constant,.ace-dawn .ace_constant.ace_character,.ace-dawn .ace_constant.ace_character.ace_escape,.ace-dawn .ace_constant.ace_other {color: #811F24}.ace-dawn .ace_invalid.ace_illegal {text-decoration: underline;font-style: italic;color: #F8F8F8;background-color: #B52A1D}.ace-dawn .ace_invalid.ace_deprecated {text-decoration: underline;font-style: italic;color: #B52A1D}.ace-dawn .ace_support {color: #691C97}.ace-dawn .ace_support.ace_constant {color: #B4371F}.ace-dawn .ace_fold {background-color: #794938;border-color: #080808}.ace-dawn .ace_list,.ace-dawn .ace_markup.ace_list,.ace-dawn .ace_support.ace_function {color: #693A17}.ace-dawn .ace_storage {font-style: italic;color: #A71D5D}.ace-dawn .ace_string {color: #0B6125}.ace-dawn .ace_string.ace_regexp {color: #CF5628}.ace-dawn .ace_comment {font-style: italic;color: #5A525F}.ace-dawn .ace_heading,.ace-dawn .ace_markup.ace_heading {color: #19356D}.ace-dawn .ace_variable {color: #234A97}.ace-dawn .ace_indent-guide {background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAEklEQVQImWNgYGBgYLh/5+x/AAizA4hxNNsZAAAAAElFTkSuQmCC) right repeat-y}";var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass)});                (function() {
+                    ace.require(["ace/theme/dawn"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();

src/theme/playpen_editor/theme-tomorrow_night.js

@@ -1 +1,7 @@
-ace.define("ace/theme/tomorrow_night",["require","exports","module","ace/lib/dom"],function(e,t,n){t.isDark=!0,t.cssClass="ace-tomorrow-night",t.cssText=".ace-tomorrow-night .ace_gutter {background: #25282c;color: #C5C8C6}.ace-tomorrow-night .ace_print-margin {width: 1px;background: #25282c}.ace-tomorrow-night {background-color: #1D1F21;color: #C5C8C6}.ace-tomorrow-night .ace_cursor {color: #AEAFAD}.ace-tomorrow-night .ace_marker-layer .ace_selection {background: #373B41}.ace-tomorrow-night.ace_multiselect .ace_selection.ace_start {box-shadow: 0 0 3px 0px #1D1F21;}.ace-tomorrow-night .ace_marker-layer .ace_step {background: rgb(102, 82, 0)}.ace-tomorrow-night .ace_marker-layer .ace_bracket {margin: -1px 0 0 -1px;border: 1px solid #4B4E55}.ace-tomorrow-night .ace_marker-layer .ace_active-line {background: #282A2E}.ace-tomorrow-night .ace_gutter-active-line {background-color: #282A2E}.ace-tomorrow-night .ace_marker-layer .ace_selected-word {border: 1px solid #373B41}.ace-tomorrow-night .ace_invisible {color: #4B4E55}.ace-tomorrow-night .ace_keyword,.ace-tomorrow-night .ace_meta,.ace-tomorrow-night .ace_storage,.ace-tomorrow-night .ace_storage.ace_type,.ace-tomorrow-night .ace_support.ace_type {color: #B294BB}.ace-tomorrow-night .ace_keyword.ace_operator {color: #8ABEB7}.ace-tomorrow-night .ace_constant.ace_character,.ace-tomorrow-night .ace_constant.ace_language,.ace-tomorrow-night .ace_constant.ace_numeric,.ace-tomorrow-night .ace_keyword.ace_other.ace_unit,.ace-tomorrow-night .ace_support.ace_constant,.ace-tomorrow-night .ace_variable.ace_parameter {color: #DE935F}.ace-tomorrow-night .ace_constant.ace_other {color: #CED1CF}.ace-tomorrow-night .ace_invalid {color: #CED2CF;background-color: #DF5F5F}.ace-tomorrow-night .ace_invalid.ace_deprecated {color: #CED2CF;background-color: #B798BF}.ace-tomorrow-night .ace_fold {background-color: #81A2BE;border-color: #C5C8C6}.ace-tomorrow-night .ace_entity.ace_name.ace_function,.ace-tomorrow-night .ace_support.ace_function,.ace-tomorrow-night .ace_variable {color: #81A2BE}.ace-tomorrow-night .ace_support.ace_class,.ace-tomorrow-night .ace_support.ace_type {color: #F0C674}.ace-tomorrow-night .ace_heading,.ace-tomorrow-night .ace_markup.ace_heading,.ace-tomorrow-night .ace_string {color: #B5BD68}.ace-tomorrow-night .ace_entity.ace_name.ace_tag,.ace-tomorrow-night .ace_entity.ace_other.ace_attribute-name,.ace-tomorrow-night .ace_meta.ace_tag,.ace-tomorrow-night .ace_string.ace_regexp,.ace-tomorrow-night .ace_variable {color: #CC6666}.ace-tomorrow-night .ace_comment {color: #969896}.ace-tomorrow-night .ace_indent-guide {background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAEklEQVQImWNgYGBgYHB3d/8PAAOIAdULw8qMAAAAAElFTkSuQmCC) right repeat-y}";var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass)})
+ace.define("ace/theme/tomorrow_night",["require","exports","module","ace/lib/dom"],function(e,t,n){t.isDark=!0,t.cssClass="ace-tomorrow-night",t.cssText=".ace-tomorrow-night .ace_gutter {background: #25282c;color: #C5C8C6}.ace-tomorrow-night .ace_print-margin {width: 1px;background: #25282c}.ace-tomorrow-night {background-color: #1D1F21;color: #C5C8C6}.ace-tomorrow-night .ace_cursor {color: #AEAFAD}.ace-tomorrow-night .ace_marker-layer .ace_selection {background: #373B41}.ace-tomorrow-night.ace_multiselect .ace_selection.ace_start {box-shadow: 0 0 3px 0px #1D1F21;}.ace-tomorrow-night .ace_marker-layer .ace_step {background: rgb(102, 82, 0)}.ace-tomorrow-night .ace_marker-layer .ace_bracket {margin: -1px 0 0 -1px;border: 1px solid #4B4E55}.ace-tomorrow-night .ace_marker-layer .ace_active-line {background: #282A2E}.ace-tomorrow-night .ace_gutter-active-line {background-color: #282A2E}.ace-tomorrow-night .ace_marker-layer .ace_selected-word {border: 1px solid #373B41}.ace-tomorrow-night .ace_invisible {color: #4B4E55}.ace-tomorrow-night .ace_keyword,.ace-tomorrow-night .ace_meta,.ace-tomorrow-night .ace_storage,.ace-tomorrow-night .ace_storage.ace_type,.ace-tomorrow-night .ace_support.ace_type {color: #B294BB}.ace-tomorrow-night .ace_keyword.ace_operator {color: #8ABEB7}.ace-tomorrow-night .ace_constant.ace_character,.ace-tomorrow-night .ace_constant.ace_language,.ace-tomorrow-night .ace_constant.ace_numeric,.ace-tomorrow-night .ace_keyword.ace_other.ace_unit,.ace-tomorrow-night .ace_support.ace_constant,.ace-tomorrow-night .ace_variable.ace_parameter {color: #DE935F}.ace-tomorrow-night .ace_constant.ace_other {color: #CED1CF}.ace-tomorrow-night .ace_invalid {color: #CED2CF;background-color: #DF5F5F}.ace-tomorrow-night .ace_invalid.ace_deprecated {color: #CED2CF;background-color: #B798BF}.ace-tomorrow-night .ace_fold {background-color: #81A2BE;border-color: #C5C8C6}.ace-tomorrow-night .ace_entity.ace_name.ace_function,.ace-tomorrow-night .ace_support.ace_function,.ace-tomorrow-night .ace_variable {color: #81A2BE}.ace-tomorrow-night .ace_support.ace_class,.ace-tomorrow-night .ace_support.ace_type {color: #F0C674}.ace-tomorrow-night .ace_heading,.ace-tomorrow-night .ace_markup.ace_heading,.ace-tomorrow-night .ace_string {color: #B5BD68}.ace-tomorrow-night .ace_entity.ace_name.ace_tag,.ace-tomorrow-night .ace_entity.ace_other.ace_attribute-name,.ace-tomorrow-night .ace_meta.ace_tag,.ace-tomorrow-night .ace_string.ace_regexp,.ace-tomorrow-night .ace_variable {color: #CC6666}.ace-tomorrow-night .ace_comment {color: #969896}.ace-tomorrow-night .ace_indent-guide {background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAEklEQVQImWNgYGBgYHB3d/8PAAOIAdULw8qMAAAAAElFTkSuQmCC) right repeat-y}";var r=e("../lib/dom");r.importCssString(t.cssText,t.cssClass)});                (function() {
+                    ace.require(["ace/theme/tomorrow_night"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();

src/theme/searcher/mod.rs

@@ -1,6 +1,6 @@
 //! Theme dependencies for in-browser search. Not included in mdbook when
 //! the "search" cargo feature is disabled.
 
-pub static JS: &'static [u8] = include_bytes!("searcher.js");
-pub static MARK_JS: &'static [u8] = include_bytes!("mark.min.js");
-pub static ELASTICLUNR_JS: &'static [u8] = include_bytes!("elasticlunr.min.js");
+pub static JS: &[u8] = include_bytes!("searcher.js");
+pub static MARK_JS: &[u8] = include_bytes!("mark.min.js");
+pub static ELASTICLUNR_JS: &[u8] = include_bytes!("elasticlunr.min.js");

src/theme/tomorrow-night.css

@@ -94,3 +94,11 @@
 .xml .hljs-cdata {
   opacity: 0.5;
 }
+
+.hljs-addition {
+  color: #718c00;
+}
+
+.hljs-deletion {
+  color: #c82829;
+}

src/utils/fs.rs

@@ -1,21 +1,9 @@
-use errors::*;
+use crate::errors::*;
+use std::convert::Into;
 use std::fs::{self, File};
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::{Component, Path, PathBuf};
 
-/// Takes a path to a file and try to read the file into a String
-pub fn file_to_string<P: AsRef<Path>>(path: P) -> Result<String> {
-    let path = path.as_ref();
-
-    let mut content = String::new();
-    File::open(path)
-        .chain_err(|| "Unable to open the file")?
-        .read_to_string(&mut content)
-        .chain_err(|| "Unable to read the file")?;
-
-    Ok(content)
-}
-
 /// Naively replaces any path seperator with a forward-slash '/'
 pub fn normalize_path(path: &str) -> String {
     use std::path::is_separator;
@@ -28,7 +16,7 @@ pub fn normalize_path(path: &str) -> String {
 pub fn write_file<P: AsRef<Path>>(build_dir: &Path, filename: P, content: &[u8]) -> Result<()> {
     let path = build_dir.join(filename);
 
-    create_file(&path)?.write_all(content).map_err(|e| e.into())
+    create_file(&path)?.write_all(content).map_err(Into::into)
 }
 
 /// Takes a path and returns a path containing just enough `../` to point to
@@ -38,8 +26,6 @@ pub fn write_file<P: AsRef<Path>>(build_dir: &Path, filename: P, content: &[u8])
 /// directory from where the path starts.
 ///
 /// ```rust
-/// # extern crate mdbook;
-/// #
 /// # use std::path::Path;
 /// # use mdbook::utils::fs::path_to_root;
 /// #
@@ -51,8 +37,8 @@ pub fn write_file<P: AsRef<Path>>(build_dir: &Path, filename: P, content: &[u8])
 ///
 /// **note:** it's not very fool-proof, if you find a situation where
 /// it doesn't return the correct path.
-/// Consider [submitting a new issue](https://github.com/rust-lang-nursery/mdBook/issues)
-/// or a [pull-request](https://github.com/rust-lang-nursery/mdBook/pulls) to improve it.
+/// Consider [submitting a new issue](https://github.com/rust-lang/mdBook/issues)
+/// or a [pull-request](https://github.com/rust-lang/mdBook/pulls) to improve it.
 pub fn path_to_root<P: Into<PathBuf>>(path: P) -> String {
     debug!("path_to_root");
     // Remove filename and add "../" for every directory
@@ -85,7 +71,7 @@ pub fn create_file(path: &Path) -> Result<File> {
         fs::create_dir_all(p)?;
     }
 
-    File::create(path).map_err(|e| e.into())
+    File::create(path).map_err(Into::into)
 }
 
 /// Removes all the content of a directory but not the directory itself
@@ -187,8 +173,6 @@ pub fn copy_files_except_ext(
 
 #[cfg(test)]
 mod tests {
-    extern crate tempfile;
-
     use super::copy_files_except_ext;
     use std::fs;
 
@@ -196,43 +180,44 @@ mod tests {
     fn copy_files_except_ext_test() {
         let tmp = match tempfile::TempDir::new() {
             Ok(t) => t,
-            Err(_) => panic!("Could not create a temp dir"),
+            Err(e) => panic!("Could not create a temp dir: {}", e),
         };
 
         // Create a couple of files
-        if let Err(_) = fs::File::create(&tmp.path().join("file.txt")) {
-            panic!("Could not create file.txt")
+        if let Err(err) = fs::File::create(&tmp.path().join("file.txt")) {
+            panic!("Could not create file.txt: {}", err);
         }
-        if let Err(_) = fs::File::create(&tmp.path().join("file.md")) {
-            panic!("Could not create file.md")
+        if let Err(err) = fs::File::create(&tmp.path().join("file.md")) {
+            panic!("Could not create file.md: {}", err);
         }
-        if let Err(_) = fs::File::create(&tmp.path().join("file.png")) {
-            panic!("Could not create file.png")
+        if let Err(err) = fs::File::create(&tmp.path().join("file.png")) {
+            panic!("Could not create file.png: {}", err);
         }
-        if let Err(_) = fs::create_dir(&tmp.path().join("sub_dir")) {
-            panic!("Could not create sub_dir")
+        if let Err(err) = fs::create_dir(&tmp.path().join("sub_dir")) {
+            panic!("Could not create sub_dir: {}", err);
         }
-        if let Err(_) = fs::File::create(&tmp.path().join("sub_dir/file.png")) {
-            panic!("Could not create sub_dir/file.png")
+        if let Err(err) = fs::File::create(&tmp.path().join("sub_dir/file.png")) {
+            panic!("Could not create sub_dir/file.png: {}", err);
         }
-        if let Err(_) = fs::create_dir(&tmp.path().join("sub_dir_exists")) {
-            panic!("Could not create sub_dir_exists")
+        if let Err(err) = fs::create_dir(&tmp.path().join("sub_dir_exists")) {
+            panic!("Could not create sub_dir_exists: {}", err);
         }
-        if let Err(_) = fs::File::create(&tmp.path().join("sub_dir_exists/file.txt")) {
-            panic!("Could not create sub_dir_exists/file.txt")
+        if let Err(err) = fs::File::create(&tmp.path().join("sub_dir_exists/file.txt")) {
+            panic!("Could not create sub_dir_exists/file.txt: {}", err);
         }
 
         // Create output dir
-        if let Err(_) = fs::create_dir(&tmp.path().join("output")) {
-            panic!("Could not create output")
+        if let Err(err) = fs::create_dir(&tmp.path().join("output")) {
+            panic!("Could not create output: {}", err);
         }
-        if let Err(_) = fs::create_dir(&tmp.path().join("output/sub_dir_exists")) {
-            panic!("Could not create output/sub_dir_exists")
+        if let Err(err) = fs::create_dir(&tmp.path().join("output/sub_dir_exists")) {
+            panic!("Could not create output/sub_dir_exists: {}", err);
         }
 
-        match copy_files_except_ext(&tmp.path(), &tmp.path().join("output"), true, &["md"]) {
-            Err(e) => panic!("Error while executing the function:\n{:?}", e),
-            Ok(_) => {}
+        if let Err(e) =
+            copy_files_except_ext(&tmp.path(), &tmp.path().join("output"), true, &["md"])
+        {
+            panic!("Error while executing the function:\n{:?}", e);
         }
 
         // Check if the correct files where created

src/utils/mod.rs

@@ -2,28 +2,32 @@
 
 pub mod fs;
 mod string;
-use errors::Error;
+use crate::errors::Error;
 use regex::Regex;
 
-use pulldown_cmark::{
-    html, Event, Options, Parser, Tag, OPTION_ENABLE_FOOTNOTES, OPTION_ENABLE_TABLES,
-};
+use pulldown_cmark::{html, CowStr, Event, Options, Parser, Tag};
 
 use std::borrow::Cow;
+use std::fmt::Write;
+use std::path::Path;
 
-pub use self::string::{take_lines, RangeArgument};
+pub use self::string::{
+    take_anchored_lines, take_lines, take_rustdoc_include_anchored_lines,
+    take_rustdoc_include_lines,
+};
 
 /// Replaces multiple consecutive whitespace characters with a single space character.
-pub fn collapse_whitespace<'a>(text: &'a str) -> Cow<'a, str> {
+pub fn collapse_whitespace(text: &str) -> Cow<'_, str> {
     lazy_static! {
         static ref RE: Regex = Regex::new(r"\s\s+").unwrap();
     }
     RE.replace_all(text, " ")
 }
 
-/// Convert the given string to a valid HTML element ID
+/// Convert the given string to a valid HTML element ID.
+/// The only restriction is that the ID must not contain any ASCII whitespace.
 pub fn normalize_id(content: &str) -> String {
-    let mut ret = content
+    content
         .chars()
         .filter_map(|ch| {
             if ch.is_alphanumeric() || ch == '_' || ch == '-' {
@@ -33,16 +37,8 @@ pub fn normalize_id(content: &str) -> String {
             } else {
                 None
             }
-        }).collect::<String>();
-    // Ensure that the first character is [A-Za-z]
-    if ret
-        .chars()
-        .next()
-        .map_or(false, |c| !c.is_ascii_alphabetic())
-    {
-        ret.insert(0, 'a');
-    }
-    ret
+        })
+        .collect::<String>()
 }
 
 /// Generate an ID for use with anchors which is derived from a "normalised"
@@ -69,50 +65,124 @@ pub fn id_from_content(content: &str) -> String {
     }
 
     // Remove spaces and hashes indicating a header
-    let trimmed = content.trim().trim_left_matches('#').trim();
+    let trimmed = content.trim().trim_start_matches('#').trim();
 
     normalize_id(trimmed)
 }
 
-fn adjust_links(event: Event) -> Event {
+/// Fix links to the correct location.
+///
+/// This adjusts links, such as turning `.md` extensions to `.html`.
+///
+/// `path` is the path to the page being rendered relative to the root of the
+/// book. This is used for the `print.html` page so that links on the print
+/// page go to the original location. Normal page rendering sets `path` to
+/// None. Ideally, print page links would link to anchors on the print page,
+/// but that is very difficult.
+fn adjust_links<'a>(event: Event<'a>, path: Option<&Path>) -> Event<'a> {
     lazy_static! {
-        static ref HTTP_LINK: Regex = Regex::new("^https?://").unwrap();
-        static ref MD_LINK: Regex = Regex::new("(?P<link>.*).md(?P<anchor>#.*)?").unwrap();
+        static ref SCHEME_LINK: Regex = Regex::new(r"^[a-z][a-z0-9+.-]*:").unwrap();
+        static ref MD_LINK: Regex = Regex::new(r"(?P<link>.*)\.md(?P<anchor>#.*)?").unwrap();
     }
 
-    match event {
-        Event::Start(Tag::Link(dest, title)) => {
-            if !HTTP_LINK.is_match(&dest) {
-                if let Some(caps) = MD_LINK.captures(&dest) {
-                    let mut html_link = [&caps["link"], ".html"].concat();
-
-                    if let Some(anchor) = caps.name("anchor") {
-                        html_link.push_str(anchor.as_str());
-                    }
-
-                    return Event::Start(Tag::Link(Cow::from(html_link), title));
+    fn fix<'a>(dest: CowStr<'a>, path: Option<&Path>) -> CowStr<'a> {
+        if dest.starts_with('#') {
+            // Fragment-only link.
+            if let Some(path) = path {
+                let mut base = path.display().to_string();
+                if base.ends_with(".md") {
+                    base.replace_range(base.len() - 3.., ".html");
+                }
+                return format!("{}{}", base, dest).into();
+            } else {
+                return dest;
+            }
+        }
+        // Don't modify links with schemes like `https`.
+        if !SCHEME_LINK.is_match(&dest) {
+            // This is a relative link, adjust it as necessary.
+            let mut fixed_link = String::new();
+            if let Some(path) = path {
+                let base = path
+                    .parent()
+                    .expect("path can't be empty")
+                    .to_str()
+                    .expect("utf-8 paths only");
+                if !base.is_empty() {
+                    write!(fixed_link, "{}/", base).unwrap();
                 }
             }
 
-            Event::Start(Tag::Link(dest, title))
+            if let Some(caps) = MD_LINK.captures(&dest) {
+                fixed_link.push_str(&caps["link"]);
+                fixed_link.push_str(".html");
+                if let Some(anchor) = caps.name("anchor") {
+                    fixed_link.push_str(anchor.as_str());
+                }
+            } else {
+                fixed_link.push_str(&dest);
+            };
+            return CowStr::from(fixed_link);
         }
+        dest
+    }
+
+    fn fix_html<'a>(html: CowStr<'a>, path: Option<&Path>) -> CowStr<'a> {
+        // This is a terrible hack, but should be reasonably reliable. Nobody
+        // should ever parse a tag with a regex. However, there isn't anything
+        // in Rust that I know of that is suitable for handling partial html
+        // fragments like those generated by pulldown_cmark.
+        //
+        // There are dozens of HTML tags/attributes that contain paths, so
+        // feel free to add more tags if desired; these are the only ones I
+        // care about right now.
+        lazy_static! {
+            static ref HTML_LINK: Regex =
+                Regex::new(r#"(<(?:a|img) [^>]*?(?:src|href)=")([^"]+?)""#).unwrap();
+        }
+
+        HTML_LINK
+            .replace_all(&html, |caps: &regex::Captures<'_>| {
+                let fixed = fix(caps[2].into(), path);
+                format!("{}{}\"", &caps[1], fixed)
+            })
+            .into_owned()
+            .into()
+    }
+
+    match event {
+        Event::Start(Tag::Link(link_type, dest, title)) => {
+            Event::Start(Tag::Link(link_type, fix(dest, path), title))
+        }
+        Event::Start(Tag::Image(link_type, dest, title)) => {
+            Event::Start(Tag::Image(link_type, fix(dest, path), title))
+        }
+        Event::Html(html) => Event::Html(fix_html(html, path)),
         _ => event,
     }
 }
 
 /// Wrapper around the pulldown-cmark parser for rendering markdown to HTML.
 pub fn render_markdown(text: &str, curly_quotes: bool) -> String {
-    let mut s = String::with_capacity(text.len() * 3 / 2);
+    render_markdown_with_path(text, curly_quotes, None)
+}
 
+pub fn new_cmark_parser(text: &str) -> Parser<'_> {
     let mut opts = Options::empty();
-    opts.insert(OPTION_ENABLE_TABLES);
-    opts.insert(OPTION_ENABLE_FOOTNOTES);
+    opts.insert(Options::ENABLE_TABLES);
+    opts.insert(Options::ENABLE_FOOTNOTES);
+    opts.insert(Options::ENABLE_STRIKETHROUGH);
+    opts.insert(Options::ENABLE_TASKLISTS);
+    Parser::new_ext(text, opts)
+}
 
-    let p = Parser::new_ext(text, opts);
+pub fn render_markdown_with_path(text: &str, curly_quotes: bool, path: Option<&Path>) -> String {
+    let mut s = String::with_capacity(text.len() * 3 / 2);
+    let p = new_cmark_parser(text);
     let mut converter = EventQuoteConverter::new(curly_quotes);
     let events = p
         .map(clean_codeblock_headers)
-        .map(adjust_links)
+        .map(|event| adjust_links(event, path))
         .map(|event| converter.convert(event));
 
     html::push_html(&mut s, events);
@@ -127,7 +197,7 @@ struct EventQuoteConverter {
 impl EventQuoteConverter {
     fn new(enabled: bool) -> Self {
         EventQuoteConverter {
-            enabled: enabled,
+            enabled,
             convert_text: true,
         }
     }
@@ -138,28 +208,28 @@ impl EventQuoteConverter {
         }
 
         match event {
-            Event::Start(Tag::CodeBlock(_)) | Event::Start(Tag::Code) => {
+            Event::Start(Tag::CodeBlock(_)) => {
                 self.convert_text = false;
                 event
             }
-            Event::End(Tag::CodeBlock(_)) | Event::End(Tag::Code) => {
+            Event::End(Tag::CodeBlock(_)) => {
                 self.convert_text = true;
                 event
             }
             Event::Text(ref text) if self.convert_text => {
-                Event::Text(Cow::from(convert_quotes_to_curly(text)))
+                Event::Text(CowStr::from(convert_quotes_to_curly(text)))
             }
             _ => event,
         }
     }
 }
 
-fn clean_codeblock_headers(event: Event) -> Event {
+fn clean_codeblock_headers(event: Event<'_>) -> Event<'_> {
     match event {
         Event::Start(Tag::CodeBlock(ref info)) => {
             let info: String = info.chars().filter(|ch| !ch.is_whitespace()).collect();
 
-            Event::Start(Tag::CodeBlock(Cow::from(info)))
+            Event::Start(Tag::CodeBlock(CowStr::from(info)))
         }
         _ => event,
     }
@@ -193,7 +263,8 @@ fn convert_quotes_to_curly(original_text: &str) -> String {
             preceded_by_whitespace = original_char.is_whitespace();
 
             converted_char
-        }).collect()
+        })
+        .collect()
 }
 
 /// Prints a "backtrace" of some `Error`.
@@ -228,6 +299,12 @@ mod tests {
                 render_markdown("[example_anchor](example.md#anchor)", false),
                 "<p><a href=\"example.html#anchor\">example_anchor</a></p>\n"
             );
+
+            // this anchor contains 'md' inside of it
+            assert_eq!(
+                render_markdown("[phantom data](foo.html#phantomdata)", false),
+                "<p><a href=\"foo.html#phantomdata\">phantom data</a></p>\n"
+            );
         }
 
         #[test]
@@ -328,28 +405,42 @@ more text with spaces
 
         #[test]
         fn it_generates_anchors() {
-            assert_eq!(
-                id_from_content("## `--passes`: add more rustdoc passes"),
-                "a--passes-add-more-rustdoc-passes"
-            );
             assert_eq!(
                 id_from_content("## Method-call expressions"),
                 "method-call-expressions"
             );
+            assert_eq!(id_from_content("## **Bold** title"), "bold-title");
+            assert_eq!(id_from_content("## `Code` title"), "code-title");
+        }
+
+        #[test]
+        fn it_generates_anchors_from_non_ascii_initial() {
+            assert_eq!(
+                id_from_content("## `--passes`: add more rustdoc passes"),
+                "--passes-add-more-rustdoc-passes"
+            );
+            assert_eq!(
+                id_from_content("## 中文標題 CJK title"),
+                "中文標題-cjk-title"
+            );
+            assert_eq!(id_from_content("## Über"), "Über");
         }
 
         #[test]
         fn it_normalizes_ids() {
             assert_eq!(
                 normalize_id("`--passes`: add more rustdoc passes"),
-                "a--passes-add-more-rustdoc-passes"
+                "--passes-add-more-rustdoc-passes"
             );
             assert_eq!(
                 normalize_id("Method-call 🐙 expressions \u{1f47c}"),
                 "method-call--expressions-"
             );
-            assert_eq!(normalize_id("_-_12345"), "a_-_12345");
-            assert_eq!(normalize_id("12345"), "a12345");
+            assert_eq!(normalize_id("_-_12345"), "_-_12345");
+            assert_eq!(normalize_id("12345"), "12345");
+            assert_eq!(normalize_id("中文"), "中文");
+            assert_eq!(normalize_id("にほんご"), "にほんご");
+            assert_eq!(normalize_id("한국어"), "한국어");
             assert_eq!(normalize_id(""), "");
         }
     }
@@ -359,18 +450,12 @@ more text with spaces
 
         #[test]
         fn it_converts_single_quotes() {
-            assert_eq!(
-                convert_quotes_to_curly("'one', 'two'"),
-                "‘one’, ‘two’"
-            );
+            assert_eq!(convert_quotes_to_curly("'one', 'two'"), "‘one’, ‘two’");
         }
 
         #[test]
         fn it_converts_double_quotes() {
-            assert_eq!(
-                convert_quotes_to_curly(r#""one", "two""#),
-                "“one”, “two”"
-            );
+            assert_eq!(convert_quotes_to_curly(r#""one", "two""#), "“one”, “two”");
         }
 
         #[test]

src/utils/string.rs

@@ -1,63 +1,124 @@
 use itertools::Itertools;
-use std::ops::{Range, RangeFrom, RangeFull, RangeTo};
-
-// This trait is already contained in the standard lib, however it is unstable.
-// TODO: Remove when the `collections_range` feature stabilises
-// (https://github.com/rust-lang/rust/issues/30877)
-pub trait RangeArgument<T: ?Sized> {
-    fn start(&self) -> Option<&T>;
-    fn end(&self) -> Option<&T>;
-}
-
-impl<T: ?Sized> RangeArgument<T> for RangeFull {
-    fn start(&self) -> Option<&T> {
-        None
-    }
-    fn end(&self) -> Option<&T> {
-        None
-    }
-}
-
-impl<T> RangeArgument<T> for RangeFrom<T> {
-    fn start(&self) -> Option<&T> {
-        Some(&self.start)
-    }
-    fn end(&self) -> Option<&T> {
-        None
-    }
-}
-
-impl<T> RangeArgument<T> for RangeTo<T> {
-    fn start(&self) -> Option<&T> {
-        None
-    }
-    fn end(&self) -> Option<&T> {
-        Some(&self.end)
-    }
-}
-
-impl<T> RangeArgument<T> for Range<T> {
-    fn start(&self) -> Option<&T> {
-        Some(&self.start)
-    }
-    fn end(&self) -> Option<&T> {
-        Some(&self.end)
-    }
-}
+use regex::Regex;
+use std::ops::Bound::{Excluded, Included, Unbounded};
+use std::ops::RangeBounds;
 
 /// Take a range of lines from a string.
-pub fn take_lines<R: RangeArgument<usize>>(s: &str, range: R) -> String {
-    let start = *range.start().unwrap_or(&0);
+pub fn take_lines<R: RangeBounds<usize>>(s: &str, range: R) -> String {
+    let start = match range.start_bound() {
+        Excluded(&n) => n + 1,
+        Included(&n) => n,
+        Unbounded => 0,
+    };
     let mut lines = s.lines().skip(start);
-    match range.end() {
-        Some(&end) => lines.take(end.saturating_sub(start)).join("\n"),
-        None => lines.join("\n"),
+    match range.end_bound() {
+        Excluded(end) => lines.take(end.saturating_sub(start)).join("\n"),
+        Included(end) => lines.take((end + 1).saturating_sub(start)).join("\n"),
+        Unbounded => lines.join("\n"),
     }
 }
 
+lazy_static! {
+    static ref ANCHOR_START: Regex = Regex::new(r"ANCHOR:\s*(?P<anchor_name>[\w_-]+)").unwrap();
+    static ref ANCHOR_END: Regex = Regex::new(r"ANCHOR_END:\s*(?P<anchor_name>[\w_-]+)").unwrap();
+}
+
+/// Take anchored lines from a string.
+/// Lines containing anchor are ignored.
+pub fn take_anchored_lines(s: &str, anchor: &str) -> String {
+    let mut retained = Vec::<&str>::new();
+    let mut anchor_found = false;
+
+    for l in s.lines() {
+        if anchor_found {
+            match ANCHOR_END.captures(l) {
+                Some(cap) => {
+                    if &cap["anchor_name"] == anchor {
+                        break;
+                    }
+                }
+                None => {
+                    if !ANCHOR_START.is_match(l) {
+                        retained.push(l);
+                    }
+                }
+            }
+        } else {
+            if let Some(cap) = ANCHOR_START.captures(l) {
+                if &cap["anchor_name"] == anchor {
+                    anchor_found = true;
+                }
+            }
+        }
+    }
+
+    retained.join("\n")
+}
+
+/// Keep lines contained within the range specified as-is.
+/// For any lines not in the range, include them but use `#` at the beginning. This will hide the
+/// lines from initial display but include them when expanding the code snippet or testing with
+/// rustdoc.
+pub fn take_rustdoc_include_lines<R: RangeBounds<usize>>(s: &str, range: R) -> String {
+    let mut output = String::with_capacity(s.len());
+
+    for (index, line) in s.lines().enumerate() {
+        if !range.contains(&index) {
+            output.push_str("# ");
+        }
+        output.push_str(line);
+        output.push_str("\n");
+    }
+    output.pop();
+    output
+}
+
+/// Keep lines between the anchor comments specified as-is.
+/// For any lines not between the anchors, include them but use `#` at the beginning. This will
+/// hide the lines from initial display but include them when expanding the code snippet or testing
+/// with rustdoc.
+pub fn take_rustdoc_include_anchored_lines(s: &str, anchor: &str) -> String {
+    let mut output = String::with_capacity(s.len());
+    let mut within_anchored_section = false;
+
+    for l in s.lines() {
+        if within_anchored_section {
+            match ANCHOR_END.captures(l) {
+                Some(cap) => {
+                    if &cap["anchor_name"] == anchor {
+                        within_anchored_section = false;
+                    }
+                }
+                None => {
+                    if !ANCHOR_START.is_match(l) {
+                        output.push_str(l);
+                        output.push_str("\n");
+                    }
+                }
+            }
+        } else {
+            if let Some(cap) = ANCHOR_START.captures(l) {
+                if &cap["anchor_name"] == anchor {
+                    within_anchored_section = true;
+                }
+            } else if !ANCHOR_END.is_match(l) {
+                output.push_str("# ");
+                output.push_str(l);
+                output.push_str("\n");
+            }
+        }
+    }
+
+    output.pop();
+    output
+}
+
 #[cfg(test)]
 mod tests {
-    use super::take_lines;
+    use super::{
+        take_anchored_lines, take_lines, take_rustdoc_include_anchored_lines,
+        take_rustdoc_include_lines,
+    };
 
     #[test]
     fn take_lines_test() {
@@ -70,4 +131,122 @@ mod tests {
         assert_eq!(take_lines(s, 4..3), "");
         assert_eq!(take_lines(s, ..100), s);
     }
+
+    #[test]
+    fn take_anchored_lines_test() {
+        let s = "Lorem\nipsum\ndolor\nsit\namet";
+        assert_eq!(take_anchored_lines(s, "test"), "");
+
+        let s = "Lorem\nipsum\ndolor\nANCHOR_END: test\nsit\namet";
+        assert_eq!(take_anchored_lines(s, "test"), "");
+
+        let s = "Lorem\nipsum\nANCHOR: test\ndolor\nsit\namet";
+        assert_eq!(take_anchored_lines(s, "test"), "dolor\nsit\namet");
+        assert_eq!(take_anchored_lines(s, "something"), "");
+
+        let s = "Lorem\nipsum\nANCHOR: test\ndolor\nsit\namet\nANCHOR_END: test\nlorem\nipsum";
+        assert_eq!(take_anchored_lines(s, "test"), "dolor\nsit\namet");
+        assert_eq!(take_anchored_lines(s, "something"), "");
+
+        let s = "Lorem\nANCHOR: test\nipsum\nANCHOR: test\ndolor\nsit\namet\nANCHOR_END: test\nlorem\nipsum";
+        assert_eq!(take_anchored_lines(s, "test"), "ipsum\ndolor\nsit\namet");
+        assert_eq!(take_anchored_lines(s, "something"), "");
+
+        let s = "Lorem\nANCHOR:    test2\nipsum\nANCHOR: test\ndolor\nsit\namet\nANCHOR_END: test\nlorem\nANCHOR_END:test2\nipsum";
+        assert_eq!(
+            take_anchored_lines(s, "test2"),
+            "ipsum\ndolor\nsit\namet\nlorem"
+        );
+        assert_eq!(take_anchored_lines(s, "test"), "dolor\nsit\namet");
+        assert_eq!(take_anchored_lines(s, "something"), "");
+    }
+
+    #[test]
+    fn take_rustdoc_include_lines_test() {
+        let s = "Lorem\nipsum\ndolor\nsit\namet";
+        assert_eq!(
+            take_rustdoc_include_lines(s, 1..3),
+            "# Lorem\nipsum\ndolor\n# sit\n# amet"
+        );
+        assert_eq!(
+            take_rustdoc_include_lines(s, 3..),
+            "# Lorem\n# ipsum\n# dolor\nsit\namet"
+        );
+        assert_eq!(
+            take_rustdoc_include_lines(s, ..3),
+            "Lorem\nipsum\ndolor\n# sit\n# amet"
+        );
+        assert_eq!(take_rustdoc_include_lines(s, ..), s);
+        // corner cases
+        assert_eq!(
+            take_rustdoc_include_lines(s, 4..3),
+            "# Lorem\n# ipsum\n# dolor\n# sit\n# amet"
+        );
+        assert_eq!(take_rustdoc_include_lines(s, ..100), s);
+    }
+
+    #[test]
+    fn take_rustdoc_include_anchored_lines_test() {
+        let s = "Lorem\nipsum\ndolor\nsit\namet";
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "test"),
+            "# Lorem\n# ipsum\n# dolor\n# sit\n# amet"
+        );
+
+        let s = "Lorem\nipsum\ndolor\nANCHOR_END: test\nsit\namet";
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "test"),
+            "# Lorem\n# ipsum\n# dolor\n# sit\n# amet"
+        );
+
+        let s = "Lorem\nipsum\nANCHOR: test\ndolor\nsit\namet";
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "test"),
+            "# Lorem\n# ipsum\ndolor\nsit\namet"
+        );
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "something"),
+            "# Lorem\n# ipsum\n# dolor\n# sit\n# amet"
+        );
+
+        let s = "Lorem\nipsum\nANCHOR: test\ndolor\nsit\namet\nANCHOR_END: test\nlorem\nipsum";
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "test"),
+            "# Lorem\n# ipsum\ndolor\nsit\namet\n# lorem\n# ipsum"
+        );
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "something"),
+            "# Lorem\n# ipsum\n# dolor\n# sit\n# amet\n# lorem\n# ipsum"
+        );
+
+        let s = "Lorem\nANCHOR: test\nipsum\nANCHOR: test\ndolor\nsit\namet\nANCHOR_END: test\nlorem\nipsum";
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "test"),
+            "# Lorem\nipsum\ndolor\nsit\namet\n# lorem\n# ipsum"
+        );
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "something"),
+            "# Lorem\n# ipsum\n# dolor\n# sit\n# amet\n# lorem\n# ipsum"
+        );
+
+        let s = "Lorem\nANCHOR:    test2\nipsum\nANCHOR: test\ndolor\nsit\namet\nANCHOR_END: test\nlorem\nANCHOR_END:test2\nipsum";
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "test2"),
+            "# Lorem\nipsum\ndolor\nsit\namet\nlorem\n# ipsum"
+        );
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "test"),
+            "# Lorem\n# ipsum\ndolor\nsit\namet\n# lorem\n# ipsum"
+        );
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "something"),
+            "# Lorem\n# ipsum\n# dolor\n# sit\n# amet\n# lorem\n# ipsum"
+        );
+
+        let s = "Lorem\nANCHOR: test\nipsum\nANCHOR_END: test\ndolor\nANCHOR: test\nsit\nANCHOR_END: test\namet";
+        assert_eq!(
+            take_rustdoc_include_anchored_lines(s, "test"),
+            "# Lorem\nipsum\n# dolor\nsit\n# amet"
+        );
+    }
 }

tests/alternative_backends.rs

@@ -1,7 +1,4 @@
-//! Integration tests to make sure alternate backends work.
-
-extern crate mdbook;
-extern crate tempfile;
+//! Integration tests to make sure alternative backends work.
 
 use mdbook::config::Config;
 use mdbook::MDBook;
@@ -11,14 +8,14 @@ use tempfile::{Builder as TempFileBuilder, TempDir};
 
 #[test]
 fn passing_alternate_backend() {
-    let (md, _temp) = dummy_book_with_backend("passing", "true");
+    let (md, _temp) = dummy_book_with_backend("passing", success_cmd());
 
     md.build().unwrap();
 }
 
 #[test]
 fn failing_alternate_backend() {
-    let (md, _temp) = dummy_book_with_backend("failing", "false");
+    let (md, _temp) = dummy_book_with_backend("failing", fail_cmd());
 
     md.build().unwrap_err();
 }
@@ -84,3 +81,19 @@ fn dummy_book_with_backend(name: &str, command: &str) -> (MDBook, TempDir) {
 
     (md, temp)
 }
+
+fn fail_cmd() -> &'static str {
+    if cfg!(windows) {
+        r#"cmd.exe /c "exit 1""#
+    } else {
+        "false"
+    }
+}
+
+fn success_cmd() -> &'static str {
+    if cfg!(windows) {
+        r#"cmd.exe /c "exit 0""#
+    } else {
+        "true"
+    }
+}

tests/build_process.rs

@@ -1,8 +1,6 @@
-extern crate mdbook;
-
 mod dummy_book;
 
-use dummy_book::DummyBook;
+use crate::dummy_book::DummyBook;
 use mdbook::book::Book;
 use mdbook::config::Config;
 use mdbook::errors::*;
@@ -52,7 +50,7 @@ fn mdbook_runs_preprocessors() {
     let cfg = Config::default();
 
     let mut book = MDBook::load_with_config(temp.path(), cfg).unwrap();
-    book.with_preprecessor(Spy(Arc::clone(&spy)));
+    book.with_preprocessor(Spy(Arc::clone(&spy)));
     book.build().unwrap();
 
     let inner = spy.lock().unwrap();

tests/custom_preprocessors.rs

@@ -1,13 +1,14 @@
-extern crate mdbook;
-
 mod dummy_book;
 
-use dummy_book::DummyBook;
+use crate::dummy_book::DummyBook;
 use mdbook::preprocess::{CmdPreprocessor, Preprocessor};
 use mdbook::MDBook;
 
 fn example() -> CmdPreprocessor {
-    CmdPreprocessor::new("nop-preprocessor".to_string(), "cargo run --example nop-preprocessor --".to_string())
+    CmdPreprocessor::new(
+        "nop-preprocessor".to_string(),
+        "cargo run --example nop-preprocessor --".to_string(),
+    )
 }
 
 #[test]
@@ -33,9 +34,11 @@ fn ask_the_preprocessor_to_blow_up() {
     let dummy_book = DummyBook::new();
     let temp = dummy_book.build().unwrap();
     let mut md = MDBook::load(temp.path()).unwrap();
-    md.with_preprecessor(example());
+    md.with_preprocessor(example());
 
-    md.config.set("preprocessor.nop-preprocessor.blow-up", true).unwrap();
+    md.config
+        .set("preprocessor.nop-preprocessor.blow-up", true)
+        .unwrap();
 
     let got = md.build();
 
@@ -47,7 +50,7 @@ fn process_the_dummy_book() {
     let dummy_book = DummyBook::new();
     let temp = dummy_book.build().unwrap();
     let mut md = MDBook::load(temp.path()).unwrap();
-    md.with_preprecessor(example());
+    md.with_preprocessor(example());
 
     md.build().unwrap();
 }

tests/dummy_book/mod.rs

@@ -3,21 +3,15 @@
 
 // Not all features are used in all test crates, so...
 #![allow(dead_code, unused_variables, unused_imports, unused_extern_crates)]
-extern crate mdbook;
-extern crate tempfile;
-extern crate walkdir;
 
 use mdbook::errors::*;
-use mdbook::utils::fs::file_to_string;
 use std::fs::{self, File};
 use std::io::{Read, Write};
 use std::path::Path;
 
-// The funny `self::` here is because we've got an `extern crate ...` and are
-// in a submodule
-use self::mdbook::MDBook;
-use self::tempfile::{Builder as TempFileBuilder, TempDir};
-use self::walkdir::WalkDir;
+use mdbook::MDBook;
+use tempfile::{Builder as TempFileBuilder, TempDir};
+use walkdir::WalkDir;
 
 /// Create a dummy book in a temporary directory, using the contents of
 /// `SUMMARY_MD` as a guide.
@@ -58,15 +52,24 @@ impl DummyBook {
         })?;
 
         let sub_pattern = if self.passing_test { "true" } else { "false" };
-        let file_containing_test = temp.path().join("src/first/nested.md");
-        replace_pattern_in_file(&file_containing_test, "$TEST_STATUS", sub_pattern)?;
+        let files_containing_tests = [
+            "src/first/nested.md",
+            "src/first/nested-test.rs",
+            "src/first/nested-test-with-anchors.rs",
+            "src/first/partially-included-test.rs",
+            "src/first/partially-included-test-with-anchors.rs",
+        ];
+        for file in &files_containing_tests {
+            let path_containing_tests = temp.path().join(file);
+            replace_pattern_in_file(&path_containing_tests, "$TEST_STATUS", sub_pattern)?;
+        }
 
         Ok(temp)
     }
 }
 
 fn replace_pattern_in_file(filename: &Path, from: &str, to: &str) -> Result<()> {
-    let contents = file_to_string(filename)?;
+    let contents = fs::read_to_string(filename)?;
     File::create(filename)?.write_all(contents.replace(from, to).as_bytes())?;
 
     Ok(())
@@ -76,7 +79,7 @@ fn replace_pattern_in_file(filename: &Path, from: &str, to: &str) -> Result<()>
 /// the list of strings asserting that the file contains all of them.
 pub fn assert_contains_strings<P: AsRef<Path>>(filename: P, strings: &[&str]) {
     let filename = filename.as_ref();
-    let content = file_to_string(filename).expect("Couldn't read the file's contents");
+    let content = fs::read_to_string(filename).expect("Couldn't read the file's contents");
 
     for s in strings {
         assert!(
@@ -91,7 +94,7 @@ pub fn assert_contains_strings<P: AsRef<Path>>(filename: P, strings: &[&str]) {
 
 pub fn assert_doesnt_contain_strings<P: AsRef<Path>>(filename: P, strings: &[&str]) {
     let filename = filename.as_ref();
-    let content = file_to_string(filename).expect("Couldn't read the file's contents");
+    let content = fs::read_to_string(filename).expect("Couldn't read the file's contents");
 
     for s in strings {
         assert!(

tests/dummy_book/src/SUMMARY.md

@@ -1,13 +1,19 @@
 # Summary
 
 [Dummy Book](README.md)
+
+---
+
 [Introduction](intro.md)
 
 - [First Chapter](first/index.md)
     - [Nested Chapter](first/nested.md)
     - [Includes](first/includes.md)
     - [Recursive](first/recursive.md)
+    - [Markdown](first/markdown.md)
+    - [Unicode](first/unicode.md)
 - [Second Chapter](second.md)
+    - [Nested Chapter](second/nested.md)
 
 ---
 

tests/dummy_book/src/first/markdown.md

@@ -0,0 +1,29 @@
+# Markdown tests
+
+Tests for some markdown output.
+
+## Tables
+
+| foo | bar |
+| --- | --- |
+| baz | bim |
+
+## Footnotes
+
+Footnote example[^1], or with a word[^word].
+
+[^1]: This is a footnote.
+
+[^word]: A longer footnote.
+    With multiple lines.
+    Third line.
+
+## Strikethrough
+
+~~strikethrough example~~
+
+## Tasklisks
+
+- [X] Apples
+- [X] Broccoli
+- [ ] Carrots

tests/dummy_book/src/first/nested-test-with-anchors.rs

@@ -0,0 +1,11 @@
+// The next line will cause a `testing` test to fail if the anchor feature is broken in such a way
+// that the whole file gets mistakenly included.
+assert!(!$TEST_STATUS);
+
+// ANCHOR: myanchor
+// ANCHOR: unendinganchor
+// The next line will cause a `rendered_output` test to fail if the anchor feature is broken in
+// such a way that the content between anchors isn't included.
+// unique-string-for-anchor-test
+assert!($TEST_STATUS);
+// ANCHOR_END: myanchor

tests/dummy_book/src/first/nested-test.rs

@@ -0,0 +1 @@
+assert!($TEST_STATUS);

tests/dummy_book/src/first/nested.md

@@ -7,3 +7,25 @@ assert!($TEST_STATUS);
 ```
 
 ## Some Section
+
+```rust
+{{#include nested-test.rs}}
+```
+
+## Anchors include the part of a file between special comments
+
+```rust
+{{#include nested-test-with-anchors.rs:myanchor}}
+```
+
+## Rustdoc include adds the rest of the file as hidden
+
+```rust
+{{#rustdoc_include partially-included-test.rs:5:7}}
+```
+
+## Rustdoc include works with anchors too
+
+```rust
+{{#rustdoc_include partially-included-test-with-anchors.rs:rustdoc-include-anchor}}
+```

tests/dummy_book/src/first/partially-included-test-with-anchors.rs

@@ -0,0 +1,11 @@
+fn some_other_function() {
+    // ANCHOR: unused-anchor-that-should-be-stripped
+    assert!($TEST_STATUS);
+    // ANCHOR_END: unused-anchor-that-should-be-stripped
+}
+
+// ANCHOR: rustdoc-include-anchor
+fn main() {
+    some_other_function();
+}
+// ANCHOR_END: rustdoc-include-anchor

tests/dummy_book/src/first/partially-included-test.rs

@@ -0,0 +1,7 @@
+fn some_function() {
+    assert!($TEST_STATUS);
+}
+
+fn main() {
+    some_function();
+}

tests/dummy_book/src/first/unicode.md

@@ -0,0 +1,21 @@
+# Unicode stress tests
+
+Please be careful editing, this contains carefully crafted characters.
+
+Two byte character: spatiëring
+
+Combining character: spatiëring
+
+Three byte character: 书こんにちは
+
+Four byte character: 𐌀‮𐌁‮𐌂‮𐌃‮𐌄‮𐌅‮𐌆‮𐌇‮𐌈‬
+
+Right-to-left: مرحبا
+
+Emoticons: 🔊 😍 💜 1️⃣
+
+right-to-left mark: hello באמת!‏
+
+
+Zalgo: ǫ̛̖̱̗̝͈̋͒͋̏ͥͫ̒̆ͩ̏͌̾͊͐ͪ̾̚
+