Ignore if package already up-to-date

Signed-off-by: Jiahao XU <Jiahao_XU@outlook.com>

src/binstall/install.rs

@@ -15,6 +15,7 @@ pub async fn install(
     jobserver_client: LazyJobserverClient,
 ) -> Result<Option<MetaData>> {
     match resolution {
+        Resolution::AlreadyUpToDate => Ok(None),
         Resolution::Fetch {
             fetcher,
             package,

src/binstall/resolve.rs

@@ -8,7 +8,7 @@ use compact_str::{CompactString, ToCompactString};
 use log::{debug, error, info, warn};
 use miette::{miette, Result};
 use reqwest::Client;
-use semver::VersionReq;
+use semver::{Version, VersionReq};
 
 use super::Options;
 use crate::{
@@ -29,6 +29,7 @@ pub enum Resolution {
     InstallFromSource {
         package: Package<Meta>,
     },
+    AlreadyUpToDate,
 }
 impl Resolution {
     fn print(&self, opts: &Options) {
@@ -70,6 +71,7 @@ impl Resolution {
             Resolution::InstallFromSource { .. } => {
                 warn!("The package will be installed from source (with cargo)",)
             }
+            Resolution::AlreadyUpToDate => (),
         }
     }
 }
@@ -77,6 +79,7 @@ impl Resolution {
 pub async fn resolve(
     opts: Arc<Options>,
     crate_name: CrateName,
+    curr_version: Option<Version>,
     temp_dir: Arc<Path>,
     install_path: Arc<Path>,
     client: Client,
@@ -109,6 +112,19 @@ pub async fn resolve(
 
     let package = manifest.package.unwrap();
 
+    if let Some(curr_version) = curr_version {
+        let new_version =
+            Version::parse(&package.version).map_err(|err| BinstallError::VersionParse {
+                v: package.version.clone(),
+                err,
+            })?;
+
+        if new_version == curr_version {
+            info!("package {crate_name} is already up to date {curr_version}");
+            return Ok(Resolution::AlreadyUpToDate);
+        }
+    }
+
     let (mut meta, binaries) = (
         package
             .metadata

src/main.rs

@@ -354,26 +354,29 @@ async fn entry(jobserver_client: LazyJobserverClient) -> Result<()> {
     })?;
 
     // Remove installed crates
-    let crate_names = CrateName::dedup(crate_names).filter(|crate_name| {
+    let crate_names = CrateName::dedup(crate_names).filter_map(|crate_name| {
         if opts.force {
-            true
+            Some((crate_name, None))
         } else if let Some(records) = &metadata {
-            let keep = if let Some(version_req) = &crate_name.version_req {
+            if let Some(metadata) = records.get(&crate_name.name) {
-                records
+                if let Some(version_req) = &crate_name.version_req {
-                    .get(&crate_name.name)
+                    if version_req.is_latest_compatible(&metadata.current_version) {
-                    .map(|metadata| !version_req.is_latest_compatible(&metadata.current_version))
+                        info!(
-                    .unwrap_or(true)
+                            "package {crate_name} is already installed and cannot be upgraded, use --force to override"
+                        );
+                        None
+                    } else {
+                        Some((crate_name, Some(metadata.current_version.clone())))
+                    }
+                } else {
+                    info!("package {crate_name} is already installed, use --force to override");
+                    None
+                }
             } else {
-                !records.contains(&crate_name.name)
+                Some((crate_name, None))
-            };
-
-            if !keep {
-                info!("package {crate_name} is already installed, use --force to override")
             }
-
-            keep
         } else {
-            true
+            Some((crate_name, None))
         }
     });
 
@@ -395,10 +398,11 @@ async fn entry(jobserver_client: LazyJobserverClient) -> Result<()> {
         // Resolve crates
         let tasks: Vec<_> = crate_names
             .into_iter()
-            .map(|crate_name| {
+            .map(|(crate_name, current_version)| {
                 AutoAbortJoinHandle::spawn(binstall::resolve(
                     binstall_opts.clone(),
                     crate_name,
+                    current_version,
                     temp_dir_path.clone(),
                     install_path.clone(),
                     client.clone(),
@@ -430,7 +434,7 @@ async fn entry(jobserver_client: LazyJobserverClient) -> Result<()> {
         // Resolve crates and install without confirmation
         crate_names
             .into_iter()
-            .map(|crate_name| {
+            .map(|(crate_name, current_version)| {
                 let opts = binstall_opts.clone();
                 let temp_dir_path = temp_dir_path.clone();
                 let jobserver_client = jobserver_client.clone();
@@ -442,6 +446,7 @@ async fn entry(jobserver_client: LazyJobserverClient) -> Result<()> {
                     let resolution = binstall::resolve(
                         opts.clone(),
                         crate_name,
+                        current_version,
                         temp_dir_path,
                         install_path,
                         client,