Upgrade rust/crates/env_logger to 0.8.1 am: 775f0ab2cd am: 87f1b7df87 am: bb9816b0dd

Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/env_logger/+/1474958 Change-Id: I20746365b1f733f7f329a306f0be010e8021271f
author: Chih-Hung Hsieh <chh@google.com> 2020-10-26 23:35:03 +0000
committer: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com> 2020-10-26 23:35:03 +0000
commit: d6946be354ec3c5d7da5ac359a1ed23155666b91 (patch)
tree: 24df3bd9491a6c70c4387b6e8424b56b7ebbefc3
parent: ddd5ec0a18f74966aad80bab7e76d8018839f7f9 (diff)
parent: bb9816b0ddbe86894e267a9ddc12abb82133abb7 (diff)
download: env_logger-d6946be354ec3c5d7da5ac359a1ed23155666b91.tar.gz
22 files changed, 431 insertions, 163 deletions
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 787e6a8..35d1636 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
 {
   "git": {
-    "sha1": "68a170094649c48c6ce7471acf3a33fd2799541c"
+    "sha1": "26e821b94f0b0b9fd3536c0ba7095c1b6c7a3ffe"
   }
 }
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..d2e8979
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,114 @@
+name: Continuous Integration
+
+on:
+  pull_request:
+    paths:
+      - "**.rs"
+      - "Cargo.toml"
+      - "Cargo.lock"
+
+jobs:
+  fmt:
+    name: Source formatting check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+          components: rustfmt
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: -- --check
+
+  check:
+    name: Compilation check
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: true
+      matrix:
+        rust:
+          - stable
+          - beta
+          - nightly
+          - 1.41.0
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+
+      - name: Run cargo check
+        uses: actions-rs/cargo@v1
+        with:
+          command: check
+
+  clippy:
+    name: Lint check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: clippy
+
+      - name: Run lints
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: -- -D warnings
+
+  ci-crate:
+    name: CI crate check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+
+      - name: Run ci crate
+        uses: actions-rs/cargo@v1
+        with:
+          command: run
+          args: -p ci
+
+  crate-example:
+    name: Crate example check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+
+      - name: Run crate example
+        uses: actions-rs/cargo@v1
+        with:
+          command: run
+          args: --example default
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000..4b6110b
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,40 @@
+name: Continuous Integration - Docs
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - "**.rs"
+      - "Cargo.toml"
+      - "Cargo.lock"
+  workflow_dispatch:
+
+jobs:
+  docs:
+    name: Generate crate documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+
+      - name: Generate documentation
+        uses: actions-rs/cargo@v1
+        env:
+          RUSTDOCFLAGS: "--enable-index-page -Zunstable-options"
+        with:
+          command: doc
+          args: --no-deps
+
+      - name: Deploy documentation
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./target/doc
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index af8f18d..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-language: rust
-sudo: false
-rust:
-  - 1.31.0
-  - stable
-  - beta
-  - nightly
-before_script:
-  - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
-script:
-  - if [ "${MINIMAL_VERSIONS}" = "y" ]; then cargo update -Z minimal-versions; fi
-  - cargo run -p ci
-  - cargo run --example default
-after_success:
-  - travis-cargo --only nightly doc-upload
-
-matrix:
-  include:
-    - rust: nightly
-      env: MINIMAL_VERSIONS=y
-
-notifications:
-  email:
-on_success: never
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f849eef..266e24a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,3 @@
 Changes to this crate are tracked via [GitHub Releases][releases].
 
-[releases]: https://github.com/sebasmagri/env_logger/releases
+[releases]: https://github.com/env-logger-rs/env_logger/releases
diff --git a/Cargo.toml b/Cargo.toml
index c34a1ee..d450a0b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@
 [package]
 edition = "2018"
 name = "env_logger"
-version = "0.7.1"
+version = "0.8.1"
 authors = ["The Rust Project Developers"]
 description = "A logging implementation for `log` which is configured via an environment\nvariable.\n"
 documentation = "https://docs.rs/env_logger"
@@ -21,7 +21,7 @@ readme = "README.md"
 keywords = ["logging", "log", "logger"]
 categories = ["development-tools::debugging"]
 license = "MIT/Apache-2.0"
-repository = "https://github.com/sebasmagri/env_logger/"
+repository = "https://github.com/env-logger-rs/env_logger/"
 
 [[test]]
 name = "regexp_filter"
@@ -43,7 +43,7 @@ version = "0.2.5"
 optional = true
 
 [dependencies.humantime]
-version = "1.3"
+version = "2.0.0"
 optional = true
 
 [dependencies.log]
@@ -52,7 +52,9 @@ features = ["std"]
 
 [dependencies.regex]
 version = "1.0.3"
+features = ["std", "perf"]
 optional = true
+default-features = false
 
 [dependencies.termcolor]
 version = "1.0.2"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 148543b..837c72b 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,11 +1,11 @@
 [package]
 name = "env_logger"
 edition = "2018"
-version = "0.7.1" # remember to update html_root_url
+version = "0.8.1" # remember to update html_root_url
 authors = ["The Rust Project Developers"]
 license = "MIT/Apache-2.0"
 readme = "README.md"
-repository = "https://github.com/sebasmagri/env_logger/"
+repository = "https://github.com/env-logger-rs/env_logger/"
 documentation = "https://docs.rs/env_logger"
 description = """
 A logging implementation for `log` which is configured via an environment
@@ -21,9 +21,9 @@ members = [
 
 [dependencies]
 log = { version = "0.4.8", features = ["std"] }
-regex = { version = "1.0.3", optional = true }
+regex = { version = "1.0.3", optional = true, default-features=false, features=["std", "perf"] }
 termcolor = { version = "1.0.2", optional = true }
-humantime = { version = "1.3", optional = true }
+humantime = { version = "2.0.0", optional = true }
 atty = { version = "0.2.5", optional = true }
 
 [[test]]
diff --git a/METADATA b/METADATA
index 63c4f4f..f988ce5 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/env_logger/env_logger-0.7.1.crate"
+    value: "https://static.crates.io/crates/env_logger/env_logger-0.8.1.crate"
   }
-  version: "0.7.1"
+  version: "0.8.1"
   license_type: NOTICE
   last_upgrade_date {
     year: 2020
-    month: 6
-    day: 5
+    month: 10
+    day: 26
   }
 }
diff --git a/README.md b/README.md
index 34e4194..1edd0e3 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,10 @@
-env_logger [![Build Status](https://travis-ci.org/sebasmagri/env_logger.svg?branch=master)](https://travis-ci.org/sebasmagri/env_logger) [![Maintenance](https://img.shields.io/badge/maintenance-actively%20maintained-brightgreen.svg)](https://github.com/sebasmagri/env_logger) [![crates.io](https://img.shields.io/crates/v/env_logger.svg)](https://crates.io/crates/env_logger) [![Documentation](https://img.shields.io/badge/docs-current-blue.svg)](https://docs.rs/env_logger)
+# env_logger
+
+[![Build Status](https://travis-ci.org/env-logger-rs/env_logger.svg?branch=master)](https://travis-ci.org/env-logger-rs/env_logger)
+[![Maintenance](https://img.shields.io/badge/maintenance-actively%20maintained-brightgreen.svg)](https://github.com/env-logger-rs/env_logger)
+[![crates.io](https://img.shields.io/crates/v/env_logger.svg)](https://crates.io/crates/env_logger)
+[![Documentation](https://docs.rs/env_logger/badge.svg)](https://docs.rs/env_logger)
+[![Documentation](https://img.shields.io/badge/docs-master-blue.svg)](https://env-logger-rs.github.io/env_logger/env_logger/index.html)
 ==========
 
 Implements a logger that can be configured via environment variables.
@@ -16,7 +22,7 @@ It must be added along with `log` to the project dependencies:
 ```toml
 [dependencies]
 log = "0.4.0"
-env_logger = "0.7.1"
+env_logger = "0.8.1"
 ```
 
 `env_logger` must be initialized as early as possible in the project. After it's initialized, you can use the `log` macros to do actual logging.
@@ -42,7 +48,7 @@ $ RUST_LOG=info ./main
 [2018-11-03T06:09:06Z INFO  default] starting up
 ```
 
-`env_logger` can be configured in other ways besides an environment variable. See [the examples](https://github.com/sebasmagri/env_logger/tree/master/examples) for more approaches.
+`env_logger` can be configured in other ways besides an environment variable. See [the examples](https://github.com/env-logger-rs/env_logger/tree/master/examples) for more approaches.
 
 ### In tests
 
@@ -53,7 +59,7 @@ Tests can use the `env_logger` crate to see log messages generated during that t
 log = "0.4.0"
 
 [dev-dependencies]
-env_logger = "0.7.1"
+env_logger = "0.8.1"
 ```
 
 ```rust
diff --git a/examples/custom_default_format.rs b/examples/custom_default_format.rs
index 4397924..b04eb60 100644
--- a/examples/custom_default_format.rs
+++ b/examples/custom_default_format.rs
@@ -27,11 +27,10 @@ fn init_logger() {
         .filter("MY_LOG_LEVEL")
         .write_style("MY_LOG_STYLE");
 
-    let mut builder = Builder::from_env(env);
-
-    builder.format_level(false).format_timestamp_nanos();
-
-    builder.init();
+    Builder::from_env(env)
+        .format_level(false)
+        .format_timestamp_nanos()
+        .init();
 }
 
 fn main() {
diff --git a/examples/custom_format.rs b/examples/custom_format.rs
index df5a8e5..d8585a5 100644
--- a/examples/custom_format.rs
+++ b/examples/custom_format.rs
@@ -19,7 +19,8 @@ If you want to control the logging output completely, see the `custom_logger` ex
 
 #[cfg(all(feature = "termcolor", feature = "humantime"))]
 fn main() {
-    use env_logger::{fmt, Builder, Env};
+    use env_logger::{fmt::Color, Builder, Env};
+
     use std::io::Write;
 
     fn init_logger() {
@@ -30,7 +31,7 @@ fn main() {
         Builder::from_env(env)
             .format(|buf, record| {
                 let mut style = buf.style();
-                style.set_bg(fmt::Color::Yellow).set_bold(true);
+                style.set_bg(Color::Yellow).set_bold(true);
 
                 let timestamp = buf.timestamp();
 
diff --git a/examples/custom_logger.rs b/examples/custom_logger.rs
index 85de45b..3d4dc5b 100644
--- a/examples/custom_logger.rs
+++ b/examples/custom_logger.rs
@@ -13,17 +13,19 @@ If you only want to change the way logs are formatted, look at the `custom_forma
 #[macro_use]
 extern crate log;
 
-use env_logger::filter::Filter;
+use env_logger::filter::{Builder, Filter};
+
 use log::{Log, Metadata, Record, SetLoggerError};
 
+const FILTER_ENV: &'static str = "MY_LOG_LEVEL";
+
 struct MyLogger {
     inner: Filter,
 }
 
 impl MyLogger {
     fn new() -> MyLogger {
-        use env_logger::filter::Builder;
-        let mut builder = Builder::from_env("MY_LOG_LEVEL");
+        let mut builder = Builder::from_env(FILTER_ENV);
 
         MyLogger {
             inner: builder.build(),
diff --git a/examples/direct_logger.rs b/examples/direct_logger.rs
index 4ba023f..4d7f39d 100644
--- a/examples/direct_logger.rs
+++ b/examples/direct_logger.rs
@@ -4,13 +4,17 @@ Using `env_logger::Logger` and the `log::Log` trait directly.
 This example doesn't rely on environment variables, or having a static logger installed.
 */
 
-fn record() -> log::Record<'static> {
-    let error_metadata = log::MetadataBuilder::new()
+use env_logger::{Builder, WriteStyle};
+
+use log::{Level, LevelFilter, Log, MetadataBuilder, Record};
+
+fn record() -> Record<'static> {
+    let error_metadata = MetadataBuilder::new()
         .target("myApp")
-        .level(log::Level::Error)
+        .level(Level::Error)
         .build();
 
-    log::Record::builder()
+    Record::builder()
         .metadata(error_metadata)
         .args(format_args!("Error!"))
         .line(Some(433))
@@ -20,16 +24,14 @@ fn record() -> log::Record<'static> {
 }
 
 fn main() {
-    use log::Log;
-
-    let stylish_logger = env_logger::Builder::new()
-        .filter(None, log::LevelFilter::Error)
-        .write_style(env_logger::WriteStyle::Always)
+    let stylish_logger = Builder::new()
+        .filter(None, LevelFilter::Error)
+        .write_style(WriteStyle::Always)
         .build();
 
-    let unstylish_logger = env_logger::Builder::new()
-        .filter(None, log::LevelFilter::Error)
-        .write_style(env_logger::WriteStyle::Never)
+    let unstylish_logger = Builder::new()
+        .filter(None, LevelFilter::Error)
+        .write_style(WriteStyle::Never)
         .build();
 
     stylish_logger.log(&record());
diff --git a/examples/filters_from_code.rs b/examples/filters_from_code.rs
index 4137c91..c877a44 100644
--- a/examples/filters_from_code.rs
+++ b/examples/filters_from_code.rs
@@ -5,10 +5,12 @@ Specify logging filters in code instead of using an environment variable.
 #[macro_use]
 extern crate log;
 
+use env_logger::Builder;
+
+use log::LevelFilter;
+
 fn main() {
-    env_logger::builder()
-        .filter_level(log::LevelFilter::Trace)
-        .init();
+    Builder::new().filter_level(LevelFilter::max()).init();
 
     trace!("some trace log");
     debug!("some debug log");
diff --git a/examples/in_tests.rs b/examples/in_tests.rs
new file mode 100644
index 0000000..c4487cc
--- /dev/null
+++ b/examples/in_tests.rs
@@ -0,0 +1,54 @@
+/*!
+Using `env_logger` in tests.
+
+Log events will be captured by `cargo` and only printed if the test fails.
+You can run this example by calling:
+
+```text
+cargo test --example in_tests
+```
+
+You should see the `it_does_not_work` test fail and include its log output.
+*/
+
+#[cfg_attr(test, macro_use)]
+extern crate log;
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    fn init_logger() {
+        let _ = env_logger::builder()
+            // Include all events in tests
+            .filter_level(log::LevelFilter::max())
+            // Ensure events are captured by `cargo test`
+            .is_test(true)
+            // Ignore errors initializing the logger if tests race to configure it
+            .try_init();
+    }
+
+    #[test]
+    fn it_works() {
+        init_logger();
+
+        let a = 1;
+        let b = 2;
+
+        debug!("checking whether {} + {} = 3", a, b);
+
+        assert_eq!(3, a + b);
+    }
+
+    #[test]
+    fn it_does_not_work() {
+        init_logger();
+
+        let a = 1;
+        let b = 2;
+
+        debug!("checking whether {} + {} = 6", a, b);
+
+        assert_eq!(6, a + b);
+    }
+}
diff --git a/examples/syslog_friendly_format.rs b/examples/syslog_friendly_format.rs
new file mode 100644
index 0000000..9809ab3
--- /dev/null
+++ b/examples/syslog_friendly_format.rs
@@ -0,0 +1,24 @@
+use std::io::Write;
+
+fn main() {
+    match std::env::var("RUST_LOG_STYLE") {
+        Ok(s) if s == "SYSTEMD" => env_logger::builder()
+            .format(|buf, record| {
+                writeln!(
+                    buf,
+                    "<{}>{}: {}",
+                    match record.level() {
+                        log::Level::Error => 3,
+                        log::Level::Warn => 4,
+                        log::Level::Info => 6,
+                        log::Level::Debug => 7,
+                        log::Level::Trace => 7,
+                    },
+                    record.target(),
+                    record.args()
+                )
+            })
+            .init(),
+        _ => env_logger::init(),
+    };
+}
diff --git a/rust-toolchain b/rust-toolchain
new file mode 100644
index 0000000..033080c
--- /dev/null
+++ b/rust-toolchain
@@ -0,0 +1 @@
+1.41.0
diff --git a/src/filter/mod.rs b/src/filter/mod.rs
index a994f4d..ba81302 100644
--- a/src/filter/mod.rs
+++ b/src/filter/mod.rs
@@ -52,7 +52,6 @@
 //!
 //!     fn flush(&self) {}
 //! }
-//! # fn main() {}
 //! ```
 //!
 //! [Enabling Logging]: ../index.html#enabling-logging
@@ -92,24 +91,18 @@ pub struct Filter {
 /// ## Example
 ///
 /// ```
-/// #[macro_use]
-/// extern crate log;
-/// extern crate env_logger;
-///
-/// use std::env;
-/// use std::io;
+/// # #[macro_use] extern crate log;
+/// # use std::env;
 /// use env_logger::filter::Builder;
 ///
-/// fn main() {
-///     let mut builder = Builder::new();
-///
-///     // Parse a logging filter from an environment variable.
-///     if let Ok(rust_log) = env::var("RUST_LOG") {
-///        builder.parse(&rust_log);
-///     }
+/// let mut builder = Builder::new();
 ///
-///     let filter = builder.build();
+/// // Parse a logging filter from an environment variable.
+/// if let Ok(rust_log) = env::var("RUST_LOG") {
+///     builder.parse(&rust_log);
 /// }
+///
+/// let filter = builder.build();
 /// ```
 ///
 /// [`Filter`]: struct.Filter.html
@@ -132,20 +125,15 @@ impl Filter {
     /// # Example
     ///
     /// ```rust
-    /// extern crate log;
-    /// extern crate env_logger;
-    ///
     /// use log::LevelFilter;
     /// use env_logger::filter::Builder;
     ///
-    /// fn main() {
-    ///     let mut builder = Builder::new();
-    ///     builder.filter(Some("module1"), LevelFilter::Info);
-    ///     builder.filter(Some("module2"), LevelFilter::Error);
+    /// let mut builder = Builder::new();
+    /// builder.filter(Some("module1"), LevelFilter::Info);
+    /// builder.filter(Some("module2"), LevelFilter::Error);
     ///
-    ///     let filter = builder.build();
-    ///     assert_eq!(filter.filter(), LevelFilter::Info);
-    /// }
+    /// let filter = builder.build();
+    /// assert_eq!(filter.filter(), LevelFilter::Info);
     /// ```
     pub fn filter(&self) -> LevelFilter {
         self.directives
@@ -310,9 +298,9 @@ fn parse_spec(spec: &str) -> (Vec<Directive>, Option<inner::Filter>) {
         );
         return (dirs, None);
     }
-    mods.map(|m| {
+    if let Some(m) = mods {
         for s in m.split(',') {
-            if s.len() == 0 {
+            if s.is_empty() {
                 continue;
             }
             let mut parts = s.split('=');
@@ -352,9 +340,9 @@ fn parse_spec(spec: &str) -> (Vec<Directive>, Option<inner::Filter>) {
                 level: log_level,
             });
         }
-    });
+    }
 
-    let filter = filter.map_or(None, |filter| match inner::Filter::new(filter) {
+    let filter = filter.and_then(|filter| match inner::Filter::new(filter) {
         Ok(re) => Some(re),
         Err(e) => {
             eprintln!("warning: invalid regex filter - {}", e);
@@ -362,7 +350,7 @@ fn parse_spec(spec: &str) -> (Vec<Directive>, Option<inner::Filter>) {
         }
     });
 
-    return (dirs, filter);
+    (dirs, filter)
 }
 
 // Check whether a level and target are enabled by the set of directives.
diff --git a/src/fmt/mod.rs b/src/fmt/mod.rs
index e699e21..558c4d9 100644
--- a/src/fmt/mod.rs
+++ b/src/fmt/mod.rs
@@ -136,13 +136,14 @@ impl fmt::Debug for Formatter {
     }
 }
 
+pub(crate) type FormatFn = Box<dyn Fn(&mut Formatter, &Record) -> io::Result<()> + Sync + Send>;
+
 pub(crate) struct Builder {
     pub format_timestamp: Option<TimestampPrecision>,
     pub format_module_path: bool,
     pub format_level: bool,
     pub format_indent: Option<usize>,
-    #[allow(unknown_lints, bare_trait_objects)]
-    pub custom_format: Option<Box<Fn(&mut Formatter, &Record) -> io::Result<()> + Sync + Send>>,
+    pub custom_format: Option<FormatFn>,
     built: bool,
 }
 
@@ -165,8 +166,7 @@ impl Builder {
     /// If the `custom_format` is `Some`, then any `default_format` switches are ignored.
     /// If the `custom_format` is `None`, then a default format is returned.
     /// Any `default_format` switches set to `false` won't be written by the format.
-    #[allow(unknown_lints, bare_trait_objects)]
-    pub fn build(&mut self) -> Box<Fn(&mut Formatter, &Record) -> io::Result<()> + Sync + Send> {
+    pub fn build(&mut self) -> FormatFn {
         assert!(!self.built, "attempt to re-use consumed builder");
 
         let built = mem::replace(
@@ -230,6 +230,7 @@ impl<'a> DefaultFormat<'a> {
                 .style()
                 .set_color(Color::Black)
                 .set_intense(true)
+                .clone()
                 .into_value(text)
         }
         #[cfg(not(feature = "termcolor"))]
diff --git a/src/fmt/writer/atty.rs b/src/fmt/writer/atty.rs
index f671841..343539c 100644
--- a/src/fmt/writer/atty.rs
+++ b/src/fmt/writer/atty.rs
@@ -9,8 +9,6 @@ from being printed.
 
 #[cfg(feature = "atty")]
 mod imp {
-    use atty;
-
     pub(in crate::fmt) fn is_stdout() -> bool {
         atty::is(atty::Stream::Stdout)
     }
diff --git a/src/fmt/writer/termcolor/extern_impl.rs b/src/fmt/writer/termcolor/extern_impl.rs
index 2d38e37..4324a45 100644
--- a/src/fmt/writer/termcolor/extern_impl.rs
+++ b/src/fmt/writer/termcolor/extern_impl.rs
@@ -51,8 +51,8 @@ impl Formatter {
     pub fn default_level_style(&self, level: Level) -> Style {
         let mut level_style = self.style();
         match level {
-            Level::Trace => level_style.set_color(Color::Black).set_intense(true),
-            Level::Debug => level_style.set_color(Color::White),
+            Level::Trace => level_style.set_color(Color::Cyan),
+            Level::Debug => level_style.set_color(Color::Blue),
             Level::Info => level_style.set_color(Color::Green),
             Level::Warn => level_style.set_color(Color::Yellow),
             Level::Error => level_style.set_color(Color::Red).set_bold(true),
@@ -370,9 +370,9 @@ impl Style {
     }
 
     /// Wrap a value in the style by taking ownership of it.
-    pub(crate) fn into_value<T>(&mut self, value: T) -> StyledValue<'static, T> {
+    pub(crate) fn into_value<T>(self, value: T) -> StyledValue<'static, T> {
         StyledValue {
-            style: Cow::Owned(self.clone()),
+            style: Cow::Owned(self),
             value,
         }
     }
@@ -451,6 +451,7 @@ impl_styled_value_fmt!(
 ///
 /// Hexadecimal numbers are written with a `0x` prefix.
 #[allow(missing_docs)]
+#[non_exhaustive]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Color {
     Black,
@@ -463,8 +464,6 @@ pub enum Color {
     White,
     Ansi256(u8),
     Rgb(u8, u8, u8),
-    #[doc(hidden)]
-    __Nonexhaustive,
 }
 
 impl Color {
@@ -480,7 +479,6 @@ impl Color {
             Color::White => Some(termcolor::Color::White),
             Color::Ansi256(value) => Some(termcolor::Color::Ansi256(value)),
             Color::Rgb(r, g, b) => Some(termcolor::Color::Rgb(r, g, b)),
-            _ => None,
         }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 4151836..4fa4055 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -15,20 +15,16 @@
 //! ## Example
 //!
 //! ```
-//! #[macro_use] extern crate log;
+//! use log::{debug, error, log_enabled, info, Level};
 //!
-//! use log::Level;
+//! env_logger::init();
 //!
-//! fn main() {
-//!     env_logger::init();
+//! debug!("this is a debug {}", "message");
+//! error!("this is printed by default");
 //!
-//!     debug!("this is a debug {}", "message");
-//!     error!("this is printed by default");
-//!
-//!     if log_enabled!(Level::Info) {
-//!         let x = 3 * 4; // expensive computation
-//!         info!("the answer was: {}", x);
-//!     }
+//! if log_enabled!(Level::Info) {
+//!     let x = 3 * 4; // expensive computation
+//!     info!("the answer was: {}", x);
 //! }
 //! ```
 //!
@@ -146,7 +142,6 @@
 //!
 //! ```
 //! # #[macro_use] extern crate log;
-//! # fn main() {}
 //! #[cfg(test)]
 //! mod tests {
 //!     fn init() {
@@ -225,7 +220,7 @@
 //! ```
 //! use env_logger::Env;
 //!
-//! env_logger::from_env(Env::default().default_filter_or("warn")).init();
+//! env_logger::Builder::from_env(Env::default().default_filter_or("warn")).init();
 //! ```
 //!
 //! [log-crate-url]: https://docs.rs/log/
@@ -237,7 +232,7 @@
 #![doc(
     html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
     html_favicon_url = "https://www.rust-lang.org/static/images/favicon.ico",
-    html_root_url = "https://docs.rs/env_logger/0.7.1"
+    html_root_url = "https://docs.rs/env_logger/0.8.1"
 )]
 #![cfg_attr(test, deny(warnings))]
 // When compiled for the rustc compiler itself we want to make sure that this is
@@ -257,13 +252,13 @@ pub use self::fmt::glob::*;
 
 use self::filter::Filter;
 use self::fmt::writer::{self, Writer};
-use self::fmt::Formatter;
+use self::fmt::{FormatFn, Formatter};
 
 /// The default name for the environment variable to read filters from.
-pub const DEFAULT_FILTER_ENV: &'static str = "RUST_LOG";
+pub const DEFAULT_FILTER_ENV: &str = "RUST_LOG";
 
 /// The default name for the environment variable to read style preferences from.
-pub const DEFAULT_WRITE_STYLE_ENV: &'static str = "RUST_LOG_STYLE";
+pub const DEFAULT_WRITE_STYLE_ENV: &str = "RUST_LOG_STYLE";
 
 /// Set of environment variables to configure from.
 ///
@@ -309,8 +304,7 @@ struct Var<'a> {
 pub struct Logger {
     writer: Writer,
     filter: Filter,
-    #[allow(unknown_lints, bare_trait_objects)]
-    format: Box<Fn(&mut Formatter, &Record) -> io::Result<()> + Sync + Send>,
+    format: FormatFn,
 }
 
 /// `Builder` acts as builder for initializing a `Logger`.
@@ -321,23 +315,20 @@ pub struct Logger {
 /// # Examples
 ///
 /// ```
-/// #[macro_use] extern crate log;
-///
-/// use std::env;
-/// use std::io::Write;
-/// use log::LevelFilter;
+/// # #[macro_use] extern crate log;
+/// # use std::io::Write;
 /// use env_logger::Builder;
+/// use log::LevelFilter;
 ///
-/// fn main() {
-///     let mut builder = Builder::from_default_env();
+/// let mut builder = Builder::from_default_env();
 ///
-///     builder.format(|buf, record| writeln!(buf, "{} - {}", record.level(), record.args()))
-///            .filter(None, LevelFilter::Info)
-///            .init();
+/// builder
+///     .format(|buf, record| writeln!(buf, "{} - {}", record.level(), record.args()))
+///     .filter(None, LevelFilter::Info)
+///     .init();
 ///
-///     error!("error message");
-///     info!("info message");
-/// }
+/// error!("error message");
+/// info!("info message");
 /// ```
 #[derive(Default)]
 pub struct Builder {
@@ -359,16 +350,15 @@ impl Builder {
     /// Create a new builder and configure filters and style:
     ///
     /// ```
-    /// # fn main() {
     /// use log::LevelFilter;
     /// use env_logger::{Builder, WriteStyle};
     ///
     /// let mut builder = Builder::new();
     ///
-    /// builder.filter(None, LevelFilter::Info)
-    ///        .write_style(WriteStyle::Always)
-    ///        .init();
-    /// # }
+    /// builder
+    ///     .filter(None, LevelFilter::Info)
+    ///     .write_style(WriteStyle::Always)
+    ///     .init();
     /// ```
     ///
     /// [`filter`]: #method.filter
@@ -412,17 +402,61 @@ impl Builder {
         E: Into<Env<'a>>,
     {
         let mut builder = Builder::new();
+        builder.parse_env(env);
+        builder
+    }
+
+    /// Applies the configuration from the environment.
+    ///
+    /// This function allows a builder to be configured with default parameters,
+    /// to be then overridden by the environment.
+    ///
+    /// # Examples
+    ///
+    /// Initialise a logger with filter level `Off`, then override the log
+    /// filter from an environment variable called `MY_LOG`:
+    ///
+    /// ```
+    /// use log::LevelFilter;
+    /// use env_logger::Builder;
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder.filter_level(LevelFilter::Off);
+    /// builder.parse_env("MY_LOG");
+    /// builder.init();
+    /// ```
+    ///
+    /// Initialise a logger with filter level `Off`, then use the `MY_LOG`
+    /// variable to override filtering and `MY_LOG_STYLE` to override  whether
+    /// or not to write styles:
+    ///
+    /// ```
+    /// use log::LevelFilter;
+    /// use env_logger::{Builder, Env};
+    ///
+    /// let env = Env::new().filter("MY_LOG").write_style("MY_LOG_STYLE");
+    ///
+    /// let mut builder = Builder::new();
+    /// builder.filter_level(LevelFilter::Off);
+    /// builder.parse_env(env);
+    /// builder.init();
+    /// ```
+    pub fn parse_env<'a, E>(&mut self, env: E) -> &mut Self
+    where
+        E: Into<Env<'a>>,
+    {
         let env = env.into();
 
         if let Some(s) = env.get_filter() {
-            builder.parse_filters(&s);
+            self.parse_filters(&s);
         }
 
         if let Some(s) = env.get_write_style() {
-            builder.parse_write_style(&s);
+            self.parse_write_style(&s);
         }
 
-        builder
+        self
     }
 
     /// Initializes the log builder from the environment using default variable names.
@@ -447,6 +481,32 @@ impl Builder {
         Self::from_env(Env::default())
     }
 
+    /// Applies the configuration from the environment using default variable names.
+    ///
+    /// This method is a convenient way to call `parse_env(Env::default())` without
+    /// having to use the `Env` type explicitly. The builder will use the
+    /// [default environment variables].
+    ///
+    /// # Examples
+    ///
+    /// Initialise a logger with filter level `Off`, then configure it using the
+    /// default environment variables:
+    ///
+    /// ```
+    /// use log::LevelFilter;
+    /// use env_logger::Builder;
+    ///
+    /// let mut builder = Builder::new();
+    /// builder.filter_level(LevelFilter::Off);
+    /// builder.parse_default_env();
+    /// builder.init();
+    /// ```
+    ///
+    /// [default environment variables]: struct.Env.html#default-environment-variables
+    pub fn parse_default_env(&mut self) -> &mut Self {
+        self.parse_env(Env::default())
+    }
+
     /// Sets the format function for formatting the log output.
     ///
     /// This function is called on each record logged and should format the
@@ -538,17 +598,15 @@ impl Builder {
     ///
     /// # Examples
     ///
-    /// Only include messages for warning and above for logs in `path::to::module`:
+    /// Only include messages for info and above for logs in `path::to::module`:
     ///
     /// ```
-    /// # fn main() {
-    /// use log::LevelFilter;
     /// use env_logger::Builder;
+    /// use log::LevelFilter;
     ///
     /// let mut builder = Builder::new();
     ///
     /// builder.filter_module("path::to::module", LevelFilter::Info);
-    /// # }
     /// ```
     pub fn filter_module(&mut self, module: &str, level: LevelFilter) -> &mut Self {
         self.filter.filter_module(module, level);
@@ -559,17 +617,15 @@ impl Builder {
     ///
     /// # Examples
     ///
-    /// Only include messages for warning and above for logs in `path::to::module`:
+    /// Only include messages for info and above for logs in `path::to::module`:
     ///
     /// ```
-    /// # fn main() {
-    /// use log::LevelFilter;
     /// use env_logger::Builder;
+    /// use log::LevelFilter;
     ///
     /// let mut builder = Builder::new();
     ///
     /// builder.filter_level(LevelFilter::Info);
-    /// # }
     /// ```
     pub fn filter_level(&mut self, level: LevelFilter) -> &mut Self {
         self.filter.filter_level(level);
@@ -583,17 +639,15 @@ impl Builder {
     ///
     /// # Examples
     ///
-    /// Only include messages for warning and above for logs in `path::to::module`:
+    /// Only include messages for info and above for logs in `path::to::module`:
     ///
     /// ```
-    /// # fn main() {
-    /// use log::LevelFilter;
     /// use env_logger::Builder;
+    /// use log::LevelFilter;
     ///
     /// let mut builder = Builder::new();
     ///
     /// builder.filter(Some("path::to::module"), LevelFilter::Info);
-    /// # }
     /// ```
     pub fn filter(&mut self, module: Option<&str>, level: LevelFilter) -> &mut Self {
         self.filter.filter(module, level);
@@ -1054,7 +1108,6 @@ pub fn init() {
 /// and `MY_LOG_STYLE` for writing colors:
 ///
 /// ```
-/// # extern crate env_logger;
 /// use env_logger::{Builder, Env};
 ///
 /// # fn run() -> Result<(), Box<::std::error::Error>> {
@@ -1064,7 +1117,7 @@ pub fn init() {
 ///
 /// Ok(())
 /// # }
-/// # fn main() { run().unwrap(); }
+/// # run().unwrap();
 /// ```
 ///
 /// # Errors
@@ -1114,6 +1167,9 @@ where
 /// Create a new builder with the default environment variables.
 ///
 /// The builder can be configured before being initialized.
+/// This is a convenient way of calling [`Builder::from_default_env`].
+///
+/// [`Builder::from_default_env`]: struct.Builder.html#method.from_default_env
 pub fn builder() -> Builder {
     Builder::from_default_env()
 }
@@ -1121,6 +1177,10 @@ pub fn builder() -> Builder {
 /// Create a builder from the given environment variables.
 ///
 /// The builder can be configured before being initialized.
+#[deprecated(
+    since = "0.8.0",
+    note = "Prefer `env_logger::Builder::from_env()` instead."
+)]
 pub fn from_env<'a, E>(env: E) -> Builder
 where
     E: Into<Env<'a>>,
author	Chih-Hung Hsieh <chh@google.com>	2020-10-26 23:35:03 +0000
committer	Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>	2020-10-26 23:35:03 +0000
commit	d6946be354ec3c5d7da5ac359a1ed23155666b91 (patch)
tree	24df3bd9491a6c70c4387b6e8424b56b7ebbefc3
parent	ddd5ec0a18f74966aad80bab7e76d8018839f7f9 (diff)
parent	bb9816b0ddbe86894e267a9ddc12abb82133abb7 (diff)
download	env_logger-d6946be354ec3c5d7da5ac359a1ed23155666b91.tar.gz