Extract functionality into modules

Author: ksceriath

src/constants.rs

@@ -33,4 +33,4 @@ impl fmt::Display for Message {
 
         write!(f, "{}", message)
     }
-}
+}

src/ds/key_node.rs

@@ -0,0 +1,40 @@
+use colored::*;
+use serde_json::Value;
+use std::collections::HashMap;
+
+#[derive(Debug, PartialEq)] // TODO check: do we need PartiaEq ?
+pub enum KeyNode {
+    Nil,
+    Value(Value, Value),
+    Node(HashMap<String, KeyNode>),
+}
+
+impl KeyNode {
+    pub fn absolute_keys(&self, keys: &mut Vec<String>, key_from_root: Option<String>) {
+        let val_key = |key: Option<String>| {
+            key.map(|mut s| {
+                s.push_str(" ->");
+                s
+            })
+            .unwrap_or(String::new())
+        };
+        let nil_key = |key: Option<String>| key.unwrap_or(String::new());
+        match self {
+            KeyNode::Nil => keys.push(nil_key(key_from_root)),
+            KeyNode::Value(a, b) => keys.push(format!(
+                "{} [ {} :: {} ]",
+                val_key(key_from_root),
+                a.to_string().blue().bold(),
+                b.to_string().cyan().bold()
+            )),
+            KeyNode::Node(map) => {
+                for (key, value) in map {
+                    value.absolute_keys(
+                        keys,
+                        Some(format!("{} {}", val_key(key_from_root.clone()), key)),
+                    )
+                }
+            }
+        }
+    }
+}

src/ds/mismatch.rs

@@ -0,0 +1,18 @@
+use crate::ds::key_node::KeyNode;
+
+#[derive(Debug, PartialEq)]
+pub struct Mismatch {
+    pub left_only_keys: KeyNode,
+    pub right_only_keys: KeyNode,
+    pub keys_in_both: KeyNode,
+}
+
+impl Mismatch {
+    pub fn new(l: KeyNode, r: KeyNode, u: KeyNode) -> Mismatch {
+        Mismatch {
+            left_only_keys: l,
+            right_only_keys: r,
+            keys_in_both: u,
+        }
+    }
+}

src/ds/mod.rs

@@ -0,0 +1,2 @@
+pub mod key_node;
+pub mod mismatch;

src/main.rs

@@ -1,17 +1,17 @@
+mod constants;
+mod ds;
+mod process;
+
 use colored::*;
+use constants::Message;
+use ds::key_node::KeyNode;
+use ds::mismatch::Mismatch;
 use serde_json;
-use serde_json::Map;
-use serde_json::Value;
-use std::collections::HashMap;
-use std::collections::HashSet;
 use std::fmt;
 use std::fs;
-use std::process;
+use std::process as proc;
 use std::str::FromStr;
 use structopt::StructOpt;
-use constants::Message;
-
-mod constants;
 
 const HELP: &str = r#"
 Example:
@@ -59,7 +59,7 @@ struct Cli {
 
 fn error_exit(message: constants::Message) -> ! {
     eprintln!("{}", message);
-    process::exit(1);
+    proc::exit(1);
 }
 
 fn main() {
@@ -130,64 +130,10 @@ fn display_output(result: Mismatch) {
     }
 }
 
-#[derive(Debug, PartialEq)] // TODO check: do we need PartiaEq ?
-enum KeyNode {
-    Nil,
-    Value(Value, Value),
-    Node(HashMap<String, KeyNode>),
-}
-
-impl KeyNode {
-    fn absolute_keys(&self, keys: &mut Vec<String>, key_from_root: Option<String>) {
-        let val_key = |key: Option<String>| {
-            key.map(|mut s| {
-                s.push_str(" ->");
-                s
-            })
-            .unwrap_or(String::new())
-        };
-        let nil_key = |key: Option<String>| key.unwrap_or(String::new());
-        match self {
-            KeyNode::Nil => keys.push(nil_key(key_from_root)),
-            KeyNode::Value(a, b) => keys.push(format!(
-                "{} [ {} :: {} ]",
-                val_key(key_from_root),
-                a.to_string().blue().bold(),
-                b.to_string().cyan().bold()
-            )),
-            KeyNode::Node(map) => {
-                for (key, value) in map {
-                    value.absolute_keys(
-                        keys,
-                        Some(format!("{} {}", val_key(key_from_root.clone()), key)),
-                    )
-                }
-            }
-        }
-    }
-}
-
-#[derive(Debug, PartialEq)]
-struct Mismatch {
-    left_only_keys: KeyNode,
-    right_only_keys: KeyNode,
-    keys_in_both: KeyNode,
-}
-
-impl Mismatch {
-    fn new(l: KeyNode, r: KeyNode, u: KeyNode) -> Mismatch {
-        Mismatch {
-            left_only_keys: l,
-            right_only_keys: r,
-            keys_in_both: u,
-        }
-    }
-}
-
 fn compare_jsons(a: &str, b: &str) -> Mismatch {
     if let Ok(value1) = serde_json::from_str(a) {
         if let Ok(value2) = serde_json::from_str(b) {
-            match_json(&value1, &value2)
+            process::match_json(&value1, &value2)
         } else {
             error_exit(Message::JSON2);
         }
@@ -196,104 +142,6 @@ fn compare_jsons(a: &str, b: &str) -> Mismatch {
     }
 }
 
-fn match_json(value1: &Value, value2: &Value) -> Mismatch {
-    match (value1, value2) {
-        (Value::Object(a), Value::Object(b)) => {
-            let (left_only_keys, right_only_keys, intersection_keys) = intersect_maps(&a, &b);
-
-            let mut unequal_keys = KeyNode::Nil;
-            let mut left_only_keys = get_map_of_keys(left_only_keys);
-            let mut right_only_keys = get_map_of_keys(right_only_keys);
-
-            if let Some(intersection_keys) = intersection_keys {
-                for key in intersection_keys {
-                    let Mismatch {
-                        left_only_keys: l,
-                        right_only_keys: r,
-                        keys_in_both: u,
-                    } = match_json(&a.get(&key).unwrap(), &b.get(&key).unwrap());
-                    left_only_keys = insert_child_key_map(left_only_keys, l, &key);
-                    right_only_keys = insert_child_key_map(right_only_keys, r, &key);
-                    unequal_keys = insert_child_key_map(unequal_keys, u, &key);
-                }
-            }
-            Mismatch::new(left_only_keys, right_only_keys, unequal_keys)
-        }
-        (a, b) => {
-            if a == b {
-                Mismatch::new(KeyNode::Nil, KeyNode::Nil, KeyNode::Nil)
-            } else {
-                Mismatch::new(
-                    KeyNode::Nil,
-                    KeyNode::Nil,
-                    KeyNode::Value(a.clone(), b.clone()),
-                )
-            }
-        }
-    }
-}
-
-fn get_map_of_keys(set: Option<HashSet<String>>) -> KeyNode {
-    if let Some(set) = set {
-        KeyNode::Node(
-            set.iter()
-                .map(|key| (String::from(key), KeyNode::Nil))
-                .collect(),
-        )
-    } else {
-        KeyNode::Nil
-    }
-}
-
-fn insert_child_key_map(parent: KeyNode, child: KeyNode, key: &String) -> KeyNode {
-    if child == KeyNode::Nil {
-        return parent;
-    }
-    if let KeyNode::Node(mut map) = parent {
-        map.insert(String::from(key), child);
-        KeyNode::Node(map) // This is weird! I just wanted to return back `parent` here
-    } else if let KeyNode::Nil = parent {
-        let mut map = HashMap::new();
-        map.insert(String::from(key), child);
-        KeyNode::Node(map)
-    } else {
-        parent // TODO Trying to insert child node in a Value variant : Should not happen => Throw an error instead.
-    }
-}
-
-fn intersect_maps(
-    a: &Map<String, Value>,
-    b: &Map<String, Value>,
-) -> (
-    Option<HashSet<String>>,
-    Option<HashSet<String>>,
-    Option<HashSet<String>>,
-) {
-    let mut intersection = HashSet::new();
-    let mut left = HashSet::new();
-    let mut right = HashSet::new();
-    for a_key in a.keys() {
-        if b.contains_key(a_key) {
-            intersection.insert(String::from(a_key));
-        } else {
-            left.insert(String::from(a_key));
-        }
-    }
-    for b_key in b.keys() {
-        if !a.contains_key(b_key) {
-            right.insert(String::from(b_key));
-        }
-    }
-    let left = if left.len() == 0 { None } else { Some(left) };
-    let right = if right.len() == 0 { None } else { Some(right) };
-    let intersection = if intersection.len() == 0 {
-        None
-    } else {
-        Some(intersection)
-    };
-    (left, right, intersection)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -331,7 +179,6 @@ mod tests {
             }
         }"#;
 
-        let mismatch = compare_jsons(data1, data2);
         let expected_left = KeyNode::Node(hashmap! {
         "b".to_string() => KeyNode::Node(hashmap! {
                 "c".to_string() => KeyNode::Node(hashmap! {
@@ -371,6 +218,8 @@ mod tests {
             )
         });
         let expected = Mismatch::new(expected_left, expected_right, expected_uneq);
+
+        let mismatch = compare_jsons(data1, data2);
         assert_eq!(mismatch, expected, "Diff was incorrect.");
     }
 

src/process.rs

@@ -0,0 +1,104 @@
+use crate::ds::key_node::KeyNode;
+use crate::ds::mismatch::Mismatch;
+use serde_json::Map;
+use serde_json::Value;
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+pub fn match_json(value1: &Value, value2: &Value) -> Mismatch {
+    match (value1, value2) {
+        (Value::Object(a), Value::Object(b)) => {
+            let (left_only_keys, right_only_keys, intersection_keys) = intersect_maps(&a, &b);
+
+            let mut unequal_keys = KeyNode::Nil;
+            let mut left_only_keys = get_map_of_keys(left_only_keys);
+            let mut right_only_keys = get_map_of_keys(right_only_keys);
+
+            if let Some(intersection_keys) = intersection_keys {
+                for key in intersection_keys {
+                    let Mismatch {
+                        left_only_keys: l,
+                        right_only_keys: r,
+                        keys_in_both: u,
+                    } = match_json(&a.get(&key).unwrap(), &b.get(&key).unwrap());
+                    left_only_keys = insert_child_key_map(left_only_keys, l, &key);
+                    right_only_keys = insert_child_key_map(right_only_keys, r, &key);
+                    unequal_keys = insert_child_key_map(unequal_keys, u, &key);
+                }
+            }
+            Mismatch::new(left_only_keys, right_only_keys, unequal_keys)
+        }
+        (a, b) => {
+            if a == b {
+                Mismatch::new(KeyNode::Nil, KeyNode::Nil, KeyNode::Nil)
+            } else {
+                Mismatch::new(
+                    KeyNode::Nil,
+                    KeyNode::Nil,
+                    KeyNode::Value(a.clone(), b.clone()),
+                )
+            }
+        }
+    }
+}
+
+fn get_map_of_keys(set: Option<HashSet<String>>) -> KeyNode {
+    if let Some(set) = set {
+        KeyNode::Node(
+            set.iter()
+                .map(|key| (String::from(key), KeyNode::Nil))
+                .collect(),
+        )
+    } else {
+        KeyNode::Nil
+    }
+}
+
+fn insert_child_key_map(parent: KeyNode, child: KeyNode, key: &String) -> KeyNode {
+    if child == KeyNode::Nil {
+        return parent;
+    }
+    if let KeyNode::Node(mut map) = parent {
+        map.insert(String::from(key), child);
+        KeyNode::Node(map) // This is weird! I just wanted to return back `parent` here
+    } else if let KeyNode::Nil = parent {
+        let mut map = HashMap::new();
+        map.insert(String::from(key), child);
+        KeyNode::Node(map)
+    } else {
+        parent // TODO Trying to insert child node in a Value variant : Should not happen => Throw an error instead.
+    }
+}
+
+fn intersect_maps(
+    a: &Map<String, Value>,
+    b: &Map<String, Value>,
+) -> (
+    Option<HashSet<String>>,
+    Option<HashSet<String>>,
+    Option<HashSet<String>>,
+) {
+    let mut intersection = HashSet::new();
+    let mut left = HashSet::new();
+    let mut right = HashSet::new();
+    for a_key in a.keys() {
+        if b.contains_key(a_key) {
+            intersection.insert(String::from(a_key));
+        } else {
+            left.insert(String::from(a_key));
+        }
+    }
+    for b_key in b.keys() {
+        if !a.contains_key(b_key) {
+            right.insert(String::from(b_key));
+        }
+    }
+    let left = if left.len() == 0 { None } else { Some(left) };
+    let right = if right.len() == 0 { None } else { Some(right) };
+    let intersection = if intersection.len() == 0 {
+        None
+    } else {
+        Some(intersection)
+    };
+    (left, right, intersection)
+}