style: format code blocks

Signed-off-by: simonsan <[email protected]>

Author: simonsan

dprint.json .dprint.json

@@ -24,10 +24,17 @@
         "theme/book.js",
         "target/**/*"
     ],
+    "exec": {
+        "commands": [{
+            "command": "rustfmt --edition 2021",
+            "exts": ["rs"]
+        }]
+    },
     "plugins": [
         "https://plugins.dprint.dev/markdown-0.16.4.wasm",
         "https://plugins.dprint.dev/toml-0.6.1.wasm",
         "https://plugins.dprint.dev/json-0.19.2.wasm",
-        "https://plugins.dprint.dev/typescript-0.89.3.wasm"
+        "https://plugins.dprint.dev/typescript-0.89.3.wasm",
+        "https://plugins.dprint.dev/exec-0.4.4.json@c207bf9b9a4ee1f0ecb75c594f774924baf62e8e53a2ce9d873816a408cecbf7"
     ]
 }

.github/workflows/lint.yml

@@ -11,4 +11,12 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: dprint/[email protected]
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@1482605bfc5719782e1267fd0c0cc350fe7646b8 # v1
+        with:
+          toolchain: stable
+          components: rustfmt
+
+      - uses: Swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2
+
+      - uses: dprint/[email protected]

src/anti_patterns/deny-warnings.md

@@ -58,35 +58,39 @@ is a list of warning lints that is (hopefully) safe to deny (as of Rustc
 1.48.0):
 
 ```rust,ignore
-#![deny(bad_style,
-       const_err,
-       dead_code,
-       improper_ctypes,
-       non_shorthand_field_patterns,
-       no_mangle_generic_items,
-       overflowing_literals,
-       path_statements,
-       patterns_in_fns_without_body,
-       private_in_public,
-       unconditional_recursion,
-       unused,
-       unused_allocation,
-       unused_comparisons,
-       unused_parens,
-       while_true)]
+#![deny(
+    bad_style,
+    const_err,
+    dead_code,
+    improper_ctypes,
+    non_shorthand_field_patterns,
+    no_mangle_generic_items,
+    overflowing_literals,
+    path_statements,
+    patterns_in_fns_without_body,
+    private_in_public,
+    unconditional_recursion,
+    unused,
+    unused_allocation,
+    unused_comparisons,
+    unused_parens,
+    while_true
+)]
 ```
 
 In addition, the following `allow`ed lints may be a good idea to `deny`:
 
 ```rust,ignore
-#![deny(missing_debug_implementations,
-       missing_docs,
-       trivial_casts,
-       trivial_numeric_casts,
-       unused_extern_crates,
-       unused_import_braces,
-       unused_qualifications,
-       unused_results)]
+#![deny(
+    missing_debug_implementations,
+    missing_docs,
+    trivial_casts,
+    trivial_numeric_casts,
+    unused_extern_crates,
+    unused_import_braces,
+    unused_qualifications,
+    unused_results
+)]
 ```
 
 Some may also want to add `missing-copy-implementations` to their list.

src/functional/generics-type-classes.md

@@ -120,8 +120,8 @@ mod bootp {
 
 // private module, lest outside users invent their own protocol kinds!
 mod proto_trait {
-    use std::path::{Path, PathBuf};
     use super::{bootp, nfs};
+    use std::path::{Path, PathBuf};
 
     pub(crate) trait ProtoKind {
         type AuthInfo;
@@ -157,7 +157,7 @@ mod proto_trait {
 }
 
 use proto_trait::ProtoKind; // keep internal to prevent impls
-pub use proto_trait::{Nfs, Bootp}; // re-export so callers can see them
+pub use proto_trait::{Bootp, Nfs}; // re-export so callers can see them
 
 struct FileDownloadRequest<P: ProtoKind> {
     file_name: PathBuf,

src/functional/optics.md

@@ -185,8 +185,8 @@ use anyhow;
 use std::str::FromStr;
 
 struct TestStruct {
-  a: usize,
-  b: String,
+    a: usize,
+    b: String,
 }
 
 impl FromStr for TestStruct {
@@ -203,7 +203,10 @@ impl ToString for TestStruct {
 }
 
 fn main() {
-    let a = TestStruct { a: 5, b: "hello".to_string() };
+    let a = TestStruct {
+        a: 5,
+        b: "hello".to_string(),
+    };
     println!("Our Test Struct as JSON: {}", a.to_string());
 }
 ```
@@ -264,8 +267,8 @@ independent form, it is even possible to have code generation creating the
 ```rust,ignore
 #[derive(Default, Serde)] // the "Serde" derive creates the trait impl block
 struct TestStruct {
-  a: usize,
-  b: String,
+    a: usize,
+    b: String,
 }
 
 // user writes this macro to generate an associated visitor type

src/idioms/coercion-arguments.md

@@ -36,10 +36,10 @@ fn three_vowels(word: &String) -> bool {
             'a' | 'e' | 'i' | 'o' | 'u' => {
                 vowel_count += 1;
                 if vowel_count >= 3 {
-                    return true
+                    return true;
                 }
             }
-            _ => vowel_count = 0
+            _ => vowel_count = 0,
         }
     }
     false
@@ -54,7 +54,6 @@ fn main() {
     // This works fine, but the following two lines would fail:
     // println!("Ferris: {}", three_vowels("Ferris"));
     // println!("Curious: {}", three_vowels("Curious"));
-
 }
 ```
 
@@ -97,10 +96,10 @@ fn three_vowels(word: &str) -> bool {
             'a' | 'e' | 'i' | 'o' | 'u' => {
                 vowel_count += 1;
                 if vowel_count >= 3 {
-                    return true
+                    return true;
                 }
             }
-            _ => vowel_count = 0
+            _ => vowel_count = 0,
         }
     }
     false

src/idioms/ctor.md

@@ -16,7 +16,7 @@ object:
 /// assert_eq!(42, s.value());
 /// ```
 pub struct Second {
-    value: u64
+    value: u64,
 }
 
 impl Second {
@@ -47,7 +47,7 @@ Rust supports default constructors with the [`Default`][std-default] trait:
 /// assert_eq!(0, s.value());
 /// ```
 pub struct Second {
-    value: u64
+    value: u64,
 }
 
 impl Second {
@@ -78,7 +78,7 @@ like they do with `Second`:
 /// ```
 #[derive(Default)]
 pub struct Second {
-    value: u64
+    value: u64,
 }
 
 impl Second {

src/idioms/ffi/accepting-strings.md

@@ -44,10 +44,7 @@ pub mod unsafe_module {
     /// - points to memory ending in a null byte
     /// - won't be mutated for the duration of this function call
     #[no_mangle]
-    pub unsafe extern "C" fn mylib_log(
-        msg: *const libc::c_char,
-        level: libc::c_int
-    ) {
+    pub unsafe extern "C" fn mylib_log(msg: *const libc::c_char, level: libc::c_int) {
         let level: crate::LogLevel = match level { /* ... */ };
 
         // SAFETY: The caller has already guaranteed this is okay (see the

src/idioms/ffi/errors.md

@@ -20,8 +20,8 @@ in a usable way:
 
 ```rust,ignore
 enum DatabaseError {
-    IsReadOnly = 1, // user attempted a write operation
-    IOError = 2, // user should read the C errno() for what it was
+    IsReadOnly = 1,    // user attempted a write operation
+    IOError = 2,       // user should read the C errno() for what it was
     FileCorrupted = 3, // user should run a repair tool to recover it
 }
 
@@ -57,10 +57,7 @@ pub mod c_api {
     use super::errors::DatabaseError;
 
     #[no_mangle]
-    pub extern "C" fn db_error_description(
-        e: *const DatabaseError
-        ) -> *mut libc::c_char {
-
+    pub extern "C" fn db_error_description(e: *const DatabaseError) -> *mut libc::c_char {
         let error: &DatabaseError = unsafe {
             // SAFETY: pointer lifetime is greater than the current stack frame
             &*e
@@ -107,17 +104,19 @@ pub mod c_api {
 struct ParseError {
     expected: char,
     line: u32,
-    ch: u16
+    ch: u16,
 }
 
-impl ParseError { /* ... */ }
+impl ParseError {
+    /* ... */
+}
 
 /* Create a second version which is exposed as a C structure */
 #[repr(C)]
 pub struct parse_error {
     pub expected: libc::c_char,
     pub line: u32,
-    pub ch: u16
+    pub ch: u16,
 }
 
 impl From<ParseError> for parse_error {

src/idioms/ffi/passing-strings.md

@@ -35,9 +35,7 @@ pub mod unsafe_module {
         fn geterr(buffer: *mut libc::c_char, size: libc::c_int) -> libc::c_int;
     }
 
-    fn report_error_to_ffi<S: Into<String>>(
-        err: S
-    ) -> Result<(), std::ffi::NulError>{
+    fn report_error_to_ffi<S: Into<String>>(err: S) -> Result<(), std::ffi::NulError> {
         let c_err = std::ffi::CString::new(err.into())?;
 
         unsafe {

src/idioms/mem-replace.md

@@ -15,7 +15,7 @@ use std::mem;
 
 enum MyEnum {
     A { name: String, x: u8 },
-    B { name: String }
+    B { name: String },
 }
 
 fn a_to_b(e: &mut MyEnum) {
@@ -24,7 +24,9 @@ fn a_to_b(e: &mut MyEnum) {
         // (note that empty strings don't allocate).
         // Then, construct the new enum variant (which will
         // be assigned to `*e`).
-        *e = MyEnum::B { name: mem::take(name) }
+        *e = MyEnum::B {
+            name: mem::take(name),
+        }
     }
 }
 ```
@@ -38,18 +40,22 @@ enum MultiVariateEnum {
     A { name: String },
     B { name: String },
     C,
-    D
+    D,
 }
 
 fn swizzle(e: &mut MultiVariateEnum) {
     use MultiVariateEnum::*;
     *e = match e {
         // Ownership rules do not allow taking `name` by value, but we cannot
         // take the value out of a mutable reference, unless we replace it:
-        A { name } => B { name: mem::take(name) },
-        B { name } => A { name: mem::take(name) },
+        A { name } => B {
+            name: mem::take(name),
+        },
+        B { name } => A {
+            name: mem::take(name),
+        },
         C => D,
-        D => C
+        D => C,
     }
 }
 ```

src/idioms/priv-extend.md

@@ -25,21 +25,23 @@ mod a {
     pub struct S {
         pub foo: i32,
     }
-    
+
     #[non_exhaustive]
     pub enum AdmitMoreVariants {
         VariantA,
         VariantB,
         #[non_exhaustive]
-        VariantC { a: String }
+        VariantC {
+            a: String,
+        },
     }
 }
 
 fn print_matched_variants(s: a::S) {
     // Because S is `#[non_exhaustive]`, it cannot be named here and
     // we must use `..` in the pattern.
-    let a::S { foo: _, ..} = s;
-    
+    let a::S { foo: _, .. } = s;
+
     let some_enum = a::AdmitMoreVariants::VariantA;
     match some_enum {
         a::AdmitMoreVariants::VariantA => println!("it's an A"),
@@ -50,7 +52,7 @@ fn print_matched_variants(s: a::S) {
 
         // The wildcard match is required because more variants may be
         // added in the future
-        _ => println!("it's a new variant")
+        _ => println!("it's a new variant"),
     }
 }
 ```
@@ -78,7 +80,7 @@ pub struct S {
     pub a: i32,
     // Because `b` is private, you cannot match on `S` without using `..` and `S`
     //  cannot be directly instantiated or matched against
-    _b: ()
+    _b: (),
 }
 ```
 

src/idioms/return-consumed-arg-on-error.md

@@ -12,7 +12,9 @@ pub fn send(value: String) -> Result<(), SendError> {
     println!("using {value} in a meaningful way");
     // Simulate non-deterministic fallible action.
     use std::time::SystemTime;
-    let period = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+    let period = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .unwrap();
     if period.subsec_nanos() % 2 == 1 {
         Ok(())
     } else {

src/patterns/behavioural/RAII.md

@@ -63,8 +63,8 @@ impl<'a, T> Deref for MutexGuard<'a, T> {
 fn baz(x: Mutex<Foo>) {
     let xx = x.lock();
     xx.foo(); // foo is a method on Foo.
-    // The borrow checker ensures we can't store a reference to the underlying
-    // Foo which will outlive the guard xx.
+              // The borrow checker ensures we can't store a reference to the underlying
+              // Foo which will outlive the guard xx.
 
     // x is unlocked when we exit this function and xx's destructor is executed.
 }