Refactor: simplify parsing code

1 files changed, 46 insertions, 16 deletions

diff --git a/src/lib.rs b/src/lib.rs
index 598b68a..ff6455f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -111,32 +111,62 @@ impl Roadmap {
 
     // Convert a Value into a Step, if possible.
     fn step_from_value(name: &str, value: &Value) -> Result<Step, &'static str> {
-        let label_key = Value::String("label".to_string());
-        let status_key = Value::String("status".to_string());
         let deps_key = Value::String("depends".to_string());
 
         match value {
             Value::Mapping(map) => {
-                if let Some(Value::String(label)) = map.get(&label_key) {
-                    let mut step = Step::new(name, label);
-                    if let Some(Value::String(status)) = map.get(&status_key) {
-                        step.set_status(&status);
-                    }
-                    if let Some(Value::Sequence(deps)) = map.get(&deps_key) {
-                        for depname in deps.iter() {
-                            if let Value::String(depname) = depname {
-                                step.add_dependency(depname);
-                            }
-                        }
-                    }
-                    return Ok(step);
+                let label = Roadmap::parse_label(&value);
+                let mut step = Step::new(name, label);
+
+                let status = Roadmap::parse_status(&value);
+                step.set_status(status);
+
+                for depname in Roadmap::parse_depends(&value).iter() {
+                    step.add_dependency(depname);
                 }
-                Ok(Step::new(name, ""))
+
+                Ok(step)
             }
             _ => Err("step is not a mapping"),
         }
     }
 
+    // Get a sequence of depenencies.
+    fn parse_depends(map: &Value) -> Vec<&str> {
+        let key_name = "depends";
+        let key = Value::String(key_name.to_string());
+        let mut depends: Vec<&str> = vec![];
+        
+        if let Some(Value::Sequence(deps)) = map.get(&key) {
+            for depname in deps.iter() {
+                if let Value::String(depname) = depname {
+                    depends.push(depname);
+                }
+            }
+        }
+
+        depends
+    }
+
+    // Get label string from a Mapping element, or empty string.
+    fn parse_label<'a>(map: &'a Value) -> &'a str {
+        Roadmap::parse_string("label", map)
+    }
+
+    // Get status string from a Mapping element, or empty string.
+    fn parse_status<'a>(map: &'a Value) -> &'a str {
+        Roadmap::parse_string("status", map)
+    }
+
+    // Get string value from a Mapping element, or empty string.
+    fn parse_string<'a>(key_name: &str, map: &'a Value) -> &'a str {
+        let key = Value::String(key_name.to_string());
+        match map.get(&key) {
+            Some(Value::String(s)) => s,
+            _ => "",
+        }
+    }
+
     /// Return list of step names.
     pub fn step_names<'a>(&'a self) -> Vec<&'a str> {
         let mut names = vec![];