Split into separate functions and remove anyhow dependency

Author: joshchoo

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "aosp-missing-blobs"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Josh Choo <dev@joshuous.com>"]
 edition = "2018"
 description = """
@@ -13,5 +13,4 @@ homepage = "https://github.com/joshuous/aosp-missing-blobs"
 repository = "https://github.com/joshuous/aosp-missing-blobs"
 
 [dependencies]
-anyhow = "1.0.40"
 goblin = "0.4"

Cargo.toml

@@ -1,70 +1,94 @@
-use anyhow::Result;
 use goblin::{self, Object};
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
-pub fn run(paths: &[String]) -> Result<()> {
-    let mut dependencies: HashMap<String, Vec<String>> = HashMap::new();
-    let mut present: HashSet<String> = HashSet::new();
+pub fn run(paths: &[String]) {
+    let blob_paths = find_blobs_in_paths(&paths);
+    let blobs_to_dependencies = get_dependencies(&blob_paths);
+    let missing_blobs = identify_missing(&blobs_to_dependencies);
+    display_missing_blobs(&missing_blobs);
+}
 
+fn find_blobs_in_paths(paths: &[String]) -> Vec<PathBuf> {
     let dirs = paths
         .iter()
         .map(Path::new)
         .filter(|path| path.is_dir())
         .collect::<Vec<_>>();
 
-    for dir in dirs.iter() {
-        for entry in fs::read_dir(dir)? {
-            let path = entry?.path();
+    let blob_paths: Vec<PathBuf> = dirs
+        .iter()
+        .map(|dir| fs::read_dir(dir).expect("Could not read directory."))
+        .flat_map(|read_dir| {
+            read_dir.map(|dir_entry| dir_entry.expect("Could not read directory entry.").path())
+        })
+        .filter(|path| match path.extension() {
+            // Assume that valid blobs have ".so" extension.
+            Some(ext) => ext == "so",
+            None => false,
+        })
+        .collect();
 
-            let filename = path
-                .file_name()
-                .expect("Could not get file name.")
-                .to_str()
-                .expect("Could not convert to string.")
-                .to_string();
+    blob_paths
+}
 
-            present.insert(filename.clone());
+fn get_dependencies(blob_paths: &Vec<PathBuf>) -> HashMap<String, Vec<String>> {
+    let mut dependencies: HashMap<String, Vec<String>> = HashMap::new();
 
-            if let Some(ext) = path.extension() {
-                if ext != "so" {
-                    continue;
-                }
-            } else {
-                continue;
-            }
+    blob_paths.iter().for_each(|path| {
+        let filename = path
+            .file_name()
+            .expect("Could not get file name.")
+            .to_str()
+            .expect("Could not convert to string.")
+            .to_owned();
 
-            let buffer = fs::read(&path)?;
-            let obj = goblin::Object::parse(&buffer);
+        let buffer = fs::read(&path).expect("Could not read path.");
+        let obj = goblin::Object::parse(&buffer);
 
-            if let Ok(Object::Elf(elf)) = obj {
-                for dep_str in elf.libraries {
-                    let dep = dep_str.to_string();
-                    match dependencies.get_mut(&dep) {
-                        Some(dependants) => {
-                            dependants.push(filename.clone());
-                        }
-                        None => {
-                            dependencies.insert(dep, vec![filename.clone()]);
-                        }
-                    }
-                }
-            }
+        if let Ok(Object::Elf(elf)) = obj {
+            let deps: Vec<String> = elf.libraries.iter().map(|dep| dep.to_string()).collect();
+            dependencies.insert(filename, deps);
         }
-    }
+    });
 
-    let mut missing: Vec<String> = vec![];
+    dependencies
+}
+
+fn identify_missing(
+    blobs_to_dependencies: &HashMap<String, Vec<String>>,
+) -> HashMap<String, Vec<String>> {
+    let mut dependencies_to_blobs: HashMap<String, Vec<String>> = HashMap::new();
+    blobs_to_dependencies.iter().for_each(|(blob, deps)| {
+        deps.iter().for_each(
+            |dependency| match dependencies_to_blobs.get_mut(dependency) {
+                Some(dependants) => {
+                    dependants.push(blob.to_owned());
+                }
+                None => {
+                    dependencies_to_blobs.insert(dependency.to_owned(), vec![blob.to_owned()]);
+                }
+            },
+        )
+    });
 
-    for dep in dependencies.keys() {
-        if !present.contains(dep) {
-            missing.push(dep.to_string());
+    let mut missing_blobs: HashMap<String, Vec<String>> = HashMap::new();
+
+    for dep in dependencies_to_blobs.keys() {
+        if !blobs_to_dependencies.contains_key(dep) {
+            // Dependency is not present.
+            let missing_dep = dep.to_owned();
+            let blobs_requiring_missing_dep = dependencies_to_blobs[dep].to_owned();
+            missing_blobs.insert(missing_dep, blobs_requiring_missing_dep);
         }
     }
 
-    for m in missing {
-        println!("{} required by: {}", m, dependencies[&m].join("; "));
-    }
+    missing_blobs
+}
 
-    Ok(())
+fn display_missing_blobs(missing_blobs: &HashMap<String, Vec<String>>) {
+    for blob in missing_blobs.keys() {
+        println!("{} required by: {}", blob, missing_blobs[blob].join("; "));
+    }
 }

src/lib.rs

@@ -1,13 +1,10 @@
-use std::{env, process};
+use std::env;
 
 use aosp_missing_blobs::run;
 
 fn main() {
     let args: Vec<String> = env::args().collect();
     let paths = &args[1..];
 
-    if let Err(e) = run(&paths) {
-        println!("An error occurred: {}", e);
-        process::exit(1)
-    }
+    run(paths);
 }