1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

/*!
# [`mxo_env_logger`](https://github.com/biluohc/mxo_env_logger)
Another `env_logger` wrapped.

## Cargo.toml: 
```toml
[dependencies]
mxo_env_logger = "^0.1"
log = "^0.3.8"
```

## Code: 
```
#[macro_use]
extern crate log;

extern crate mxo_env_logger;
use mxo_env_logger::*; // * contains StdErr(std::error::Error), so can use `e.description()` direct.

fn main() {
    init();

    trace!("Trace her"); // default closed.
    info!("Info u");
    warn!("Warning her");
    error!("Error world!");

    std::fs::File::open("Hentai.you").log_err(|e| error!("File open failed: {:?}", e.description()));
    std::env::args().nth(1000).ok_or("No 1000 Args").log_err(|e| error!("{}", e));
}
```

## Output: 
```sh
INFO #main::mock:26: Info u
WARN #main::mock:27: Warning her
ERROR#main::mock:28: Error world!
ERROR#main:12: File open failed: "entity not found"
ERROR#main:16: No 1000 Args
```
*/
extern crate log;
use log::{LogLevelFilter, LogRecord, SetLoggerError};

extern crate env_logger;
use env_logger::LogBuilder;

use std::result::Result;
use std::env;

pub use std::error::Error as StdErr;

/// Initializes the global logger with an env logger.
pub fn init() -> Result<(), SetLoggerError> {
    let format = |record: &LogRecord| {
        format!(
            "{:5}#{}:{}: {}",
            record.level(),
            record.target(),
            record.location().line(),
            record.args()
        )
    };

    let mut builder = LogBuilder::new();
    builder.format(format).filter(None, LogLevelFilter::Info);

    env::var("RUST_LOG").ok().map(|v| builder.parse(&v));
    builder.init()
}

/**
 Use like `map_err`, but it return the origin `E` rather than a new `E`(The `FnOnce` `F` not eat `E`).

 Ps: the macros belongs to `log` crate.

 ```sh
    std::fs::File::open("Hentai.you").log_err(|e| error!("File open failed: {:?}", e.description()));

    std::env::args().nth(1000).ok_or("No 1000 Args").log_err(|e| error!("{}", e));
 ```
 */
pub trait LogErr<E> {
    fn log_err<F: FnOnce(&E)>(self, f: F) -> Self;
}

impl<T, E> LogErr<E> for Result<T, E> {
    fn log_err<F: FnOnce(&E)>(self, f: F) -> Self {
        match self {
            Ok(o) => Ok(o),
            Err(e) => {
                f(&e);
                Err(e)
            }
        }
    }
}