nightly fmt

Author: estk

.github/workflows/ci.yml

@@ -22,6 +22,7 @@ jobs:
           - nightly-2023-10-25
     steps:
       - uses: actions/checkout@v4
+      - uses: streetsidesoftware/cspell-action@v5
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.toolchain }}
@@ -39,6 +40,9 @@ jobs:
           cargo fmt -- --check
           cargo clippy -- -D warnings
 
+      - name: Spell
+        run: cspell --config ./cspell.json "**/*.{rs|md}"
+
   cargo:
     name: Build & Test
     runs-on: ubuntu-latest

.vscode/settings.json

@@ -1,12 +1,5 @@
 {
-    "cSpell.words": [
-        "appender",
-        "appenders",
-        "fmtorp",
-        "fmtr",
-        "hmap",
-        "Lyrd",
-        "messageonly",
-        "targ"
-    ]
+    "rust-analyzer.rustfmt.extraArgs": [
+        "+nightly"
+    ],
 }

trace4rs-config/src/config.rs

@@ -2,18 +2,29 @@
 
 use std::{
     borrow::Cow,
-    collections::{HashMap, HashSet},
+    collections::{
+        HashMap,
+        HashSet,
+    },
     result,
     str::FromStr,
 };
 
 #[cfg(feature = "schemars")]
 use schemars::JsonSchema;
 #[cfg(feature = "serde")]
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::{
+    Deserialize,
+    Deserializer,
+    Serialize,
+    Serializer,
+};
 use tracing::level_filters;
 
-use crate::error::{Error, Result};
+use crate::error::{
+    Error,
+    Result,
+};
 
 /// The root configuration object containing everything necessary to build a
 /// `trace4rs::Handle`.
@@ -23,7 +34,7 @@ use crate::error::{Error, Result};
 pub struct Config {
     /// The default logger, which must be configured.
     #[cfg_attr(feature = "serde", serde(rename = "root", alias = "default"))]
-    pub default: Logger,
+    pub default:   Logger,
     /// Appenders are assigned an id of your choice and configure actual log
     /// message output.
     #[cfg_attr(
@@ -37,7 +48,7 @@ pub struct Config {
         feature = "in-order-serialization",
         serde(serialize_with = "ordered_map")
     )]
-    pub loggers: HashMap<Target, Logger>,
+    pub loggers:   HashMap<Target, Logger>,
 }
 
 /// # Errors
@@ -80,15 +91,18 @@ impl Default for Config {
 impl Config {
     /// A configuration for `INFO` and above to be logged to stdout.
     fn console_config() -> Config {
-        use literally::{hmap, hset};
+        use literally::{
+            hmap,
+            hset,
+        };
 
         Config {
-            default: Logger {
-                level: LevelFilter::INFO,
+            default:   Logger {
+                level:     LevelFilter::INFO,
                 appenders: hset! { "stdout" },
-                format: Format::default(),
+                format:    Format::default(),
             },
-            loggers: hmap! {},
+            loggers:   hmap! {},
             appenders: hmap! {
                 "stdout" => Appender::Console
             },
@@ -135,12 +149,12 @@ pub struct Logger {
         serde(serialize_with = "ordered_set")
     )]
     pub appenders: HashSet<AppenderId>,
-    pub level: LevelFilter,
+    pub level:     LevelFilter,
     #[cfg_attr(
         feature = "serde",
         serde(default = "Format::default", skip_serializing_if = "Format::is_normal")
     )]
-    pub format: Format,
+    pub format:    Format,
 }
 
 #[cfg(feature = "serde")]
@@ -315,7 +329,7 @@ pub enum Appender {
         path: String,
     },
     RollingFile {
-        path: String,
+        path:   String,
         #[cfg_attr(feature = "serde", serde(rename = "rolloverPolicy"))]
         policy: Policy,
     },
@@ -424,15 +438,18 @@ impl Policy {
 mod test {
     use literally::hset;
 
-    use super::{LevelFilter, Logger};
+    use super::{
+        LevelFilter,
+        Logger,
+    };
     use crate::config::Format;
 
     #[test]
     fn test_format_serde() {
         let lgr = Logger {
             appenders: hset! {},
-            level: LevelFilter::OFF,
-            format: Format::Normal,
+            level:     LevelFilter::OFF,
+            format:    Format::Normal,
         };
         let lgr_value = dbg!(serde_json::to_value(&lgr).unwrap());
         assert!(lgr_value.get("format").is_none());
@@ -441,8 +458,8 @@ mod test {
 
         let lgr = Logger {
             appenders: hset! {},
-            level: LevelFilter::OFF,
-            format: Format::MessageOnly,
+            level:     LevelFilter::OFF,
+            format:    Format::MessageOnly,
         };
         let lgr_value = dbg!(serde_json::to_value(&lgr).unwrap());
         let fmt = lgr_value.get("format").unwrap().as_str().unwrap();
@@ -452,8 +469,8 @@ mod test {
 
         let lgr = Logger {
             appenders: hset! {},
-            level: LevelFilter::OFF,
-            format: Format::Custom("foobar".to_string()),
+            level:     LevelFilter::OFF,
+            format:    Format::Custom("foobar".to_string()),
         };
         let lgr_value = dbg!(serde_json::to_value(&lgr).unwrap());
         let fmt = lgr_value.get("format").unwrap().as_str().unwrap();

trace4rs-fmtorp/src/lib.rs

@@ -1,5 +1,9 @@
 use core::fmt;
-use std::{borrow::Cow, collections::HashSet, ops::RangeInclusive};
+use std::{
+    borrow::Cow,
+    collections::HashSet,
+    ops::RangeInclusive,
+};
 
 use tracing_subscriber::fmt::format;
 
@@ -18,13 +22,13 @@ pub enum Error {
 #[derive(Debug)]
 pub struct Fmtr<'fmtstr> {
     /// The owned or static borrowed format string.
-    fmt_str: Cow<'fmtstr, str>,
+    fmt_str:      Cow<'fmtstr, str>,
     /// The ranges indexing `fmt_str` which 1-1 index `ordered_fields`.
     /// # Invariants
     /// Ranges are strictly within bounds of fmt_str
     field_ranges: Vec<RangeInclusive<usize>>,
     /// The names of fields indexed identically to field_ranges.
-    field_names: Vec<&'static str>,
+    field_names:  Vec<&'static str>,
 }
 impl<'fmtstr> Fmtr<'fmtstr> {
     /// Unrecognized fields should be an error

trace4rs/benches/log4rs_bench.rs

@@ -3,18 +3,28 @@
 
 use std::env;
 
-use criterion::{black_box, Criterion};
+use criterion::{
+    black_box,
+    Criterion,
+};
 use log::LevelFilter;
 use log4rs::{
     append::{
         console::ConsoleAppender,
         file::FileAppender,
         rolling_file::{
-            policy::compound::{roll::fixed_window::FixedWindowRoller, trigger::size::SizeTrigger},
+            policy::compound::{
+                roll::fixed_window::FixedWindowRoller,
+                trigger::size::SizeTrigger,
+            },
             RollingFileAppender,
         },
     },
-    config::{Appender, Logger, Root},
+    config::{
+        Appender,
+        Logger,
+        Root,
+    },
     Handle,
 };
 

trace4rs/benches/trace4rs_bench.rs

@@ -3,10 +3,18 @@
 
 use std::env;
 
-use criterion::{black_box, Criterion};
+use criterion::{
+    black_box,
+    Criterion,
+};
 use trace4rs::{
-    config::{self, Format, Policy},
-    Config, Handle,
+    config::{
+        self,
+        Format,
+        Policy,
+    },
+    Config,
+    Handle,
 };
 use tracing::Subscriber;
 macro_rules! do_log {
@@ -41,7 +49,7 @@ fn mk_handle() -> (Handle, impl Subscriber) {
             path: "file.log".to_string(),
         };
         let rolling_file = config::Appender::RollingFile {
-            path: "rolling_file.log".to_string(),
+            path:   "rolling_file.log".to_string(),
             policy: Policy {
                 pattern: Some("rolling_file.log.{}".to_string()),
                 max_size_roll_backups: 3,
@@ -57,20 +65,20 @@ fn mk_handle() -> (Handle, impl Subscriber) {
     };
 
     let default = config::Logger {
-        level: config::LevelFilter::INFO,
+        level:     config::LevelFilter::INFO,
         appenders: literally::hset! {"console"},
-        format: Format::default(),
+        format:    Format::default(),
     };
     let loggers = {
         let file_logger = config::Logger {
-            level: config::LevelFilter::INFO,
+            level:     config::LevelFilter::INFO,
             appenders: literally::hset! {"file"},
-            format: Format::default(),
+            format:    Format::default(),
         };
         let rolling_file_logger = config::Logger {
-            level: config::LevelFilter::INFO,
+            level:     config::LevelFilter::INFO,
             appenders: literally::hset! {"file"},
-            format: Format::default(),
+            format:    Format::default(),
         };
         literally::hmap! {"file" => file_logger, "rolling_file" => rolling_file_logger}
     };

trace4rs/src/appenders/mod.rs

@@ -2,22 +2,38 @@
 use std::{
     collections::HashMap,
     convert::TryFrom,
-    fs::{self},
-    io::{self, LineWriter, Write},
+    fs::{
+        self,
+    },
+    io::{
+        self,
+        LineWriter,
+        Write,
+    },
     ops::Deref,
     path::Path,
     sync::Arc,
 };
 
-use camino::{Utf8Path, Utf8PathBuf};
+use camino::{
+    Utf8Path,
+    Utf8PathBuf,
+};
 use parking_lot::Mutex;
 use path_absolutize::Absolutize;
 use tracing_subscriber::fmt::MakeWriter;
 
 use crate::{
-    config::{self, AppenderId, Policy},
+    config::{
+        self,
+        AppenderId,
+        Policy,
+    },
     env::try_expand_env_vars,
-    error::{Error, Result},
+    error::{
+        Error,
+        Result,
+    },
 };
 
 mod rolling;
@@ -155,7 +171,10 @@ impl Appender {
         count: usize,
         size: &str,
     ) -> Result<Self> {
-        use rolling::{Roller, Trigger};
+        use rolling::{
+            Roller,
+            Trigger,
+        };
         let abs_path = {
             let ps = path_str.as_ref();
             let cp = Utf8Path::new(ps);
@@ -280,7 +299,7 @@ impl io::Write for Console {
 /// An appender which writes to a file.
 #[derive(Debug)]
 pub struct File {
-    path: Utf8PathBuf,
+    path:   Utf8PathBuf,
     writer: LineWriter<fs::File>,
 }
 impl File {