Add global version_comparator

plugins/updater/src/lib.rs

@@ -13,8 +13,9 @@
     html_favicon_url = "https://github.com/tauri-apps/tauri/raw/dev/app-icon.png"
 )]
 
-use std::ffi::OsString;
+use std::{ffi::OsString, sync::Arc};
 
+use semver::Version;
 use tauri::{
     plugin::{Builder as PluginBuilder, TauriPlugin},
     Manager, Runtime,
@@ -71,7 +72,11 @@ impl<R: Runtime, T: Manager<R>> UpdaterExt<R> for T {
     fn updater_builder(&self) -> UpdaterBuilder {
         let app = self.app_handle();
         let package_info = app.package_info();
-        let UpdaterState { config, target } = self.state::<UpdaterState>().inner();
+        let UpdaterState {
+            config,
+            target,
+            version_comparator,
+        } = self.state::<UpdaterState>().inner();
 
         let mut builder = UpdaterBuilder::new(
             package_info.name.clone(),
@@ -88,6 +93,10 @@ impl<R: Runtime, T: Manager<R>> UpdaterExt<R> for T {
             builder = builder.current_exe_args(args);
         }
 
+        if let Some(version_comparator) = version_comparator {
+            builder = builder.global_version_comparator(version_comparator.clone());
+        }
+
         #[cfg(any(
             target_os = "linux",
             target_os = "dragonfly",
@@ -118,13 +127,15 @@ impl<R: Runtime, T: Manager<R>> UpdaterExt<R> for T {
 struct UpdaterState {
     target: Option<String>,
     config: Config,
+    version_comparator: Option<GlobalVersionComparator>,
 }
 
 #[derive(Default)]
 pub struct Builder {
     target: Option<String>,
     pubkey: Option<String>,
     installer_args: Vec<OsString>,
+    version_comparator: Option<GlobalVersionComparator>,
 }
 
 impl Builder {
@@ -165,9 +176,18 @@ impl Builder {
         self
     }
 
+    pub fn version_comparator<F: Fn(Version, RemoteRelease) -> bool + Send + Sync + 'static>(
+        mut self,
+        f: F,
+    ) -> Self {
+        self.version_comparator.replace(Arc::new(f));
+        self
+    }
+
     pub fn build<R: Runtime>(self) -> TauriPlugin<R, Config> {
         let pubkey = self.pubkey;
         let target = self.target;
+        let version_comparator = self.version_comparator;
         let installer_args = self.installer_args;
         PluginBuilder::<R, Config>::new("updater")
             .setup(move |app, api| {
@@ -178,7 +198,11 @@ impl Builder {
                 if let Some(windows) = &mut config.windows {
                     windows.installer_args.extend_from_slice(&installer_args);
                 }
-                app.manage(UpdaterState { target, config });
+                app.manage(UpdaterState {
+                    target,
+                    config,
+                    version_comparator,
+                });
                 Ok(())
             })
             .invoke_handler(tauri::generate_handler![

plugins/updater/src/updater.rs

@@ -93,12 +93,14 @@ impl RemoteRelease {
 }
 
 pub type OnBeforeExit = Arc<dyn Fn() + Send + Sync + 'static>;
+pub(crate) type GlobalVersionComparator = Arc<dyn Fn(Version, RemoteRelease) -> bool + Send + Sync>;
 
 pub struct UpdaterBuilder {
     app_name: String,
     current_version: Version,
     config: Config,
     version_comparator: Option<Box<dyn Fn(Version, RemoteRelease) -> bool + Send + Sync>>,
+    global_version_comparator: Option<GlobalVersionComparator>,
     executable_path: Option<PathBuf>,
     target: Option<String>,
     endpoints: Option<Vec<Url>>,
@@ -125,6 +127,7 @@ impl UpdaterBuilder {
             current_version,
             config,
             version_comparator: None,
+            global_version_comparator: None,
             executable_path: None,
             target: None,
             endpoints: None,
@@ -221,6 +224,11 @@ impl UpdaterBuilder {
         self
     }
 
+    pub(crate) fn global_version_comparator(mut self, f: GlobalVersionComparator) -> Self {
+        self.global_version_comparator.replace(f);
+        self
+    }
+
     pub fn build(self) -> Result<Updater> {
         let endpoints = self
             .endpoints
@@ -252,6 +260,7 @@ impl UpdaterBuilder {
             app_name: self.app_name,
             current_version: self.current_version,
             version_comparator: self.version_comparator,
+            global_version_comparator: self.global_version_comparator,
             timeout: self.timeout,
             proxy: self.proxy,
             endpoints,
@@ -284,6 +293,7 @@ pub struct Updater {
     app_name: String,
     current_version: Version,
     version_comparator: Option<Box<dyn Fn(Version, RemoteRelease) -> bool + Send + Sync>>,
+    global_version_comparator: Option<GlobalVersionComparator>,
     timeout: Option<Duration>,
     proxy: Option<Url>,
     endpoints: Vec<Url>,
@@ -394,7 +404,15 @@ impl Updater {
 
         let should_update = match self.version_comparator.as_ref() {
             Some(comparator) => comparator(self.current_version.clone(), release.clone()),
-            None => release.version > self.current_version,
+            None => {
+                match self.global_version_comparator.as_ref() {
+                    Some(comparator) => comparator(self.current_version.clone(), release.clone()),
+                    None => {
+                        // default comparator
+                        release.version > self.current_version
+                    }
+                }
+            }
         };
 
         let update = if should_update {