Making adjustments based on clippy.

gemla/src/bracket/mod.rs

@@ -25,23 +25,15 @@ impl tree::Tree<Uuid> {
 
 /// Constructs a tree with a given height while simultaneously running a simulation on each node.
 fn build_tree(h: u32) -> Option<Box<tree::Tree<Uuid>>> {
-    let mut result: Option<Box<tree::Tree<Uuid>>> = None;
-
     // Recursively building a tree and running the simulation after wards to ensure a bottom-up
     // execution order.
     if h != 0 {
-        result = Some(Box::new(tree::Tree::new(
+        let tree = tree::Tree::new(Uuid::new_v4(), build_tree(h - 1), build_tree(h - 1));
-            Uuid::new_v4(),
+        tree.run_simulation();
-            build_tree(h - 1),
+        Some(Box::new(tree))
-            build_tree(h - 1),
+    } else {
-        )));
+        None
-        match &result {
-            Some(r) => (*r).run_simulation(),
-            _ => (),
-        }
     }
-
-    result
 }
 
 /// Generates a bracket tree and runs simulation against each node.

gemla/src/file_linked/mod.rs

@@ -19,20 +19,17 @@ where
 
         match &meta {
             Ok(m) if m.is_file() => {
-                let mut file = fs::OpenOptions::new().read(true).open(path).or(
+                let mut file = fs::OpenOptions::new().read(true).open(path).or_else(|_| {
-                    Err(format!(
+                    Err(format!("Unable to open file {}", path))
-                        "Unable to open file {}",
+                })?;
-                        path
-                    )),
-                )?;
                 let mut s = String::new();
-                file.read_to_string(&mut s).or(Err(String::from(
+                file.read_to_string(&mut s).or_else(|_| {
-                    "Unable to read from file.",
+                    Err(String::from("Unable to read from file."))
-                )))?;
+                })?;
 
-                let val = T::from_str(&s).or(Err(String::from(
+                let val = T::from_str(&s).or_else(|_| {
-                    "Unable to parse value from file.",
+                    Err(String::from("Unable to parse value from file."))
-                )))?;
+                })?;
 
                 Ok(FileLinked {
                     val,
@@ -70,11 +67,11 @@ where
             .create(true)
             .truncate(true)
             .open(&self.path)
-            .or(Err(format!("Unable to open path {}", self.path)))?;
+            .or_else(|_| Err(format!("Unable to open path {}", self.path)))?;
 
-        write!(file, "{}", self.val).or(Err(String::from(
+        write!(file, "{}", self.val).or_else(|_| {
-            "Unable to write to file.",
+            Err(String::from("Unable to write to file."))
-        )))?;
+        })?;
 
         Ok(())
     }

gemla/src/main.rs

@@ -28,7 +28,7 @@ fn main() {
     let directory = matches.value_of(constants::args::DIRECTORY).unwrap();
     let metadata = metadata(directory);
     match &metadata {
-        Ok(m) if m.is_dir() == true => {
+        Ok(m) if m.is_dir() => {
             println!("{} is a valid directory!", directory);
             println!("Building tree for {}.", directory);
             bracket::run_bracket();

gemla/src/tree/mod.rs

@@ -11,12 +11,15 @@ pub struct Tree<T> {
 
 #[macro_export]
 macro_rules! btree {
-	($val:expr, $l:expr, $r:expr) => { 
+    ($val:expr, $l:expr, $r:expr) => { 
-		$crate::tree::Tree::new($val, Some(Box::new($l)), Some(Box::new($r))) 
+    $crate::tree::Tree::new(
-		};
+        $val, 
-	($val:expr, , $r:expr) => { $crate::tree::Tree::new($val, None, Some(Box::new($r))) };
+        Some(Box::new($l)), 
-	($val:expr, $l:expr,) => { $crate::tree::Tree::new($val, Some(Box::new($l)), None) };
+        Some(Box::new($r))
-	($val:expr) => { Tree::new($val, None, None) };
+    ) };
+    ($val:expr, , $r:expr) => { $crate::tree::Tree::new($val, None, Some(Box::new($r))) };
+    ($val:expr, $l:expr,) => { $crate::tree::Tree::new($val, Some(Box::new($l)), None) };
+    ($val:expr) => { Tree::new($val, None, None) };
 }
 
 impl<T> Tree<T> {
@@ -90,16 +93,12 @@ fn from_str_helper<T: FromStr>(s: &str) -> Result<Option<Box<Tree<T>>>, ParseTre
     let caps = re.captures(s);
 
     if let Some(c) = caps {
-        let val = T::from_str(c.get(1).unwrap().as_str()).or(Err(
+        let val = T::from_str(c.get(1).unwrap().as_str()).or_else(|_| {
-            ParseTreeError::new(
+            Err(ParseTreeError::new(format!(
-                format!(
+                "Unable to parse node value: {}",
-                    "Unable to parse node value: {}",
+                c.get(1).unwrap().as_str()
-                    c.get(1)
+            )))
-                        .unwrap()
+        })?;
-                        .as_str()
-                ),
-            ),
-        ))?;
         let (left, right) = seperate_nodes(c.get(2).unwrap().as_str())?;
         let left = from_str_helper(left)?;
         let right = from_str_helper(right)?;
@@ -122,7 +121,9 @@ where
         let result = from_str_helper(s)?;
 
         result
-            .ok_or(ParseTreeError::new(format!("Unable to parse string {}", s)))
+            .ok_or_else(|| {
+                ParseTreeError::new(format!("Unable to parse string {}", s))
+            })
             .and_then(|t| Ok(*t))
     }
 }