neolog 0.0.2

an easy way to log to a file in rust
Documentation 
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
98
99
100
101
102
103

use std::{fs::{self, File}, env, path::Path, io::{self, Write}};

#[allow(non_camel_case_types)]
pub struct neologFile {
    file: File,
    logging_level: i32
}

pub fn init(file: &str, level: Option<&str>) -> Result<neologFile, io::Error> {
    let logfile = Path::new(&env::current_dir().unwrap()).join(file);
    match fs::metadata(logfile.clone()){
        Ok(_) => (),
        Err(_) => {
            match fs::File::create(logfile.clone()){
                Ok(_) => (),
                Err(e) => {
                    eprintln!("neolog error: {}", e);
                    return Err(e)
                }
            }
        },
    };

    let file = match fs::OpenOptions::new().append(true).open(logfile.clone()){
        Ok(f) => f,
        Err(e) => {
            eprintln!("neolog error: {}", e);
            return Err(e)
        }
    };

    let logging_level: i32 = match level.unwrap_or("debug").to_lowercase().as_str() {
        "debug" => 2, // only debugging messages called by debug() and any errors
        "critical" => 4, // only errors called by critical()
        "error" => 3, // only errors called by error() or critical()
        "all" => 1, // all messages specified by info() or any other function
        "verbose" => 1,
        _ => 2, // default to debug if any other value is presented
    };

    return Ok(neologFile{file, logging_level})
}

fn log(message: String, mut fileref: neologFile) -> Result<neologFile, io::Error> {
    match fileref.file.write_all(&message.as_bytes()) {
        Ok(_) => return Ok(fileref),
        Err(e) => return Err(e),
    }
}

pub fn debug(mut message: String, logfile: neologFile) -> Result<neologFile, io::Error> {
    let line_number = line!();
    message = format!("DEBUG (line {}): {}", line_number, message);
    if logfile.logging_level <= 2 {
        match log(message, logfile){
            Ok(o) => Ok(o),
            Err(e) => Err(e)
        }
    }
    else {
        Ok(logfile)
    }
}

pub fn critical(mut message: String, logfile: neologFile) -> Result<neologFile, io::Error> {
    let line_number = line!();
    message = format!("## CRITICAL ERROR at line {} ##\n{}\n###   ###", line_number, message);
    if logfile.logging_level <= 2 {
        match log(message, logfile){
            Ok(o) => Ok(o),
            Err(e) => Err(e)
        }
    }
    else {
        Ok(logfile)
    }
}

pub fn error(mut message: String, logfile: neologFile) -> Result<neologFile, io::Error> {
    let line_number = line!();
    message = format!("## ERROR at line {} ##: {}", line_number, message);
    if logfile.logging_level <= 2 {
        match log(message, logfile){
            Ok(o) => Ok(o),
            Err(e) => Err(e)
        }
    }
    else {
        Ok(logfile)
    }
}

pub fn info(message: String, logfile: neologFile) -> Result<neologFile, io::Error> {
    if logfile.logging_level <= 2 {
        match log(message, logfile){
            Ok(o) => Ok(o),
            Err(e) => Err(e)
        }
    }
    else {
        Ok(logfile)
    }
}