okeydoke

pttodoer/src/main.rs

@@ -30,14 +30,126 @@ struct When(String);
 
 impl When {
    fn new(src: String) -> Result<When, String> {
-      let duration = Regex::new(r"").unwrap();
+      match Self::new_duration(src.clone()) {
+         Some(x) => { return Ok(x); },
+         None => {},
+      };
+      match Self::new_ts(src.clone()) {
+         Some(x) => { return Ok(x); },
+         None => {},
+      };
+      match Self::new_cron(src.clone()) {
+         Some(x) => { return Ok(x); },
+         None => {},
+      };
+      Err(format!("cannot parse when {}", src))
+   }
+
+   fn new_duration(src: String) -> Option<When> {
+      match Duration::new(src.clone()) {
+         Ok(_) => Some(When{0: src.clone()}),
+         _ => None,
+      }
+   }
+
+   fn new_ts(src: String) -> Option<When> {
+      match TS::new(src.clone()) {
+         Ok(_) => Some(When{0: src.clone()}),
+         _ => None,
+      }
+   }
+
+   fn new_cron(src: String) -> Option<When> {
+      match Cron::new(src.clone()) {
+         Ok(_) => Some(When{0: src.clone()}),
+         _ => None,
+      }
+   }
+}
+
+#[cfg(test)]
+mod test_when {
+   use super::*;
+
+   #[test]
+   fn parse() {
+      match When::new("1d2h3m".to_string()) {
+         Ok(when) => {
+            assert!(false, "not impl: {:?}", when);
+         },
+         Err(err) => assert!(false, "failed to parse when: {}", err),
+      };
+   }
+}
+
+#[derive(Debug)]
+struct Cron(String);
+
+impl Cron {
+   fn new(src: String) -> Result<Cron, String> {
+      Err("not impl".to_string())
+   }
+}
+
+#[derive(Debug)]
+struct Duration(u64);
+
+impl Duration {
+   fn new(src: String) -> Result<Duration, String> {
+      let duration = Regex::new(r"([0-9]+d)?([0-9]+h)?([0-9]+m)?").unwrap();
       match duration.is_match(&src) {
+         false => { return Err("ill formatted duration".to_string()); },
          _ => {},
       };
-      Err("not impl: Duration".to_string())
+      let caps = duration.captures(&src).unwrap();
+      let mut sum: u64 = 0;
+      match caps.get(1) {
+         Some(d) => { sum += 60 * 60 * 24 * Self::to_n(d.as_str()); },
+         _ => {},
+      };
+      match caps.get(2) {
+         Some(h) => { sum += 60 * 60 * Self::to_n(h.as_str()); },
+         _ => {},
+      };
+      match caps.get(3) {
+         Some(m) => { sum += 60 * Self::to_n(m.as_str()); },
+         _ => {},
+      };
+      Ok(Duration{0: sum})
+   }
 
-      //Err("not impl: TS".to_string())
+   fn to_n(s: &str) -> u64 {
-      //Err("not impl: cron".to_string())
+      let s = s.to_string();
+      let (s, _) = s.split_at(s.len()-1);
+      match s.parse::<u64>() {
+         Ok(n) => n,
+         _ => 0,
+      }
+   }
+}
+
+#[cfg(test)]
+mod test_duration {
+   use super::*;
+
+   #[test]
+   fn parse() {
+      match Duration::new("1d2h3m".to_string()) {
+         Ok(d) => assert_eq!(60*60*24 + 60*60*2 + 60*3, d.0),
+         Err(err) => assert!(false, "failed to parse duration: {}", err),
+      };
+      match Duration::new("1d".to_string()) {
+         Ok(d) => assert_eq!(60*60*24, d.0),
+         Err(err) => assert!(false, "failed to parse duration: {}", err),
+      };
+      match Duration::new("2h".to_string()) {
+         Ok(d) => assert_eq!(60*60*2, d.0),
+         Err(err) => assert!(false, "failed to parse duration: {}", err),
+      };
+      match Duration::new("3m".to_string()) {
+         Ok(d) => assert_eq!(60*3, d.0),
+         Err(err) => assert!(false, "failed to parse duration: {}", err),
+      };
    }
 }