fix: read config, allow stdin anywhere, ignore invalid package

src/core/config.rs

@@ -123,7 +123,7 @@ pub fn init() {
     let _ = &*CONFIG;
 }
 
-pub static CONFIG: LazyLock<Config> = LazyLock::new(Config::default);
+pub static CONFIG: LazyLock<Config> = LazyLock::new(Config::new);
 
 pub fn generate_default_config() -> Result<()> {
     let home_config = home_config_path();

src/lib.rs

@@ -23,15 +23,20 @@ mod registry;
 async fn handle_cli() -> Result<()> {
     let mut args = env::args().collect::<Vec<_>>();
 
-    if let Some(command) = args.last() {
-        if command == "-" {
-            args.pop();
+    let mut i = 0;
+    while i < args.len() {
+        if args[i] == "-" {
             let mut stdin = std::io::stdin();
             let mut buffer = String::new();
             if stdin.read_to_string(&mut buffer).is_ok() {
                 let stdin_args = buffer.split_whitespace().collect::<Vec<&str>>();
-                args.extend(stdin_args.into_iter().map(String::from));
+                args.remove(i);
+                args.splice(i..i, stdin_args.into_iter().map(String::from));
+            } else {
+                i += 1;
             }
+        } else {
+            i += 1;
         }
     }
 

src/package/mod.rs

@@ -121,7 +121,7 @@ pub fn parse_package_query(query: &str) -> PackageQuery {
 }
 
 #[inline]
-pub fn gen_package_info(name: &str, path: &Path, size: u64) -> Result<ResolvedPackage> {
+pub fn gen_package_info(name: &str, path: &Path, size: u64) -> ResolvedPackage {
     let package = Package {
         pkg: name.to_owned(),
         pkg_name: name.to_owned(),
@@ -130,11 +130,9 @@ pub fn gen_package_info(name: &str, path: &Path, size: u64) -> Result<ResolvedPa
         ..Default::default()
     };
 
-    let resolved_package = ResolvedPackage {
+    ResolvedPackage {
         repo_name: "local".to_owned(),
         collection: "local".to_string(),
         package,
-    };
-
-    Ok(resolved_package)
+    }
 }

src/registry/storage.rs

@@ -83,34 +83,40 @@ impl PackageStorage {
         yes: bool,
         quiet: bool,
     ) -> Result<()> {
-        let resolved_packages: Result<Vec<ResolvedPackage>> = package_names
+        let resolved_packages: Vec<ResolvedPackage> = package_names
             .iter()
-            .map(|package_name| {
-                if let Ok(package) = self.resolve_package(package_name, yes) {
-                    Ok(package)
-                } else {
-                    // check if a local package is provided instead
-                    let package_path = build_path(package_name)?;
-                    if package_path.is_file() {
-                        let realpath = if package_path.is_symlink() {
-                            package_path.read_link()?
+            .filter_map(|package_name| {
+                match self.resolve_package(package_name, yes) {
+                    Ok(package) => Some(package),
+                    Err(err) => {
+                        // Check if a local package is provided instead
+                        let package_path = build_path(package_name).ok()?;
+
+                        if package_path.is_file() {
+                            let realpath = if package_path.is_symlink() {
+                                package_path.read_link().ok()?
+                            } else {
+                                package_path
+                            };
+
+                            let file = File::open(&realpath).ok()?;
+                            let mut buf_reader = BufReader::new(&file);
+                            if get_file_type(&mut buf_reader) != FileType::Unknown {
+                                let package_name = realpath.file_name().unwrap().to_string_lossy();
+                                let size = file.metadata().ok()?.len();
+                                Some(gen_package_info(&package_name, &realpath, size))
+                            } else {
+                                error!("{}", err);
+                                None
+                            }
                         } else {
-                            package_path
-                        };
-                        let file = File::open(&realpath)?;
-                        let mut buf_reader = BufReader::new(&file);
-                        if get_file_type(&mut buf_reader) != FileType::Unknown {
-                            let package_name = realpath.file_name().unwrap().to_string_lossy();
-                            let size = file.metadata()?.len();
-                            let package = gen_package_info(&package_name, &realpath, size)?;
-                            return Ok(package);
-                        };
-                    };
-                    Err(anyhow::anyhow!("Package {} not found.", package_name))
+                            error!("{}", err);
+                            None
+                        }
+                    }
                 }
             })
             .collect();
-        let resolved_packages = resolved_packages?;
 
         let results: Vec<_> = join_all(resolved_packages.iter().map(|package| {
             let installed_packages = Arc::clone(&installed_packages);