Rustfmt for 2024

examples/remove-emphasis/mdbook-remove-emphasis/src/main.rs

@@ -1,10 +1,10 @@
 //! This is a demonstration of an mdBook preprocessor which parses markdown
 //! and removes any instances of emphasis.
 
+use mdbook::BookItem;
 use mdbook::book::{Book, Chapter};
 use mdbook::errors::Error;
 use mdbook::preprocess::{CmdPreprocessor, Preprocessor, PreprocessorContext};
-use mdbook::BookItem;
 use pulldown_cmark::{Event, Parser, Tag, TagEnd};
 use std::io;
 

src/book/book.rs

@@ -4,7 +4,7 @@ use std::fs::{self, File};
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 
-use super::summary::{parse_summary, Link, SectionNumber, Summary, SummaryItem};
+use super::summary::{Link, SectionNumber, Summary, SummaryItem, parse_summary};
 use crate::config::BuildConfig;
 use crate::errors::*;
 use crate::utils::bracket_escape;

src/book/mod.rs

@@ -9,9 +9,9 @@ mod book;
 mod init;
 mod summary;
 
-pub use self::book::{load_book, Book, BookItem, BookItems, Chapter};
+pub use self::book::{Book, BookItem, BookItems, Chapter, load_book};
 pub use self::init::BookBuilder;
-pub use self::summary::{parse_summary, Link, SectionNumber, Summary, SummaryItem};
+pub use self::summary::{Link, SectionNumber, Summary, SummaryItem, parse_summary};
 
 use log::{debug, error, info, log_enabled, trace, warn};
 use std::ffi::OsString;
@@ -817,9 +817,11 @@ mod tests {
 
         let preprocessors = determine_preprocessors(&cfg).unwrap();
 
-        assert!(!preprocessors
+        assert!(
+            !preprocessors
                 .iter()
-            .any(|preprocessor| preprocessor.name() == "random"));
+                .any(|preprocessor| preprocessor.name() == "random")
+        );
     }
 
     #[test]
@@ -836,9 +838,11 @@ mod tests {
 
         let preprocessors = determine_preprocessors(&cfg).unwrap();
 
-        assert!(!preprocessors
+        assert!(
+            !preprocessors
                 .iter()
-            .any(|preprocessor| preprocessor.name() == "links"));
+                .any(|preprocessor| preprocessor.name() == "links")
+        );
     }
 
     #[test]

src/book/summary.rs

@@ -776,7 +776,10 @@ mod tests {
 
         assert!(got.is_err());
         let error_message = got.err().unwrap().to_string();
-        assert_eq!(error_message, "failed to parse SUMMARY.md line 2, column 1: Suffix chapters cannot be followed by a list");
+        assert_eq!(
+            error_message,
+            "failed to parse SUMMARY.md line 2, column 1: Suffix chapters cannot be followed by a list"
+        );
     }
 
     #[test]
@@ -788,7 +791,10 @@ mod tests {
 
         assert!(got.is_err());
         let error_message = got.err().unwrap().to_string();
-        assert_eq!(error_message, "failed to parse SUMMARY.md line 1, column 0: Suffix chapters cannot be followed by a list");
+        assert_eq!(
+            error_message,
+            "failed to parse SUMMARY.md line 1, column 0: Suffix chapters cannot be followed by a list"
+        );
     }
 
     #[test]

src/cmd/build.rs

@@ -1,7 +1,7 @@
 use super::command_prelude::*;
 use crate::{get_book_dir, open};
-use mdbook::errors::Result;
 use mdbook::MDBook;
+use mdbook::errors::Result;
 use std::path::PathBuf;
 
 // Create clap subcommand arguments

src/cmd/command_prelude.rs

@@ -1,6 +1,6 @@
 //! Helpers for building the command-line arguments for commands.
 
-pub use clap::{arg, Arg, ArgMatches, Command};
+pub use clap::{Arg, ArgMatches, Command, arg};
 use std::path::PathBuf;
 
 pub trait CommandExt: Sized {

src/cmd/init.rs

@@ -1,8 +1,8 @@
 use crate::get_book_dir;
-use clap::{arg, ArgMatches, Command as ClapCommand};
+use clap::{ArgMatches, Command as ClapCommand, arg};
+use mdbook::MDBook;
 use mdbook::config;
 use mdbook::errors::Result;
-use mdbook::MDBook;
 use std::io;
 use std::io::Write;
 use std::process::Command;

src/cmd/serve.rs

@@ -2,15 +2,15 @@ use super::command_prelude::*;
 #[cfg(feature = "watch")]
 use super::watch;
 use crate::{get_book_dir, open};
+use axum::Router;
 use axum::extract::ws::{Message, WebSocket, WebSocketUpgrade};
 use axum::routing::get;
-use axum::Router;
 use clap::builder::NonEmptyStringValueParser;
-use futures_util::sink::SinkExt;
 use futures_util::StreamExt;
+use futures_util::sink::SinkExt;
+use mdbook::MDBook;
 use mdbook::errors::*;
 use mdbook::utils::fs::get_404_output_file;
-use mdbook::MDBook;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
 use tokio::sync::broadcast;

src/cmd/test.rs

@@ -1,9 +1,9 @@
 use super::command_prelude::*;
 use crate::get_book_dir;
-use clap::builder::NonEmptyStringValueParser;
 use clap::ArgAction;
-use mdbook::errors::Result;
+use clap::builder::NonEmptyStringValueParser;
 use mdbook::MDBook;
+use mdbook::errors::Result;
 use std::path::PathBuf;
 
 // Create clap subcommand arguments

src/cmd/watch.rs

@@ -1,7 +1,7 @@
 use super::command_prelude::*;
 use crate::{get_book_dir, open};
-use mdbook::errors::Result;
 use mdbook::MDBook;
+use mdbook::errors::Result;
 use std::path::{Path, PathBuf};
 
 mod native;

src/config.rs

@@ -55,8 +55,8 @@ use std::fs::File;
 use std::io::Read;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
-use toml::value::Table;
 use toml::Value;
+use toml::value::Table;
 
 use crate::errors::*;
 use crate::utils::{self, toml_ext::TomlExt};

src/lib.rs

@@ -101,6 +101,6 @@ pub use crate::renderer::Renderer;
 
 /// The error types used through out this crate.
 pub mod errors {
-    pub(crate) use anyhow::{bail, ensure, Context};
+    pub(crate) use anyhow::{Context, bail, ensure};
     pub use anyhow::{Error, Result};
 }

src/preprocess/links.rs

@@ -684,8 +684,7 @@ mod tests {
 
     #[test]
     fn test_find_playgrounds_with_properties() {
-        let s =
-            "Some random text with escaped playground {{#playground file.rs editable }} and some \
+        let s = "Some random text with escaped playground {{#playground file.rs editable }} and some \
                  more\n text {{#playground my.rs editable no_run should_panic}} ...";
 
         let res = find_links(s).collect::<Vec<_>>();
@@ -714,8 +713,7 @@ mod tests {
 
     #[test]
     fn test_find_all_link_types() {
-        let s =
-            "Some random text with escaped playground {{#include file.rs}} and \\{{#contents are \
+        let s = "Some random text with escaped playground {{#include file.rs}} and \\{{#contents are \
                  insignifficant in escaped link}} some more\n text  {{#playground my.rs editable \
                  no_run should_panic}} ...";
 

src/renderer/html_handlebars/hbs_renderer.rs

@@ -1,8 +1,8 @@
 use crate::book::{Book, BookItem};
 use crate::config::{BookConfig, Code, Config, HtmlConfig, Playground, RustEdition};
 use crate::errors::*;
-use crate::renderer::html_handlebars::helpers;
 use crate::renderer::html_handlebars::StaticFiles;
+use crate::renderer::html_handlebars::helpers;
 use crate::renderer::{RenderContext, Renderer};
 use crate::theme::{self, Theme};
 use crate::utils;
@@ -1066,20 +1066,34 @@ mod tests {
     #[test]
     fn add_playground() {
         let inputs = [
-          ("<code class=\"language-rust\">x()</code>",
-           "<pre class=\"playground\"><code class=\"language-rust\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>"),
-          ("<code class=\"language-rust\">fn main() {}</code>",
-           "<pre class=\"playground\"><code class=\"language-rust\">fn main() {}</code></pre>"),
-          ("<code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code>",
-           "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code></pre>"),
-          ("<code class=\"language-rust editable\">let s = \"foo\n ## bar\n\";</code>",
-           "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n ## bar\n\";</code></pre>"),
-          ("<code class=\"language-rust editable\">let s = \"foo\n # bar\n#\n\";</code>",
-           "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n#\n\";</code></pre>"),
-          ("<code class=\"language-rust ignore\">let s = \"foo\n # bar\n\";</code>",
-           "<code class=\"language-rust ignore\">let s = \"foo\n # bar\n\";</code>"),
-          ("<code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code>",
-           "<pre class=\"playground\"><code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code></pre>"),
+            (
+                "<code class=\"language-rust\">x()</code>",
+                "<pre class=\"playground\"><code class=\"language-rust\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust\">fn main() {}</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code>",
+                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust editable\">let s = \"foo\n ## bar\n\";</code>",
+                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n ## bar\n\";</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust editable\">let s = \"foo\n # bar\n#\n\";</code>",
+                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n#\n\";</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust ignore\">let s = \"foo\n # bar\n\";</code>",
+                "<code class=\"language-rust ignore\">let s = \"foo\n # bar\n\";</code>",
+            ),
+            (
+                "<code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code>",
+                "<pre class=\"playground\"><code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code></pre>",
+            ),
         ];
         for (src, should_be) in &inputs {
             let got = add_playground_pre(
@@ -1096,14 +1110,22 @@ mod tests {
     #[test]
     fn add_playground_edition2015() {
         let inputs = [
-          ("<code class=\"language-rust\">x()</code>",
-           "<pre class=\"playground\"><code class=\"language-rust edition2015\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>"),
-          ("<code class=\"language-rust\">fn main() {}</code>",
-           "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>"),
-          ("<code class=\"language-rust edition2015\">fn main() {}</code>",
-           "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>"),
-          ("<code class=\"language-rust edition2018\">fn main() {}</code>",
-           "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>"),
+            (
+                "<code class=\"language-rust\">x()</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2015\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust edition2015\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust edition2018\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>",
+            ),
         ];
         for (src, should_be) in &inputs {
             let got = add_playground_pre(
@@ -1120,14 +1142,22 @@ mod tests {
     #[test]
     fn add_playground_edition2018() {
         let inputs = [
-          ("<code class=\"language-rust\">x()</code>",
-           "<pre class=\"playground\"><code class=\"language-rust edition2018\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>"),
-          ("<code class=\"language-rust\">fn main() {}</code>",
-           "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>"),
-          ("<code class=\"language-rust edition2015\">fn main() {}</code>",
-           "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>"),
-          ("<code class=\"language-rust edition2018\">fn main() {}</code>",
-           "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>"),
+            (
+                "<code class=\"language-rust\">x()</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2018\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust edition2015\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust edition2018\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>",
+            ),
         ];
         for (src, should_be) in &inputs {
             let got = add_playground_pre(
@@ -1144,14 +1174,22 @@ mod tests {
     #[test]
     fn add_playground_edition2021() {
         let inputs = [
-            ("<code class=\"language-rust\">x()</code>",
-             "<pre class=\"playground\"><code class=\"language-rust edition2021\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>"),
-            ("<code class=\"language-rust\">fn main() {}</code>",
-             "<pre class=\"playground\"><code class=\"language-rust edition2021\">fn main() {}</code></pre>"),
-            ("<code class=\"language-rust edition2015\">fn main() {}</code>",
-             "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>"),
-            ("<code class=\"language-rust edition2018\">fn main() {}</code>",
-             "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>"),
+            (
+                "<code class=\"language-rust\">x()</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2021\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2021\">fn main() {}</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust edition2015\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>",
+            ),
+            (
+                "<code class=\"language-rust edition2018\">fn main() {}</code>",
+                "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>",
+            ),
         ];
         for (src, should_be) in &inputs {
             let got = add_playground_pre(
@@ -1171,29 +1209,37 @@ mod tests {
         let inputs = [
             (
                 "<pre class=\"playground\"><code class=\"language-rust\">\n# #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
-           "<pre class=\"playground\"><code class=\"language-rust\">\n<span class=\"boring\">#![allow(unused)]\n</span><span class=\"boring\">fn main() {\n</span>x()\n<span class=\"boring\">}</span></code></pre>",),
+                "<pre class=\"playground\"><code class=\"language-rust\">\n<span class=\"boring\">#![allow(unused)]\n</span><span class=\"boring\">fn main() {\n</span>x()\n<span class=\"boring\">}</span></code></pre>",
+            ),
             // # must be followed by a space for a line to be hidden
             (
                 "<pre class=\"playground\"><code class=\"language-rust\">\n#fn main() {\nx()\n#}</code></pre>",
-           "<pre class=\"playground\"><code class=\"language-rust\">\n#fn main() {\nx()\n#}</code></pre>",),
+                "<pre class=\"playground\"><code class=\"language-rust\">\n#fn main() {\nx()\n#}</code></pre>",
+            ),
             (
                 "<pre class=\"playground\"><code class=\"language-rust\">fn main() {}</code></pre>",
-           "<pre class=\"playground\"><code class=\"language-rust\">fn main() {}</code></pre>",),
+                "<pre class=\"playground\"><code class=\"language-rust\">fn main() {}</code></pre>",
+            ),
             (
                 "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code></pre>",
-           "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n<span class=\"boring\"> bar\n</span>\";</code></pre>",),
+                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n<span class=\"boring\"> bar\n</span>\";</code></pre>",
+            ),
             (
                 "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n ## bar\n\";</code></pre>",
-           "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code></pre>",),
+                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code></pre>",
+            ),
             (
                 "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n#\n\";</code></pre>",
-           "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n<span class=\"boring\"> bar\n</span><span class=\"boring\">\n</span>\";</code></pre>",),
+                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n<span class=\"boring\"> bar\n</span><span class=\"boring\">\n</span>\";</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>\";</code>",),
+                "<code class=\"language-rust ignore\">let s = \"foo\n<span class=\"boring\"> bar\n</span>\";</code>",
+            ),
             (
                 "<pre class=\"playground\"><code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code></pre>",
-           "<pre class=\"playground\"><code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code></pre>",),
+                "<pre class=\"playground\"><code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code></pre>",
+            ),
         ];
         for (src, should_be) in &inputs {
             let got = hide_lines(src, &Code::default());
@@ -1206,10 +1252,12 @@ mod tests {
         let inputs = [
             (
                 "<code class=\"language-python\">~hidden()\nnothidden():\n~    hidden()\n    ~hidden()\n    nothidden()</code>",
-           "<code class=\"language-python\"><span class=\"boring\">hidden()\n</span>nothidden():\n<span class=\"boring\">    hidden()\n</span><span class=\"boring\">    hidden()\n</span>    nothidden()\n</code>",),
+                "<code class=\"language-python\"><span class=\"boring\">hidden()\n</span>nothidden():\n<span class=\"boring\">    hidden()\n</span><span class=\"boring\">    hidden()\n</span>    nothidden()\n</code>",
+            ),
             (
                 "<code class=\"language-python hidelines=!!!\">!!!hidden()\nnothidden():\n!!!    hidden()\n    !!!hidden()\n    nothidden()</code>",
-            "<code class=\"language-python hidelines=!!!\"><span class=\"boring\">hidden()\n</span>nothidden():\n<span class=\"boring\">    hidden()\n</span><span class=\"boring\">    hidden()\n</span>    nothidden()\n</code>",),
+                "<code class=\"language-python hidelines=!!!\"><span class=\"boring\">hidden()\n</span>nothidden():\n<span class=\"boring\">    hidden()\n</span><span class=\"boring\">    hidden()\n</span>    nothidden()\n</code>",
+            ),
         ];
         for (src, should_be) in &inputs {
             let got = hide_lines(

src/renderer/html_handlebars/static_files.rs

@@ -5,7 +5,7 @@ use log::{debug, warn};
 use crate::config::HtmlConfig;
 use crate::errors::*;
 use crate::renderer::html_handlebars::helpers::resources::ResourceHelper;
-use crate::theme::{self, playground_editor, Theme};
+use crate::theme::{self, Theme, playground_editor};
 use crate::utils;
 
 use std::borrow::Cow;

src/utils/mod.rs

@@ -5,7 +5,7 @@ mod string;
 pub(crate) mod toml_ext;
 use crate::errors::Error;
 use log::error;
-use pulldown_cmark::{html, CodeBlockKind, CowStr, Event, Options, Parser, Tag, TagEnd};
+use pulldown_cmark::{CodeBlockKind, CowStr, Event, Options, Parser, Tag, TagEnd, html};
 use regex::Regex;
 
 use std::borrow::Cow;

tests/testsuite/book_test.rs

@@ -1,7 +1,7 @@
 //! Utility for building and running tests against mdbook.
 
-use mdbook::book::BookBuilder;
 use mdbook::MDBook;
+use mdbook::book::BookBuilder;
 use snapbox::IntoData;
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};

tests/testsuite/search.rs

@@ -1,8 +1,8 @@
 //! Tests for search support.
 
 use crate::prelude::*;
-use mdbook::book::Chapter;
 use mdbook::BookItem;
+use mdbook::book::Chapter;
 use snapbox::file;
 use std::path::{Path, PathBuf};
 
@@ -62,7 +62,10 @@ fn reasonable_search_index() {
     // See note about InlineHtml in search.rs. Ideally the `alert()` part
     // should not be in the index, but we don't have a way to scrub inline
     // html.
-    assert_eq!(docs[&sneaky]["body"], "I put <HTML> in here! Sneaky inline event alert(\"inline\");. But regular inline is indexed.");
+    assert_eq!(
+        docs[&sneaky]["body"],
+        "I put <HTML> in here! Sneaky inline event alert(\"inline\");. But regular inline is indexed."
+    );
     assert_eq!(
         docs[&no_headers]["breadcrumbs"],
         "First Chapter » No Headers"