chore(release): 3.0.0-beta.5

Author: afonsojramos

rust/Cargo.lock

@@ -3,7 +3,7 @@ members = ["crates/spicetify", "crates/cli", "crates/tui", "crates/daemon"]
 resolver = "2"
 
 [workspace.package]
-version = "3.0.0-beta.4"
+version = "3.0.0-beta.5"
 edition = "2024"
 rust-version = "1.95"
 repository = "https://github.com/veryboringhwl/app"

rust/Cargo.toml

@@ -52,7 +52,9 @@ fn offered_token(headers: &HeaderMap) -> Option<(String, String)> {
         .split(',')
         .map(str::trim)
         .find_map(|proto| {
-            proto.strip_prefix(TOKEN_PROTOCOL_PREFIX).map(|tok| (proto.to_string(), tok.to_string()))
+            proto
+                .strip_prefix(TOKEN_PROTOCOL_PREFIX)
+                .map(|tok| (proto.to_string(), tok.to_string()))
         })
 }
 

rust/crates/daemon/src/routes.rs

@@ -33,7 +33,8 @@ pub(crate) fn run(ctx: &AppContext) -> Result<()> {
 
     if !spa.exists() && !ctx.mirror && backup.exists() {
         tracing::info!("{}", fl!("restoring-spa-backup", path = spa.to_string_lossy()));
-        std::fs::rename(&backup, &spa).map_err(fs_err("restoring xpui.spa from the backup at", &spa))?;
+        std::fs::rename(&backup, &spa)
+            .map_err(fs_err("restoring xpui.spa from the backup at", &spa))?;
     }
 
     // Names the path on failure: a bare "Permission denied" here means the
@@ -109,9 +110,11 @@ pub(crate) fn run(ctx: &AppContext) -> Result<()> {
     }
 
     if dest_xpui.exists() {
-        std::fs::remove_dir_all(&dest_xpui).map_err(fs_err("removing the previous xpui at", &dest_xpui))?;
+        std::fs::remove_dir_all(&dest_xpui)
+            .map_err(fs_err("removing the previous xpui at", &dest_xpui))?;
     }
-    std::fs::rename(&tmp, &dest_xpui).map_err(fs_err("installing the patched client to", &dest_xpui))?;
+    std::fs::rename(&tmp, &dest_xpui)
+        .map_err(fs_err("installing the patched client to", &dest_xpui))?;
 
     ensure_daemon(ctx);
 

rust/crates/spicetify/src/commands/apply.rs

@@ -137,7 +137,10 @@ pub(crate) fn ensure_system_modules(ctx: &AppContext) {
 fn seed_system_module(ctx: &AppContext, vault: &Vault, id: &str) -> Result<()> {
     let module = vault.modules.get(id).ok_or_else(|| anyhow::anyhow!("not in the registry"))?;
     let version = resolve_version(module)?;
-    let entry = module.v.get(&version).ok_or_else(|| anyhow::anyhow!("{version} is not in the registry"))?;
+    let entry = module
+        .v
+        .get(&version)
+        .ok_or_else(|| anyhow::anyhow!("{version} is not in the registry"))?;
     if entry.artifacts.is_empty() {
         anyhow::bail!("{id}@{version} has no artifact");
     }
@@ -243,8 +246,7 @@ mod tests {
     #[test]
     #[ignore = "hits the live registry and downloads artifacts"]
     fn seed_live_installs_and_enables_system_modules() {
-        let root =
-            std::env::temp_dir().join(format!("spicetify-seed-live-{}", std::process::id()));
+        let root = std::env::temp_dir().join(format!("spicetify-seed-live-{}", std::process::id()));
         let _ = std::fs::remove_dir_all(&root);
         std::fs::create_dir_all(&root).expect("temp config");
 
@@ -260,10 +262,7 @@ mod tests {
         for id in SYSTEM_MODULES {
             let link = modules_root.join(id);
             assert!(link.exists(), "{id} enabled and reachable through modules/");
-            assert!(
-                link.join("metadata.json").is_file(),
-                "{id} unpacked with its metadata"
-            );
+            assert!(link.join("metadata.json").is_file(), "{id} unpacked with its metadata");
         }
         assert!(missing_system_modules(&modules_root).is_empty(), "nothing left to seed");
 
@@ -276,10 +275,18 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
         std::fs::create_dir_all(&dir).expect("temp dir");
 
-        assert_eq!(missing_system_modules(&dir), vec!["stdlib", "store"], "a fresh config needs both");
+        assert_eq!(
+            missing_system_modules(&dir),
+            vec!["stdlib", "store"],
+            "a fresh config needs both"
+        );
 
         std::fs::create_dir_all(dir.join("stdlib")).expect("stdlib dir");
-        assert_eq!(missing_system_modules(&dir), vec!["store"], "an installed module is left alone");
+        assert_eq!(
+            missing_system_modules(&dir),
+            vec!["store"],
+            "an installed module is left alone"
+        );
 
         std::fs::create_dir_all(dir.join("store")).expect("store dir");
         assert!(missing_system_modules(&dir).is_empty(), "nothing to seed once both exist");

rust/crates/spicetify/src/commands/pkg.rs

@@ -89,8 +89,9 @@ fn perform(ctx: &AppContext, action: ProtocolAction, uri: &Url) -> Result<()> {
             // Spicetify.Daemon, a spicetify:// link) could otherwise supply
             // the hash of its own bytes and have them verified against
             // themselves, which is no verification at all.
-            let checksum = crate::commands::pkg::registry_checksum(&id.module_identifier, &id.version)
-                .unwrap_or_default();
+            let checksum =
+                crate::commands::pkg::registry_checksum(&id.module_identifier, &id.version)
+                    .unwrap_or_default();
             if checksum.is_empty() {
                 tracing::warn!(
                     "{id}: not in the registry, so there is no checksum to verify these bytes against"
@@ -176,7 +177,6 @@ fn require_param(query: &[(Cow<'_, str>, Cow<'_, str>)], key: &str) -> Result<St
         .ok_or_else(|| anyhow::anyhow!("missing '{key}' query parameter"))
 }
 
-
 fn get_all_params(query: &[(Cow<'_, str>, Cow<'_, str>)], key: &str) -> Vec<String> {
     query.iter().filter(|(k, _)| k == key).map(|(_, v)| v.to_string()).collect()
 }

rust/crates/spicetify/src/commands/protocol.rs

@@ -225,8 +225,12 @@ mod tests {
     #[test]
     fn fixup_drops_a_stale_data_dir_so_detection_can_run() {
         let mut cfg = Config {
-            spotify_data_dir: Some(PathBuf::from("/spicetify-nonexistent/Spotify.app/Contents/Resources")),
-            spotify_exec: Some(PathBuf::from("/spicetify-nonexistent/Spotify.app/Contents/MacOS/Spotify")),
+            spotify_data_dir: Some(PathBuf::from(
+                "/spicetify-nonexistent/Spotify.app/Contents/Resources",
+            )),
+            spotify_exec: Some(PathBuf::from(
+                "/spicetify-nonexistent/Spotify.app/Contents/MacOS/Spotify",
+            )),
             ..Config::default()
         };
         // Neither path exists: the stale-config shape that shadowed detection

rust/crates/spicetify/src/context.rs

@@ -85,7 +85,9 @@ fn verify_checksum(expected: &str, bytes: &[u8]) -> Result<()> {
     let want = want.trim_start_matches("sha256:");
     let got = remote::digest(bytes);
     if want != got {
-        anyhow::bail!("checksum mismatch: the vault declares sha256:{want}, the download is sha256:{got}");
+        anyhow::bail!(
+            "checksum mismatch: the vault declares sha256:{want}, the download is sha256:{got}"
+        );
     }
     Ok(())
 }

rust/crates/spicetify/src/module/mod.rs

@@ -23,8 +23,10 @@ pub(crate) const fn spotify_binary_name() -> &'static str {
 /// location, fall back to the per-user one, then to Launch Services, and
 /// finally name `/Applications` so an error still points somewhere real.
 fn spotify_app_bundle() -> PathBuf {
-    let candidates =
-        [PathBuf::from("/Applications/Spotify.app"), base_dirs().home_dir().join("Applications/Spotify.app")];
+    let candidates = [
+        PathBuf::from("/Applications/Spotify.app"),
+        base_dirs().home_dir().join("Applications/Spotify.app"),
+    ];
     resolve_bundle(&candidates, spotlight_spotify)
 }
 
@@ -192,7 +194,8 @@ mod tests {
         // would be skipped like an empty leftover Spotify.app.
         let present = dir.clone();
         std::fs::create_dir_all(present.join("Contents").join("MacOS")).expect("bundle dirs");
-        std::fs::write(present.join("Contents").join("MacOS").join("Spotify"), b"").expect("bundle exec");
+        std::fs::write(present.join("Contents").join("MacOS").join("Spotify"), b"")
+            .expect("bundle exec");
         // A sentinel from spotlight proves it was never consulted: the valid
         // candidate short-circuits before the fallback runs.
         let sentinel = PathBuf::from("/sentinel/Spotify.app");
@@ -205,7 +208,10 @@ mod tests {
     fn resolve_bundle_falls_back_to_spotlight_then_applications() {
         let missing = PathBuf::from("/definitely/not/here/Spotify.app");
         let spotlit = PathBuf::from("/Users/someone/Applications/Spotify.app");
-        assert_eq!(resolve_bundle(std::slice::from_ref(&missing), || Some(spotlit.clone())), spotlit);
+        assert_eq!(
+            resolve_bundle(std::slice::from_ref(&missing), || Some(spotlit.clone())),
+            spotlit
+        );
         assert_eq!(
             resolve_bundle(&[missing], || None),
             PathBuf::from("/Applications/Spotify.app"),

rust/crates/spicetify/src/platform/macos.rs

@@ -144,8 +144,7 @@ mod removal_tests {
     use super::*;
 
     fn scratch(name: &str) -> std::path::PathBuf {
-        let dir =
-            std::env::temp_dir().join(format!("spicetify-rm-{name}-{}", std::process::id()));
+        let dir = std::env::temp_dir().join(format!("spicetify-rm-{name}-{}", std::process::id()));
         let _ = std::fs::remove_dir_all(&dir);
         std::fs::create_dir_all(&dir).expect("temp dir");
         dir