Add a nox task to rustfmt code in the guide

guide/pyclass_parameters.md

@@ -24,12 +24,12 @@ more accompanying `#[pyo3(...)]` annotations, e.g.:
 ```rust,ignore
 // Argument supplied directly to the `#[pyclass]` annotation.
 #[pyclass(name = "SomeName", subclass)]
-struct MyClass { }
+struct MyClass {}
 
 // Argument supplied as a separate annotation.
 #[pyclass]
 #[pyo3(name = "SomeName", subclass)]
-struct MyClass { }
+struct MyClass {}
 ```
 
 [params-1]: https://docs.rs/pyo3/latest/pyo3/struct.PyAny.html

guide/src/building_and_distribution.md

@@ -115,7 +115,7 @@ The easiest way to set the correct linker arguments is to add a [`build.rs`](htt
 
 ```rust,ignore
 fn main() {
-  pyo3_build_config::add_extension_module_link_args();
+    pyo3_build_config::add_extension_module_link_args();
 }
 ```
 

guide/src/building_and_distribution/multiple_python_versions.md

@@ -14,13 +14,13 @@ This allows us to write code like the following
 
 ```rust,ignore
 #[cfg(Py_3_7)]
-fn function_only_supported_on_python_3_7_and_up() { }
+fn function_only_supported_on_python_3_7_and_up() {}
 
 #[cfg(not(Py_3_8))]
-fn function_only_supported_before_python_3_8() { }
+fn function_only_supported_before_python_3_8() {}
 
 #[cfg(not(Py_LIMITED_API))]
-fn function_incompatible_with_abi3_feature() { }
+fn function_incompatible_with_abi3_feature() {}
 ```
 
 The following sections first show how to add these `#[cfg]` flags to your build process, and then cover some common patterns flags in a little more detail.
@@ -98,11 +98,10 @@ PyO3 provides the APIs [`Python::version()`] and [`Python::version_info()`] to q
 use pyo3::Python;
 
 Python::with_gil(|py| {
-   // PyO3 supports Python 3.7 and up.
-   assert!(py.version_info() >= (3, 7));
-   assert!(py.version_info() >= (3, 7, 0));
+    // PyO3 supports Python 3.7 and up.
+    assert!(py.version_info() >= (3, 7));
+    assert!(py.version_info() >= (3, 7, 0));
 });
-
 ```
 
 [`Python::version()`]: {{#PYO3_DOCS_URL}}/pyo3/struct.Python.html#method.version

guide/src/class.md

@@ -26,8 +26,8 @@ To define a custom Python class, add the `#[pyclass]` attribute to a Rust struct
 use pyo3::prelude::*;
 
 #[pyclass]
-struct Integer{
-    inner: i32
+struct Integer {
+    inner: i32,
 }
 
 // A "tuple" struct
@@ -166,7 +166,7 @@ struct MyClass {
     num: i32,
 }
 Python::with_gil(|py| {
-    let obj = PyCell::new(py, MyClass { num: 3}).unwrap();
+    let obj = PyCell::new(py, MyClass { num: 3 }).unwrap();
     {
         let obj_ref = obj.borrow(); // Get PyRef
         assert_eq!(obj_ref.num, 3);
@@ -204,7 +204,7 @@ fn return_myclass() -> Py<MyClass> {
 
 let obj = return_myclass();
 
-Python::with_gil(|py|{
+Python::with_gil(|py| {
     let cell = obj.as_ref(py); // Py<MyClass>::as_ref returns &PyCell<MyClass>
     let obj_ref = cell.borrow(); // Get PyRef<T>
     assert_eq!(obj_ref.num, 1);
@@ -279,7 +279,7 @@ impl SubClass {
     }
 
     fn method2(self_: PyRef<'_, Self>) -> PyResult<usize> {
-        let super_ = self_.as_ref();  // Get &BaseClass
+        let super_ = self_.as_ref(); // Get &BaseClass
         super_.method().map(|x| x * self_.val2)
     }
 }
@@ -293,13 +293,12 @@ struct SubSubClass {
 impl SubSubClass {
     #[new]
     fn new() -> PyClassInitializer<Self> {
-        PyClassInitializer::from(SubClass::new())
-            .add_subclass(SubSubClass{val3: 20})
+        PyClassInitializer::from(SubClass::new()).add_subclass(SubSubClass { val3: 20 })
     }
 
     fn method3(self_: PyRef<'_, Self>) -> PyResult<usize> {
         let v = self_.val3;
-        let super_ = self_.into_super();  // Get PyRef<'_, SubClass>
+        let super_ = self_.into_super(); // Get PyRef<'_, SubClass>
         SubClass::method2(super_).map(|x| x * v)
     }
 }
@@ -426,7 +425,7 @@ For simple cases where a member variable is just read and written with no side e
 #[pyclass]
 struct MyClass {
     #[pyo3(get, set)]
-    num: i32
+    num: i32,
 }
 ```
 
@@ -937,7 +936,7 @@ You may not use enums as a base class or let enums inherit from other classes.
 ```rust,compile_fail
 # use pyo3::prelude::*;
 #[pyclass(subclass)]
-enum BadBase{
+enum BadBase {
     Var1,
 }
 ```
@@ -949,7 +948,7 @@ enum BadBase{
 struct Base;
 
 #[pyclass(extends=Base)]
-enum BadSubclass{
+enum BadSubclass {
     Var1,
 }
 ```

guide/src/class/numeric.md

@@ -395,7 +395,6 @@ fn my_module(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
 #         Ok(())
 #     })
 # }
-
 ```
 
 ## Appendix: Writing some unsafe code

guide/src/class/object.md

@@ -40,10 +40,10 @@ print(n)
 ### String representations
 
 It can't even print an user-readable representation of itself! We can fix that by defining the
- `__repr__` and `__str__` methods inside a `#[pymethods]` block. We do this by accessing the value
- contained inside `Number`.
+`__repr__` and `__str__` methods inside a `#[pymethods]` block. We do this by accessing the value
+contained inside `Number`.
 
- ```rust
+```rust
 # use pyo3::prelude::*;
 #
 # #[pyclass]
@@ -114,13 +114,13 @@ impl Number {
 > ```rust
 > # use pyo3::prelude::*;
 > #[pyclass]
-> struct NotHashable { }
+> struct NotHashable {}
 >
 > #[pymethods]
 > impl NotHashable {
->    #[classattr]
->    const __hash__: Option<Py<PyAny>> = None;
->}
+>     #[classattr]
+>     const __hash__: Option<Py<PyAny>> = None;
+> }
 > ```
 
 ### Comparisons

guide/src/class/protocols.md

@@ -48,7 +48,7 @@ given signatures should be interpreted as follows:
     # use pyo3::prelude::*;
     #
     #[pyclass]
-    struct NotHashable { }
+    struct NotHashable {}
 
     #[pymethods]
     impl NotHashable {
@@ -229,7 +229,7 @@ Use the `#[pyclass(sequence)]` annotation to instruct PyO3 to fill the `sq_lengt
     # use pyo3::prelude::*;
     #
     #[pyclass]
-    struct NoContains { }
+    struct NoContains {}
 
     #[pymethods]
     impl NoContains {