prettylogger/
json.rs

1use crate::{Logger, Error};
2use std::{
3    fs::{File, read_to_string},
4    io::Write,
5};
6use crate::fileio::{expand_env_vars, expand_tilde};
7
8impl Logger {
9    /// Creates a `Logger` instance from a JSON template as string.
10    ///
11    /// # Example
12    /// ```
13    /// # use prettylogger::Logger;
14    /// let pretty_json = serde_json::to_string_pretty(&Logger::default())
15    ///     .expect("Failed to serialize logger!");
16    /// let raw_json = serde_json::to_string(&Logger::default())
17    ///     .expect("Failed to serialize logger!");
18    /// assert_eq!(Logger::default(), Logger::from_template_str(&pretty_json)
19    ///     .expect("Failed to deserialize logger!"));
20    /// assert_eq!(Logger::default(), Logger::from_template_str(&raw_json)
21    ///     .expect("Failed to deserialize logger!"));
22    /// ```
23    pub fn from_template_str(template: &str) -> Result<Logger, Error> {
24        let result: Result<Logger, serde_json::Error>
25            = serde_json::from_str(&template);
26        match result {
27            Ok(mut logger) => {
28                logger.log_count += 1;
29                logger.show_datetime = logger.log_format.contains("%d");
30
31                return Ok(logger);
32            },
33            Err(e) => Err(Error::new(&e.to_string()))
34        }
35    }
36
37    /// Creates a `Logger` instance from a template file.
38    ///
39    /// Automatically expands environment variables.
40    ///
41    /// # Example
42    /// ```
43    /// # use prettylogger::Logger;
44    /// # let mut path = std::env::temp_dir();
45    /// # path.push("libprettylogger-tests/from-template.json");
46    /// # let path = &path.to_str().unwrap().to_string();
47    /// # Logger::default().save_template(path);
48    /// let mut logger = Logger::from_template(path);
49    /// ```
50    pub fn from_template(path: &str) -> Result<Logger, Error> {
51        let path = expand_env_vars(&expand_tilde(path));
52
53        match read_to_string(path) {
54            Ok(contents) => {
55                Logger::from_template_str(&contents)
56            },
57            Err(e) => Err(Error::new(&e.to_string()))
58        }
59    }
60
61    /// Saves a `Logger` to template file.
62    ///
63    /// Automatically expands environment variables.
64    ///
65    /// # Example
66    /// ```
67    /// # use prettylogger::Logger;
68    /// # let mut path = std::env::temp_dir();
69    /// # path.push("libprettylogger-tests/from-template.json");
70    /// # let path = &path.to_str().unwrap().to_string();
71    /// let mut logger = Logger::default();
72    /// logger.save_template(path);
73    /// ```
74    pub fn save_template(&self, path: &str) -> Result<(), Error> {
75        let path = expand_env_vars(&expand_tilde(path));
76
77        let json: Result<_, serde_json::Error>
78            = serde_json::to_string_pretty(self);
79
80        match json {
81            Ok(json) => {
82                match File::create(path) {
83                    Ok(mut file) => {
84                        match file.write_all(json.as_bytes()) {
85                            Ok(_) => Ok(()),
86                            Err(e) => {
87                                Err(Error::new(&e.to_string()))
88                            }
89                        }
90                    },
91                    Err(e) => Err(Error::new(&e.to_string()))
92                }
93            },
94            Err(e) => Err(Error::new(&e.to_string()))
95        }
96    }
97}