wip: add logging capabilities

src/config.rs

@@ -1,13 +1,116 @@
-use std::path::PathBuf;
 use clap::Parser;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use tracing_core::{Level, LevelFilter};
 
-#[derive(Debug, Parser)]
-pub struct Args {
-    path: PathBuf,
+pub enum VerbosityFilter {
+    Off,
+    Error,
+    Warn,
+    Info,
+    Debug,
+    Trace,
 }
 
-impl Args {
+impl VerbosityFilter {
+    fn with_offset(&self, offset: i16) -> VerbosityFilter {
+        let value = match self {
+            Self::Off => 0_i16,
+            Self::Error => 1,
+            Self::Warn => 2,
+            Self::Info => 3,
+            Self::Debug => 4,
+            Self::Trace => 5,
+        };
+        match value.saturating_add(offset) {
+            i16::MIN..=0 => Self::Off,
+            1 => Self::Error,
+            2 => Self::Warn,
+            3 => Self::Info,
+            4 => Self::Debug,
+            5..=i16::MAX => Self::Trace,
+        }
+    }
+
+}
+impl From<LevelFilter> for VerbosityFilter {
+    fn from(level: LevelFilter) -> Self {
+        match level {
+            LevelFilter::OFF => Self::Off,
+            LevelFilter::ERROR => Self::Error,
+            LevelFilter::WARN => Self::Warn,
+            LevelFilter::INFO => Self::Info,
+            LevelFilter::DEBUG => Self::Debug,
+            LevelFilter::TRACE => Self::Trace,
+        }
+    }
+}
+
+impl From<VerbosityFilter> for Option<Level> {
+    fn from(filter: VerbosityFilter) -> Self {
+        match filter {
+            VerbosityFilter::Off => None,
+            VerbosityFilter::Error => Some(Level::ERROR),
+            VerbosityFilter::Warn => Some(Level::WARN),
+            VerbosityFilter::Info => Some(Level::INFO),
+            VerbosityFilter::Debug => Some(Level::DEBUG),
+            VerbosityFilter::Trace => Some(Level::TRACE),
+        }
+    }
+}
+impl From<Option<Level>> for VerbosityFilter {
+    fn from(level: Option<Level>) -> Self {
+        match level {
+            None => Self::Off,
+            Some(Level::ERROR) => Self::Error,
+            Some(Level::WARN) => Self::Warn,
+            Some(Level::INFO) => Self::Info,
+            Some(Level::DEBUG) => Self::Debug,
+            Some(Level::TRACE) => Self::Trace,
+        }
+    }
+}
+
+#[derive(Debug, Parser, Serialize, Deserialize)]
+pub struct Config {
+    path: PathBuf,
+    #[arg(
+        long,
+        short = 'v',
+        action = clap::ArgAction::Count,
+        global = true,
+        help = "Increase logging verbosity",
+    )]
+    verbose: u8,
+
+    #[arg(
+        long,
+        short = 'q',
+        action = clap::ArgAction::Count,
+        global = true,
+        help = "Decrease logging verbosity",
+        conflicts_with = "verbose",
+    )]
+    quiet: u8,
+}
+
+impl Config {
     pub fn path(&self) -> &PathBuf {
         &self.path
     }
-}
+    /// Gets the filter that should be applied to the logger.
+    /// 
+    pub fn filter(&self) -> VerbosityFilter {
+        let offset = self.verbose as i16 - self.quiet as i16;
+        VerbosityFilter::Error.with_offset(offset)
+    }
+
+    pub fn tracing_level(&self) -> Option<tracing_core::Level> {
+        self.filter().into()
+    }
+
+    /// Get the tracing level filter.
+    pub fn tracing_level_filter(&self) -> tracing_core::LevelFilter {
+        self.filter().into()
+    }
+}