getting format from environment variables

1 files changed, 44 insertions, 24 deletions

diff --git a/src/client/listener.rs b/src/client/listener.rs
index 370af62..6aefbb1 100644
--- a/src/client/listener.rs
+++ b/src/client/listener.rs
@@ -17,20 +17,45 @@
 
 use std::os::unix::net::UnixStream;
 use std::io::{BufReader};
-
+use std::env;
 use bincode::{decode_from_std_read, config};
+
 use crate::daemon::pomo::{Pomo,State};
 
+struct Format {
+    format_work: String,
+    format_work_paused: String,
+    format_work_idle: String,
+    format_break: String,
+    format_break_paused: String,
+    format_break_idle: String,
+    format_long_break: String,
+    format_long_break_paused: String,
+    format_long_break_idle: String,
+}
+
 pub fn start_listener() {
     let sock_path = "/tmp/polydorod.sock";
     let stream = UnixStream::connect(sock_path).unwrap_or_else(|_| panic!("could not connect to daemon"));
     let mut reader = BufReader::new(stream);
 
+    let f = Format {
+        format_work: get_envvar("FORMAT_WORK", "work"),
+        format_work_paused: get_envvar("FORMAT_WORK_PAUSED", "[work]"),
+        format_work_idle: get_envvar("FORMAT_WORK_IDLE", "(work)"),
+        format_break: get_envvar("FORMAT_BREAK", "break"),
+        format_break_paused: get_envvar("FORMAT_BREAK_PAUSED", "[break]"),
+        format_break_idle: get_envvar("FORMAT_BREAK_IDLE", "(break)"),
+        format_long_break: get_envvar("FORMAT_LONG_BREAK", "long break"),
+        format_long_break_paused: get_envvar("FORMAT_LONG_BREAK_PAUSED", "[long break]"),
+        format_long_break_idle: get_envvar("FORMAT_LONG_BREAK_IDLE", "(long break)"),
+    };
+
     loop {
         // blocks until a struct is received
         match decode_from_std_read::<Pomo, _, _>(&mut reader, config::standard()) {
             Ok(p) => {
-                pretty_print(p);
+                pretty_print(&f, p);
             }
             Err(e) => {
                 eprintln!("polydoro listener error: {}", e);
@@ -40,34 +65,29 @@ pub fn start_listener() {
     }
 }
 
-pub fn format_time(secs: u16) -> String {
+// TODO: show remaining time, not time elapsed
+fn format_time(secs: u16) -> String {
     format!("{:02}:{:02}", secs / 60, secs % 60)
 }
 
-pub fn pretty_print(p: Pomo) {
-    let format_work = "work";
-    let format_work_paused = "[work]";
-    let format_work_idle = "(work)";
-    let format_break = "break";
-    let format_break_paused = "[break]";
-    let format_break_idle = "(break)";
-    let format_long_break = "long break";
-    let format_long_break_paused = "[long break]";
-    let format_long_break_idle = "(long break)";
+fn get_envvar(key: &str, def: &str) -> String {
+    env::var(key).unwrap_or_else(|_| def.to_string())
+}
 
-    let f = match p.current_state {
-        State::Work => format_work,
-        State::Break => format_break,
-        State::LongBreak => format_long_break,
+fn pretty_print(f: &Format, p: Pomo) {
+    let format = match p.current_state {
+        State::Work => &f.format_work,
+        State::Break => &f.format_break,
+        State::LongBreak => &f.format_long_break,
 
-        State::WorkPaused => format_work_paused,
-        State::BreakPaused => format_break_paused,
-        State::LongBreakPaused => format_long_break_paused,
+        State::WorkPaused => &f.format_work_paused,
+        State::BreakPaused => &f.format_break_paused,
+        State::LongBreakPaused => &f.format_long_break_paused,
 
-        State::WorkIdle => format_work_idle,
-        State::BreakIdle => format_break_idle,
-        State::LongBreakIdle => format_long_break_idle,
+        State::WorkIdle => &f.format_work_idle,
+        State::BreakIdle => &f.format_break_idle,
+        State::LongBreakIdle => &f.format_long_break_idle,
     };
 
-    println!("{} {} - {}", f, p.counter, format_time(p.secs_elapsed));
+    println!("{} {} - {}", format, p.counter, format_time(p.secs_elapsed));
 }