cargo fmt over everything

Author: 0xpr03

examples/async_monitor.rs

@@ -2,7 +2,7 @@ use futures::{
     channel::mpsc::{channel, Receiver},
     SinkExt, StreamExt,
 };
-use notify::{Event, RecommendedWatcher, RecursiveMode, Watcher, Config};
+use notify::{Config, Event, RecommendedWatcher, RecursiveMode, Watcher};
 use std::path::Path;
 
 /// Async, futures channel based event watching
@@ -24,11 +24,14 @@ fn async_watcher() -> notify::Result<(RecommendedWatcher, Receiver<notify::Resul
 
     // Automatically select the best implementation for your platform.
     // You can also access each implementation directly e.g. INotifyWatcher.
-    let watcher = RecommendedWatcher::new(move |res| {
-        futures::executor::block_on(async {
-            tx.send(res).await.unwrap();
-        })
-    }, Config::default())?;
+    let watcher = RecommendedWatcher::new(
+        move |res| {
+            futures::executor::block_on(async {
+                tx.send(res).await.unwrap();
+            })
+        },
+        Config::default(),
+    )?;
 
     Ok((watcher, rx))
 }
@@ -48,4 +51,4 @@ async fn async_watch<P: AsRef<Path>>(path: P) -> notify::Result<()> {
     }
 
     Ok(())
-}
+}

examples/debouncer_mini_custom.rs

@@ -1,6 +1,6 @@
 use std::{path::Path, time::Duration};
 
-use notify::{RecursiveMode, Config};
+use notify::{Config, RecursiveMode};
 use notify_debouncer_mini::new_debouncer_opt;
 
 /// Debouncer with custom backend and waiting for exit
@@ -18,7 +18,13 @@ fn main() {
     // setup debouncer
     let (tx, rx) = std::sync::mpsc::channel();
     // select backend via fish operator, here PollWatcher backend
-    let mut debouncer = new_debouncer_opt::<_,notify::PollWatcher>(Duration::from_secs(2), None, tx, Config::default()).unwrap();
+    let mut debouncer = new_debouncer_opt::<_, notify::PollWatcher>(
+        Duration::from_secs(2),
+        None,
+        tx,
+        Config::default(),
+    )
+    .unwrap();
 
     debouncer
         .watcher()

examples/monitor_raw.rs

@@ -1,4 +1,4 @@
-use notify::{RecommendedWatcher, RecursiveMode, Watcher, Config};
+use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
 use std::path::Path;
 
 fn main() {
@@ -30,4 +30,4 @@ fn watch<P: AsRef<Path>>(path: P) -> notify::Result<()> {
     }
 
     Ok(())
-}
+}

examples/poll_sysfs.rs

@@ -3,7 +3,7 @@
 /// This example can't be demonstrated under windows, it might be relevant for network shares
 #[cfg(not(target_os = "windows"))]
 fn not_windows_main() -> notify::Result<()> {
-    use notify::{PollWatcher, RecursiveMode, Watcher, Config};
+    use notify::{Config, PollWatcher, RecursiveMode, Watcher};
     use std::path::Path;
     use std::time::Duration;
 
@@ -27,7 +27,7 @@ fn not_windows_main() -> notify::Result<()> {
     println!("watching {:?}...", paths);
     // configure pollwatcher backend
     let config = Config::default()
-        .with_compare_contents(true) // crucial part for pseudo filesystems 
+        .with_compare_contents(true) // crucial part for pseudo filesystems
         .with_poll_interval(Duration::from_secs(2));
     let (tx, rx) = std::sync::mpsc::channel();
     // create pollwatcher backend

examples/watcher_kind.rs

@@ -1,5 +1,5 @@
-use std::{path::Path, time::Duration};
 use notify::*;
+use std::{path::Path, time::Duration};
 
 // example of detecting the recommended watcher kind
 fn main() {
@@ -8,9 +8,8 @@ fn main() {
     // That way the pollwatcher specific stuff is still configured, if it should be used.
     let mut watcher: Box<dyn Watcher> = if RecommendedWatcher::kind() == WatcherKind::PollWatcher {
         // custom config for PollWatcher kind
-        // you 
-        let config = Config::default()
-            .with_poll_interval(Duration::from_secs(1));
+        // you
+        let config = Config::default().with_poll_interval(Duration::from_secs(1));
         Box::new(PollWatcher::new(tx, config).unwrap())
     } else {
         // use default config for everything else

notify/src/config.rs

@@ -22,18 +22,18 @@ impl RecursiveMode {
 }
 
 /// Watcher Backend configuration
-/// 
+///
 /// This contains multiple settings that may relate to only one specific backend,
 /// such as to correctly configure each backend regardless of what is selected during runtime.
-/// 
+///
 /// ```rust
 /// # use std::time::Duration;
 /// # use notify::Config;
 /// let config = Config::default()
 ///     .with_poll_interval(Duration::from_secs(2))
 ///     .with_compare_contents(true);
 /// ```
-/// 
+///
 /// Some options can be changed during runtime, others have to be set when creating the watcher backend.
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub struct Config {
@@ -46,10 +46,10 @@ pub struct Config {
 
 impl Config {
     /// For [crate::PollWatcher]
-    /// 
+    ///
     /// Interval between each rescan attempt. This can be extremely expensive for large
     /// file trees so it is recommended to measure and tune accordingly.
-    /// 
+    ///
     /// The default poll frequency is 30 seconds.
     pub fn with_poll_interval(mut self, dur: Duration) -> Self {
         self.poll_interval = dur;
@@ -62,14 +62,14 @@ impl Config {
     }
 
     /// For [crate::PollWatcher]
-    /// 
+    ///
     /// Optional feature that will evaluate the contents of changed files to determine if
     /// they have indeed changed using a fast hashing algorithm.  This is especially important
     /// for pseudo filesystems like those on Linux under /sys and /proc which are not obligated
     /// to respect any other filesystem norms such as modification timestamps, file sizes, etc.
     /// By enabling this feature, performance will be significantly impacted as all files will
     /// need to be read and hashed at each `poll_interval`.
-    /// 
+    ///
     /// This can't be changed during runtime. Off by default.
     pub fn with_compare_contents(mut self, compare_contents: bool) -> Self {
         self.compare_contents = compare_contents;
@@ -84,9 +84,9 @@ impl Config {
 
 impl Default for Config {
     fn default() -> Self {
-        Self { 
+        Self {
             poll_interval: Duration::from_secs(30),
-            compare_contents: false
+            compare_contents: false,
         }
     }
-}
+}

notify/src/lib.rs

@@ -6,14 +6,14 @@
 //! [dependencies]
 //! notify = "6.0.0"
 //! ```
-//! 
+//!
 //! If you want debounced events, see [notify-debouncer-mini](https://github.com/notify-rs/notify/tree/main/notify-debouncer-mini)
 //! or [notify-debouncer-full](https://github.com/notify-rs/notify/tree/main/notify-debouncer-full).
-//! 
+//!
 //! ## Features
-//! 
+//!
 //! List of compilation features, see below for details
-//! 
+//!
 //! - `serde` for serialization of events
 //! - `macos_fsevent` enabled by default, for fsevent backend on macos
 //! - `macos_kqueue` for kqueue backend on macos
@@ -26,66 +26,66 @@
 //! ```toml
 //! notify = { version = "6.0.0", features = ["serde"] }
 //! ```
-//! 
+//!
 //! ### Crossbeam-Channel & Tokio
-//! 
+//!
 //! By default crossbeam-channel is used internally by notify.
 //! This can [cause issues](https://github.com/notify-rs/notify/issues/380) when used inside tokio.
-//! 
+//!
 //! You can disable crossbeam-channel, letting notify fallback to std channels via
-//! 
+//!
 //! ```toml
 //! notify = { version = "6.0.0", default-features = false, features = ["macos_kqueue"] }
 //! // Alternatively macos_fsevent instead of macos_kqueue
 //! ```
 //! Note the `macos_kqueue` requirement here, otherwise no backend is available on macos.
-//! 
+//!
 //! # Known Problems
-//! 
+//!
 //! ### Docker with Linux on MacOS M1
-//! 
+//!
 //! Docker on macos M1 [throws](https://github.com/notify-rs/notify/issues/423) `Function not implemented (os error 38)`.
 //! You have to manually use the [PollWatcher], as the native backend isn't available inside the emulation.
-//! 
+//!
 //! ### MacOS, FSEvents and unowned files
-//! 
+//!
 //! Due to the inner security model of FSEvents (see [FileSystemEventSecurity](https://developer.apple.com/library/mac/documentation/Darwin/Conceptual/FSEvents_ProgGuide/FileSystemEventSecurity/FileSystemEventSecurity.html)),
 //! some events cannot be observed easily when trying to follow files that do not
 //! belong to you. In this case, reverting to the pollwatcher can fix the issue,
 //! with a slight performance cost.
-//! 
+//!
 //! ### Editor Behaviour
-//! 
+//!
 //! If you rely on precise events (Write/Delete/Create..), you will notice that the actual events
 //! can differ a lot between file editors. Some truncate the file on save, some create a new one and replace the old one.
 //! See also [this](https://github.com/notify-rs/notify/issues/247) and [this](https://github.com/notify-rs/notify/issues/113#issuecomment-281836995) issues for example.
 //!
 //! ### Parent folder deletion
-//! 
+//!
 //! If you want to receive an event for a deletion of folder `b` for the path `/a/b/..`, you will have to watch its parent `/a`.
 //! See [here](https://github.com/notify-rs/notify/issues/403) for more details.
-//! 
+//!
 //! ### Pseudo Filesystems like /proc,/sys
-//! 
+//!
 //! Some filesystems like `/proc` and `/sys` on *nix do not emit change events or use correct file change dates.
 //! To circumvent that problem you can use the [PollWatcher] with the `compare_contents` option.
-//! 
+//!
 //! ### Linux: Bad File Descriptor / No space left on device
-//! 
+//!
 //! This may be the case of running into the max-files watched limits of your user or system.
 //! (Files also includes folders.) Note that for recursive watched folders each file and folder inside counts towards the limit.
-//! 
+//!
 //! You may increase this limit in linux via
 //! ```sh
 //! sudo sysctl fs.inotify.max_user_instances=8192 # example number
 //! sudo sysctl fs.inotify.max_user_watches=524288 # example number
 //! sudo sysctl -p
 //! ```
-//! 
+//!
 //! Note that the [PollWatcher] is not restricted by this limitation, so it may be an alternative if your users can't increase the limit.
-//! 
+//!
 //! # Examples
-//! 
+//!
 //! For more examples visit the [examples folder](https://github.com/notify-rs/notify/tree/main/examples) in the repository.
 //!
 //! ```rust,no_exec

notify/src/poll.rs

@@ -3,7 +3,7 @@
 //! Checks the `watch`ed paths periodically to detect changes. This implementation only uses
 //! Rust stdlib APIs and should work on all of the platforms it supports.
 
-use crate::{EventHandler, RecursiveMode, Watcher, Config};
+use crate::{Config, EventHandler, RecursiveMode, Watcher};
 use std::{
     collections::HashMap,
     path::{Path, PathBuf},
@@ -393,10 +393,10 @@ mod data {
 }
 
 /// Polling based `Watcher` implementation.
-/// 
+///
 /// By default scans through all files and checks for changed entries based on their change date.
 /// Can also be changed to perform file content change checks.
-/// 
+///
 /// See [Config] for more details.
 #[derive(Debug)]
 pub struct PollWatcher {
@@ -408,10 +408,7 @@ pub struct PollWatcher {
 
 impl PollWatcher {
     /// Create a new [PollWatcher], configured as needed.
-    pub fn new<F: EventHandler>(
-        event_handler: F,
-        config: Config,
-    ) -> crate::Result<PollWatcher> {
+    pub fn new<F: EventHandler>(event_handler: F, config: Config) -> crate::Result<PollWatcher> {
         let data_builder = DataBuilder::new(event_handler, config.compare_contents());
 
         let poll_watcher = PollWatcher {