Merge pull request #4 from joshuous/clap-cli

Implement recursive search and add clap

Author: joshchoo

Cargo.lock

@@ -1,17 +1,16 @@
 [package]
 name = "aosp-missing-blobs"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Josh Choo <dev@joshuous.com>"]
 edition = "2018"
 description = """
-aosp-missing-blobs is a nifty tool to identify required blobs (.so) that are missing from AOSP ROM builds,
-and to show which existing blobs rely on them. This will be particularly useful for ROM developers who want
-to ensure that they have not missed out any required proprietary OEM blobs.
+A tool to identify required blobs (.so) that are missing from AOSP ROM builds, and to show which existing blobs depend on them.
 """
 license = "MIT"
 homepage = "https://github.com/joshuous/aosp-missing-blobs"
 repository = "https://github.com/joshuous/aosp-missing-blobs"
 
 [dependencies]
 clap = "2.33"
-goblin = "0.4"
+goblin = "0.4"
+ignore = "0.4"

Cargo.toml

@@ -1,39 +1,82 @@
 use goblin::{self, Object};
+use ignore::WalkBuilder;
 use std::collections::HashMap;
 use std::fs;
 use std::path::{Path, PathBuf};
 
-pub fn run(paths: &[&str]) {
-    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);
+pub struct MissingBlobs {
+    recursive: bool,
 }
 
-fn find_blobs_in_paths(paths: &[&str]) -> Vec<PathBuf> {
+impl MissingBlobs {
+    pub fn new(recursive: bool) -> Self {
+        Self { recursive }
+    }
+
+    pub fn run(&self, paths: &[&str]) {
+        let file_paths: Vec<PathBuf> = if self.recursive {
+            find_files_recursively(&paths)
+        } else {
+            find_files(&paths)
+        };
+
+        let blob_paths: Vec<&PathBuf> = file_paths
+            .iter()
+            .filter(|path| match path.extension() {
+                // Assume that valid blobs have ".so" extension.
+                Some(ext) => ext == "so",
+                None => false,
+            })
+            .collect();
+
+        let blobs_to_dependencies = get_dependencies(&blob_paths);
+        let missing_blobs = identify_missing(&blobs_to_dependencies);
+        display_missing_blobs(&missing_blobs);
+    }
+}
+
+fn find_files(paths: &[&str]) -> Vec<PathBuf> {
     let dirs = paths
         .iter()
         .map(Path::new)
         .filter(|path| path.is_dir())
         .collect::<Vec<_>>();
 
-    let blob_paths: Vec<PathBuf> = dirs
+    let file_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();
 
-    blob_paths
+    file_paths
+}
+
+fn find_files_recursively(paths: &[&str]) -> Vec<PathBuf> {
+    let mut walker = WalkBuilder::new(paths[0]);
+    for path in &paths[1..] {
+        walker.add(path);
+    }
+
+    // Don't read from ignore configs
+    walker
+        .ignore(false)
+        .git_ignore(false)
+        .git_exclude(false)
+        .git_global(false);
+
+    walker
+        .build()
+        .map(|dir_entry| {
+            dir_entry
+                .expect("Could not read directory entry.")
+                .into_path()
+        })
+        .collect()
 }
 
-fn get_dependencies(blob_paths: &Vec<PathBuf>) -> HashMap<String, Vec<String>> {
+fn get_dependencies(blob_paths: &[&PathBuf]) -> HashMap<String, Vec<String>> {
     let mut dependencies: HashMap<String, Vec<String>> = HashMap::new();
 
     blob_paths.iter().for_each(|path| {

src/lib.rs

@@ -1,20 +1,26 @@
-use aosp_missing_blobs::run;
-use clap::{App, Arg};
+use aosp_missing_blobs::MissingBlobs;
+use clap::{crate_description, crate_name, crate_version, App, Arg};
 
 fn main() {
-    let matches = App::new("aosp-missing-blobs")
-        .version("0.3.0")
-        .author("Josh Choo <dev@joshuous.com>")
-        .about("An AOSP tool to generate a list of required missing blobs.")
+    let matches = App::new(crate_name!())
+        .version(crate_version!())
+        .about(crate_description!())
         .arg(
             Arg::with_name("PATHS")
                 .help("Paths to blobs")
                 .required(true)
                 .multiple(true),
         )
+        .arg(
+            Arg::with_name("recursive")
+                .short("r")
+                .long("recursive")
+                .help("Read blobs in each path recursively"),
+        )
         .get_matches();
 
     let paths = matches.values_of("PATHS").unwrap().collect::<Vec<_>>();
+    let recursive = matches.is_present("recursive");
 
-    run(&paths);
+    MissingBlobs::new(recursive).run(&paths);
 }