feat(env_filter): support no_std

.github/workflows/ci.yml

@@ -72,7 +72,12 @@ jobs:
     - uses: Swatinem/rust-cache@v2
     - uses: taiki-e/install-action@cargo-hack
     - name: Default features
-      run: cargo hack check --each-feature --locked --rust-version --ignore-private --workspace --all-targets --keep-going
+      run:
+        - cargo hack check --each-feature --locked --rust-version --ignore-private --package env_logger --all-targets --keep-going
+        # When the std feature is enabled, a lower MSRV of 1.71 is sufficient and was the MSRV for the crate before std was made optional.
+        # To make sure we keep it that way, check configurations with std enabled and disabled separately and with their respective MSRVs.
+        - cargo hack check --feature-powerset --depth 2 --locked --version-range 1.71..=1.71 --ignore-private --package env_filter --all-targets --keep-going --at-least-one-of std,default
+        - cargo hack check --each-feature --locked --version-range 1.81..=1.81 --ignore-private --package env_filter --all-targets --keep-going --exclude-features std,default
   minimal-versions:
     name: Minimal versions
     strategy:

Cargo.toml

@@ -135,7 +135,7 @@ unstable-kv = ["kv"]
 
 [dependencies]
 log = { version = "0.4.29", features = ["std"] }
-env_filter = { version = "1.0.0", path = "crates/env_filter", default-features = false }
+env_filter = { version = "1.0.0", path = "crates/env_filter", default-features = false, features = ["std"] }
 jiff = { version = "0.2.22", default-features = false, features = ["std"], optional = true }
 anstream = { version = "1.0.0", default-features = false, features = ["wincon"], optional = true }
 anstyle = { version = "1.0.13", optional = true }

crates/env_filter/Cargo.toml

@@ -9,7 +9,6 @@ keywords = ["logging", "log", "logger"]
 repository.workspace = true
 license.workspace = true
 edition.workspace = true
-rust-version.workspace = true
 include.workspace = true
 
 [package.metadata.docs.rs]
@@ -26,12 +25,13 @@ pre-release-replacements = [
 ]
 
 [features]
-default = ["regex"]
+default = ["std", "regex"]
 regex = ["dep:regex"]
+std = ["regex/std"]
 
 [dependencies]
-log = { version = "0.4.29", features = ["std"] }
-regex = { version = "1.12.3", optional = true, default-features=false, features=["std", "perf"] }
+log = { version = "0.4.29", default-features = false }
+regex = { version = "1.12.3", optional = true, default-features=false, features=["perf"] }
 
 [dev-dependencies]
 snapbox = "1.0"

crates/env_filter/src/directive.rs

@@ -1,3 +1,5 @@
+use alloc::string::String;
+
 use log::Level;
 use log::LevelFilter;
 

crates/env_filter/src/filter.rs

@@ -1,6 +1,5 @@
-use std::env;
-use std::fmt;
-use std::mem;
+use alloc::{borrow::ToOwned, string::ToString, vec::Vec};
+use core::{fmt, mem};
 
 use log::{LevelFilter, Metadata, Record};
 
@@ -48,10 +47,11 @@ impl Builder {
     }
 
     /// Initializes the filter builder from an environment.
+    #[cfg(feature = "std")]
     pub fn from_env(env: &str) -> Builder {
         let mut builder = Builder::new();
 
-        if let Ok(s) = env::var(env) {
+        if let Ok(s) = std::env::var(env) {
             builder.parse(&s);
         }
 
@@ -108,7 +108,10 @@ impl Builder {
         } = parse_spec(filters);
 
         for error in errors {
+            #[cfg(feature = "std")]
             eprintln!("warning: {error}, ignoring it");
+            #[cfg(not(feature = "std"))]
+            log::warn!("{error}, ignoring it");
         }
 
         self.filter = filter;
@@ -258,8 +261,9 @@ impl fmt::Debug for Filter {
 
 #[cfg(test)]
 mod tests {
+    use alloc::{borrow::ToOwned, vec, vec::Vec};
+
     use log::{Level, LevelFilter};
-    use snapbox::{assert_data_eq, str};
 
     use super::{enabled, Builder, Directive, Filter};
 
@@ -486,10 +490,12 @@ mod tests {
 
     #[test]
     fn try_parse_invalid_filter() {
+        #[allow(unused_variables)]
         let error = Builder::new().try_parse("info,crate1=invalid").unwrap_err();
-        assert_data_eq!(
+        #[cfg(feature = "std")]
+        snapbox::assert_data_eq!(
             error,
-            str!["error parsing logger filter: invalid logging spec 'invalid'"]
+            snapbox::str!["error parsing logger filter: invalid logging spec 'invalid'"]
         );
     }
 

crates/env_filter/src/lib.rs

@@ -38,10 +38,13 @@
 //! ```
 
 #![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(not(feature = "std"), no_std)]
 #![warn(missing_docs)]
 #![warn(clippy::print_stderr)]
 #![warn(clippy::print_stdout)]
 
+extern crate alloc;
+
 mod directive;
 mod filter;
 mod filtered_log;

crates/env_filter/src/op.rs

@@ -1,4 +1,5 @@
-use std::fmt;
+use alloc::string::{String, ToString};
+use core::fmt;
 
 #[derive(Debug, Clone)]
 pub(crate) struct FilterOp {
@@ -24,13 +25,13 @@ impl FilterOp {
 
 #[cfg(not(feature = "regex"))]
 impl FilterOp {
-    pub fn new(spec: &str) -> Result<Self, String> {
+    pub(crate) fn new(spec: &str) -> Result<Self, String> {
         Ok(Self {
             inner: spec.to_string(),
         })
     }
 
-    pub fn is_match(&self, s: &str) -> bool {
+    pub(crate) fn is_match(&self, s: &str) -> bool {
         s.contains(&self.inner)
     }
 }

crates/env_filter/src/parser.rs

@@ -1,6 +1,7 @@
+use alloc::{borrow::ToOwned, format, string::String, vec::Vec};
+use core::fmt::{Display, Formatter};
+
 use log::LevelFilter;
-use std::error::Error;
-use std::fmt::{Display, Formatter};
 
 use crate::Directive;
 use crate::FilterOp;
@@ -46,12 +47,16 @@ pub struct ParseError {
 }
 
 impl Display for ParseError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         write!(f, "error parsing logger filter: {}", self.details)
     }
 }
 
-impl Error for ParseError {}
+#[cfg(feature = "std")]
+impl std::error::Error for ParseError {}
+
+#[cfg(not(feature = "std"))]
+impl core::error::Error for ParseError {}
 
 /// Parse a logging specification string (e.g: `crate1,crate2::mod3,crate3::x=error/foo`)
 /// and return a vector with log directives.
@@ -115,9 +120,13 @@ pub(crate) fn parse_spec(spec: &str) -> ParseResult {
 
 #[cfg(test)]
 mod tests {
+    use alloc::{borrow::ToOwned, string::ToString};
+
     use crate::ParseError;
     use log::LevelFilter;
-    use snapbox::{assert_data_eq, str, Data, IntoData};
+    #[cfg(feature = "std")]
+    use snapbox::{assert_data_eq, str};
+    use snapbox::{Data, IntoData};
 
     use super::{parse_spec, ParseResult};
 
@@ -164,6 +173,7 @@ mod tests {
         assert!(filter.is_none());
 
         assert_eq!(errors.len(), 1);
+        #[cfg(feature = "std")]
         assert_data_eq!(
             &errors[0],
             str!["invalid logging spec 'crate1::mod1=warn=info'"]
@@ -185,6 +195,7 @@ mod tests {
         assert!(filter.is_none());
 
         assert_eq!(errors.len(), 1);
+        #[cfg(feature = "std")]
         assert_data_eq!(&errors[0], str!["invalid logging spec 'noNumber'"]);
     }
 
@@ -203,6 +214,7 @@ mod tests {
         assert!(filter.is_none());
 
         assert_eq!(errors.len(), 1);
+        #[cfg(feature = "std")]
         assert_data_eq!(&errors[0], str!["invalid logging spec 'wrong'"]);
     }
 
@@ -221,6 +233,7 @@ mod tests {
         assert!(filter.is_none());
 
         assert_eq!(errors.len(), 1);
+        #[cfg(feature = "std")]
         assert_data_eq!(&errors[0], str!["invalid logging spec 'wrong'"]);
     }
 
@@ -394,6 +407,7 @@ mod tests {
         assert!(filter.is_some() && filter.unwrap().to_string() == "a.c");
 
         assert_eq!(errors.len(), 1);
+        #[cfg(feature = "std")]
         assert_data_eq!(
             &errors[0],
             str!["invalid logging spec 'crate1::mod1=error=warn'"]
@@ -425,6 +439,7 @@ mod tests {
         assert!(filter.is_none());
 
         assert_eq!(errors.len(), 1);
+        #[cfg(feature = "std")]
         assert_data_eq!(
             &errors[0],
             str!["invalid logging spec 'debug/abc/a.c' (too many '/'s)"]
@@ -446,14 +461,17 @@ mod tests {
         assert!(filter.is_none());
 
         assert_eq!(errors.len(), 2);
-        assert_data_eq!(
-            &errors[0],
-            str!["invalid logging spec 'crate1::mod1=warn=info'"]
-        );
-        assert_data_eq!(
-            &errors[1],
-            str!["invalid logging spec 'crate3=error=error'"]
-        );
+        #[cfg(feature = "std")]
+        {
+            assert_data_eq!(
+                &errors[0],
+                str!["invalid logging spec 'crate1::mod1=warn=info'"]
+            );
+            assert_data_eq!(
+                &errors[1],
+                str!["invalid logging spec 'crate3=error=error'"]
+            );
+        }
     }
 
     #[test]
@@ -471,8 +489,11 @@ mod tests {
         assert!(filter.is_none());
 
         assert_eq!(errors.len(), 2);
-        assert_data_eq!(&errors[0], str!["invalid logging spec 'noNumber'"]);
-        assert_data_eq!(&errors[1], str!["invalid logging spec 'invalid'"]);
+        #[cfg(feature = "std")]
+        {
+            assert_data_eq!(&errors[0], str!["invalid logging spec 'noNumber'"]);
+            assert_data_eq!(&errors[1], str!["invalid logging spec 'invalid'"]);
+        }
     }
 
     #[test]
@@ -490,18 +511,23 @@ mod tests {
         assert!(filter.is_none());
 
         assert_eq!(errors.len(), 2);
-        assert_data_eq!(
-            &errors[0],
-            str!["invalid logging spec 'crate1::mod1=debug=info'"]
-        );
-        assert_data_eq!(&errors[1], str!["invalid logging spec 'invalid'"]);
+        #[cfg(feature = "std")]
+        {
+            assert_data_eq!(
+                &errors[0],
+                str!["invalid logging spec 'crate1::mod1=debug=info'"]
+            );
+            assert_data_eq!(&errors[1], str!["invalid logging spec 'invalid'"]);
+        }
     }
 
     #[test]
     fn parse_error_message_single_error() {
+        #[allow(unused_variables)]
         let error = parse_spec("crate1::mod1=debug=info,crate2=debug")
             .ok()
             .unwrap_err();
+        #[cfg(feature = "std")]
         assert_data_eq!(
             error,
             str!["error parsing logger filter: invalid logging spec 'crate1::mod1=debug=info'"]
@@ -510,9 +536,11 @@ mod tests {
 
     #[test]
     fn parse_error_message_multiple_errors() {
+        #[allow(unused_variables)]
         let error = parse_spec("crate1::mod1=debug=info,crate2=debug,crate3=invalid")
             .ok()
             .unwrap_err();
+        #[cfg(feature = "std")]
         assert_data_eq!(
             error,
             str!["error parsing logger filter: invalid logging spec 'crate1::mod1=debug=info'"]