Restructure sensors

A sensor now provides an icon and a status

src/sensors/battery.rs

@@ -5,7 +5,8 @@ use super::Sensor;
 
 pub struct BatterySensor {
     charge_now: File,
-    charge_full: File
+    charge_full: File,
+    percentage: u32
 }
 
 impl BatterySensor {
@@ -13,13 +14,22 @@ impl BatterySensor {
         let path = format!("/sys/class/power_supply/{}", supply);
         BatterySensor {
             charge_now: File::open(format!("{}/{}", path, "charge_now")).unwrap(),
-            charge_full: File::open(format!("{}/{}", path, "charge_full")).unwrap()
+            charge_full: File::open(format!("{}/{}", path, "charge_full")).unwrap(),
+            percentage: 0
         }
     }
 }
 
 impl Sensor for BatterySensor {
-    fn status(&mut self) -> String {
+    fn icon(&self) -> String {
+        "BAT".to_string()
+    }
+
+    fn status(&self) -> String {
+        format!("{}%", self.percentage)
+    }
+
+    fn process(&mut self) {
         let mut s = String::new();
 
         self.charge_now.read_to_string(&mut s).ok().expect("Could not read current charge");
@@ -33,7 +43,7 @@ impl Sensor for BatterySensor {
         self.charge_now.seek(SeekFrom::Start(0)).ok();
         self.charge_full.seek(SeekFrom::Start(0)).ok();
 
-        format!("{}%", charge_now / (charge_full / 100))
+        self.percentage = charge_now / (charge_full / 100)
     }
 }
 

src/sensors/disk.rs

@@ -2,17 +2,26 @@ use super::Sensor;
 use std::process::Command;
 
 pub struct DiskSensor {
-    mount: String
+    mount: String,
+    space: String
 }
 
 impl DiskSensor {
     pub fn new(mount: &str) -> DiskSensor {
-        DiskSensor { mount: mount.to_string() }
+        DiskSensor { mount: mount.to_string(), space: "".to_string() }
     }
 }
 
 impl Sensor for DiskSensor {
-    fn status(&mut self) -> String {
+    fn icon(&self) -> String {
+        self.mount.clone()
+    }
+
+    fn status(&self) -> String {
+        self.space.clone()
+    }
+
+    fn process(&mut self) {
         let output = Command::new("df")
           .arg("--output=avail")
           .arg("-h")
@@ -23,6 +32,7 @@ impl Sensor for DiskSensor {
 
         let output = String::from_utf8_lossy(&output.stdout);
         let space = output.lines().nth(1).expect("Could not get space");
-        space.trim().to_string()
+
+        self.space = space.trim().to_string()
     }
 }

src/sensors/mod.rs

@@ -15,7 +15,9 @@ use self::temperature::TempSensor;
 use self::time::TimeSensor;
 
 pub trait Sensor {
-    fn status(&mut self) -> String;
+    fn icon(&self) -> String;
+    fn status(&self) -> String;
+    fn process(&mut self);
 }
 
 pub fn sensors(tx: &Channel, config: &Config) {
@@ -40,7 +42,14 @@ pub fn sensors(tx: &Channel, config: &Config) {
 
     loop {
         let status = sensors.iter_mut()
-            .map(|sensor| sensor.status())
+            .map(|sensor| {
+                sensor.process();
+                format!(
+                    "%{{B#666666}} {} %{{B-}} {}",
+                    sensor.icon(),
+                    sensor.status()
+                )
+            })
             .collect::<Vec<String>>();
 
         comm::send(tx, "sensors", &reduce(status));
@@ -49,7 +58,5 @@ pub fn sensors(tx: &Channel, config: &Config) {
 }
 
 fn reduce(arr: Vec<String>) -> String {
-    let result = arr.into_iter()
-        .fold("".to_string(), |acc, elem| format!("{} | {}", acc, elem));
-    if result.len() > 0 { result[3..].to_string() } else { result }
+    arr.into_iter().fold("".to_string(), |acc, elem| format!("{} {}", acc, elem))
 }

src/sensors/netspeed.rs

@@ -18,6 +18,7 @@ struct Stats {
 pub struct NetSpeedSensor {
     files: Vec<StatFiles>,
     stats: Option<Stats>,
+    rate: Option<Stats>,
     last_time: i64
 }
 
@@ -30,13 +31,25 @@ impl NetSpeedSensor {
         NetSpeedSensor {
             files: files,
             stats: None,
+            rate: None,
             last_time: 0
         }
     }
 }
 
 impl Sensor for NetSpeedSensor {
-    fn status(&mut self) -> String {
+    fn icon(&self) -> String {
+        "NET".to_string()
+    }
+
+    fn status(&self) -> String {
+        match self.rate.as_ref() {
+            Some(rate) => format!("{}↓ {}↑", format_bytes(rate.rx), format_bytes(rate.tx)),
+            None => "?".to_string()
+        }
+    }
+
+    fn process(&mut self) {
         let curr_time = time::get_time().sec;
 
         let stats = self.files
@@ -49,18 +62,17 @@ impl Sensor for NetSpeedSensor {
 
         let diff_time = curr_time - self.last_time;
         let output = match (self.stats.as_ref(), diff_time) {
-            (_, 0) | (None, _) => "?".to_string(),
+            (_, 0) | (None, _) => None,
             (Some(pstats), diff_time) => {
                 let rx = (stats.rx - pstats.rx) / diff_time;
                 let tx = (stats.tx - pstats.tx) / diff_time;
-                format!("{}↓ {}↑", format_bytes(rx), format_bytes(tx))
+                Some(Stats { rx: rx, tx: tx })
             }
         };
 
         self.last_time = curr_time;
         self.stats = Some(stats);
-
-        output
+        self.rate = output;
     }
 }
 

src/sensors/temperature.rs

@@ -4,29 +4,39 @@ use std::io::prelude::*;
 use super::Sensor;
 
 pub struct TempSensor {
-    file: File
+    file: File,
+    temp: Option<u32>
 }
 
 impl TempSensor {
     pub fn new(zone: &str) -> TempSensor {
         let path = format!("/sys/class/thermal/{}/temp", zone);
         TempSensor {
-            file: File::open(path).unwrap()
+            file: File::open(path).unwrap(),
+            temp: None
         }
     }
 }
 
 impl Sensor for TempSensor {
-    fn status(&mut self) -> String {
+    fn icon(&self) -> String {
+        "TEMP".to_string()
+    }
+
+    fn status(&self) -> String {
+        match self.temp {
+            Some(i) => format!("{}°C", i/1000),
+            None => "?°C".to_string(),
+        }
+    }
+
+    fn process(&mut self) {
         let mut s = String::new();
         self.file.read_to_string(&mut s).ok().expect("Could not read temperature stats");
         let i : Option<u32> = s.trim().parse().ok();
         self.file.seek(SeekFrom::Start(0)).ok().expect("Could not reread temperature");
 
-        match i {
-            Some(i) => format!("{}°C", i/1000),
-            None => "?°C".to_string(),
-        }
+        self.temp = i;
     }
 }
 

src/sensors/time.rs

@@ -4,20 +4,35 @@ use super::Sensor;
 
 pub struct TimeSensor {
     format: String,
-    is_utc: bool
+    is_utc: bool,
+    time: String
 }
 
 impl TimeSensor {
     pub fn new(format: &str, is_utc: bool) -> TimeSensor {
         TimeSensor {
             format: format.to_string(),
-            is_utc: is_utc
+            is_utc: is_utc,
+            time: "".to_string()
         }
     }
 }
 
 impl Sensor for TimeSensor {
-    fn status(&mut self) -> String {
+    fn icon(&self) -> String {
+        if self.is_utc {
+            "UTC"
+        }
+        else {
+            "LOC"
+        }.to_string()
+    }
+
+    fn status(&self) -> String {
+        self.time.clone()
+    }
+
+    fn process(&mut self) {
         let now =
             if self.is_utc {
                 time::now_utc()
@@ -28,7 +43,7 @@ impl Sensor for TimeSensor {
 
 
         let time = time::strftime(&self.format, &now);
-        time.unwrap()
+        self.time = time.unwrap()
     }
 }