refactored code

1 files changed, 300 insertions, 0 deletions

diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..3af6f72
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,300 @@
+use chrono::prelude::*;
+use std::env;
+use std::fs::File;
+use std::io::Error;
+use std::io::Read;
+use std::process::Command;
+use std::thread;
+use std::time::Duration;
+use yaml_rust::{yaml, YamlLoader};
+
+pub struct Config {
+    pub seperator: String,
+    pub time: Time,
+    pub memory: Memory,
+    pub disk: Disk,
+    pub volume: Volume,
+}
+
+pub struct Time {
+    pub format: String,
+    pub icon: String,
+}
+
+pub struct Memory {
+    pub icon: String,
+    pub enabled: bool,
+}
+
+pub struct Disk {
+    pub icon: String,
+    pub enabled: bool,
+}
+
+pub struct Volume {
+    pub icon: String,
+    pub enabled: bool,
+}
+
+pub fn load_config() -> Result<Config, Error> {
+    let yml_source = env::var("HOME").unwrap() + "/.config/rsblocks/rsblocks.yml";
+    let mut data = String::new();
+    let mut file = match File::open(yml_source) {
+        Ok(file) => file,
+        Err(_) => {
+            println!("~/.config/rsblocks/rsblocks.yml file not found, loading defaults!");
+            return Ok(load_defaults());
+        }
+    };
+    file.read_to_string(&mut data)?;
+
+    let yml_content = &YamlLoader::load_from_str(&data).unwrap()[0];
+    let config = gen_default_config(yml_content);
+    Ok(config)
+}
+
+fn gen_default_config(doc: &yaml::Yaml) -> Config {
+    // setting icons
+    let seperator = get_or_set_string(doc, "general", "seperator", "|");
+    let time_icon = get_or_set_string(doc, "time", "icon", "");
+    let time_format = get_or_set_string(doc, "time", "format", "%T");
+    let mem_icon = get_or_set_string(doc, "memory", "icon", "");
+    let disk_icon = get_or_set_string(doc, "disk", "icon", "");
+    let volume_icon = get_or_set_string(doc, "volume", "icon", "");
+
+    // everything false by default
+    let disk_enabled = get_or_set_bool(doc, "disk", "enable");
+    let memory_enabled = get_or_set_bool(doc, "memory", "enable");
+    let volume_enabled = get_or_set_bool(doc, "volume", "enable");
+
+    Config {
+        seperator,
+        time: Time {
+            format: time_format,
+            icon: time_icon,
+        },
+        memory: Memory {
+            icon: mem_icon,
+            enabled: memory_enabled,
+        },
+        disk: Disk {
+            icon: disk_icon,
+            enabled: disk_enabled,
+        },
+        volume: Volume {
+            icon: volume_icon,
+            enabled: volume_enabled,
+        },
+    }
+}
+
+// getting a boolean value from rsblocks.yml file or set it false if it does not exist
+fn get_or_set_bool(doc: &yaml::Yaml, parent: &str, child: &str) -> bool {
+    let val: bool;
+    if doc[parent][child].is_badvalue() {
+        val = false;
+    } else {
+        val = doc[parent][child].as_bool().unwrap()
+    }
+    val
+}
+
+// getting a String value from the rsblocks.yml file or set the default in the last parameter
+fn get_or_set_string(doc: &yaml::Yaml, parent: &str, child: &str, default_val: &str) -> String {
+    let val: String;
+    if doc[parent][child].is_badvalue() {
+        val = String::from(default_val)
+    } else {
+        val = String::from(doc[parent][child].as_str().unwrap());
+    }
+
+    val
+}
+
+fn load_defaults() -> Config {
+    Config {
+        seperator: String::from("|"),
+        time: Time {
+            format: String::from("%T"),
+            icon: String::from(""),
+        },
+        memory: Memory {
+            icon: String::from(""),
+            enabled: false,
+        },
+        disk: Disk {
+            icon: String::from(""),
+            enabled: false,
+        },
+        volume: Volume {
+            icon: String::from(""),
+            enabled: false,
+        },
+    }
+}
+/* LOADING CONFIGS ENDS HERE  */
+
+/* Running the program:
+
+TODO: this is sucks, i want to update each one in a diffrent delay, maybe i'll try to use threads
+*/
+pub fn run(config: Config) {
+    loop {
+        let mut bar = String::from("");
+
+        // the order of the IF's below matters to the final format
+
+        if config.volume.enabled {
+            // volume return String
+            bar.push_str(&get_sound(&config));
+        }
+
+        if config.disk.enabled {
+            // disk_free return String
+            bar.push_str(&disk_free(&config));
+        }
+
+        if config.memory.enabled {
+            // mem return Result
+            bar.push_str(&mem(&config).unwrap());
+        }
+
+        bar.push_str(&fmt_date(&config));
+
+        Command::new("xsetroot")
+            .arg("-name")
+            .arg(bar)
+            .output()
+            .unwrap();
+
+        thread::sleep(Duration::from_millis(75));
+    }
+}
+
+// format bar date/time
+pub fn fmt_date(config: &Config) -> String {
+    let now = Local::now();
+
+    format!(
+        "  {}  {}  {}",
+        config.time.icon,
+        now.format(&config.time.format),
+        config.seperator
+    )
+}
+
+pub fn disk_free(config: &Config) -> String {
+    let cmd = Command::new("sh")
+        .arg("-c")
+        .args(&["df -h"])
+        .output()
+        .unwrap();
+    let output = String::from_utf8_lossy(&cmd.stdout);
+    let mut disk_used = String::new();
+    for line in output.lines() {
+        if line.ends_with('/') {
+            let splited = line.split_whitespace().collect::<Vec<&str>>();
+            disk_used = splited[2].to_string();
+            break;
+        }
+    }
+    format!(
+        "  {}  {}  {}",
+        config.disk.icon, disk_used, config.seperator
+    )
+}
+
+// TODO: what a horrible solution to get the sound, i dont like it
+//       find another way you dumb fuck
+
+pub fn get_sound(config: &Config) -> String {
+    let cmd_content = Command::new("amixer")
+        .args(&["-D", "pulse", "get", "Master"])
+        .output()
+        .expect("Make sure that you have alsa-utils installed on your system");
+
+    let vol: String = String::from_utf8_lossy(&cmd_content.stdout)
+        .lines()
+        .last()
+        .expect("failed to get sound volume")
+        .split('[')
+        .collect::<Vec<&str>>()[1]
+        .split(']')
+        .collect::<Vec<&str>>()[0]
+        .trim()
+        .to_string();
+
+    format!("  {}  {}  {}", config.volume.icon, vol, config.seperator)
+}
+
+pub fn mem(config: &Config) -> Result<String, std::io::Error> {
+    let mut buf = String::new();
+
+    File::open("/proc/meminfo")?.read_to_string(&mut buf)?;
+
+    let mut mem_total: u32 = 0;
+    let mut shmem: u32 = 0;
+    let mut mem_free: u32 = 0;
+    let mut mem_buffers: u32 = 0;
+    let mut mem_cached: u32 = 0;
+    let mut mem_srecl: u32 = 0;
+
+    for line in buf.lines() {
+        if mem_total > 0
+            && shmem > 0
+            && mem_free > 0
+            && mem_buffers > 0
+            && mem_cached > 0
+            && mem_srecl > 0
+        {
+            break;
+        }
+        if line.starts_with("MemTotal") {
+            assign_val(line, &mut mem_total);
+        }
+        if line.starts_with("SReclaimable") {
+            assign_val(line, &mut mem_srecl)
+        }
+        if line.starts_with("Cached") {
+            assign_val(line, &mut mem_cached)
+        }
+
+        if line.starts_with("Shmem") {
+            assign_val(line, &mut shmem);
+        }
+
+        if line.starts_with("MemFree") {
+            assign_val(line, &mut mem_free);
+        }
+        if line.starts_with("Buffers") {
+            assign_val(line, &mut mem_buffers);
+        }
+    }
+
+    let mem_used = (mem_total + shmem - mem_free - mem_buffers - mem_cached - mem_srecl) / 1024;
+    let result: String;
+    if mem_used > 1000 {
+        result = format!(
+            "  {}  {:.1}G  {}",
+            config.memory.icon,
+            mem_used as f32 / 1000.0,
+            config.seperator
+        );
+    } else {
+        result = format!(
+            "  {}  {}M  {}",
+            config.memory.icon, mem_used, config.seperator
+        );
+    }
+    Ok(result)
+}
+
+fn assign_val(line: &str, assignable: &mut u32) {
+    let parsed: u32 = line.split(':').collect::<Vec<&str>>()[1]
+        .trim()
+        .split(' ')
+        .collect::<Vec<&str>>()[0]
+        .parse()
+        .unwrap();
+    *assignable = parsed;
+}