From 302e3e3c4fe04c8aff15b7605afa3e343499837e Mon Sep 17 00:00:00 2001 From: Taku Kodma <79110363+risu729@users.noreply.github.com> Date: Tue, 19 May 2026 22:08:22 +1000 Subject: [PATCH 1/7] fix(spm): classify artifact bundle lock options --- src/backend/mod.rs | 1 + src/backend/spm.rs | 97 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 98 insertions(+) diff --git a/src/backend/mod.rs b/src/backend/mod.rs index 03e2ab24ec..d69f4d87bc 100644 --- a/src/backend/mod.rs +++ b/src/backend/mod.rs @@ -385,6 +385,7 @@ pub fn install_time_option_keys_for_type(backend_type: &BackendType) -> Vec npm::install_time_option_keys(), BackendType::Pipx => pipx::install_time_option_keys(), BackendType::Aqua => aqua::install_time_option_keys(), + BackendType::Spm => spm::install_time_option_keys(), _ => vec![], } } diff --git a/src/backend/spm.rs b/src/backend/spm.rs index 884f27fc93..26362f7d30 100644 --- a/src/backend/spm.rs +++ b/src/backend/spm.rs @@ -16,6 +16,7 @@ use eyre::{WrapErr, bail}; use serde::Deserialize; use serde::Deserializer; use serde::de::{MapAccess, Visitor}; +use std::collections::BTreeMap; use std::path::{Path, PathBuf}; use std::{ fmt::{self, Debug}, @@ -74,6 +75,30 @@ impl<'a> SpmOptions<'a> { mode.requires_artifactbundle() || self.artifactbundle_asset().is_some() } + fn lockfile_options(&self) -> BTreeMap { + let mut opts = BTreeMap::new(); + let provider = self.provider(); + if provider != GitProviderKind::GitHub.as_ref() { + opts.insert("provider".to_string(), provider.to_string()); + } + if let Some(api_url) = self.api_url() { + opts.insert("api_url".to_string(), api_url.to_string()); + } + match self.artifactbundle_mode() { + ArtifactBundleMode::Required => { + opts.insert("artifactbundle".to_string(), "true".to_string()); + } + ArtifactBundleMode::SourceOnly => { + opts.insert("artifactbundle".to_string(), "false".to_string()); + } + ArtifactBundleMode::Auto => {} + } + if let Some(asset) = self.artifactbundle_asset() { + opts.insert("artifactbundle_asset".to_string(), asset.to_string()); + } + opts + } + fn filter_bins(&self) -> Option> { let value = self.values.raw().opts.get("filter_bins")?; let bins: Vec = match value { @@ -115,6 +140,15 @@ impl Backend for SPMBackend { &["provider", "api_url", "artifactbundle_asset"] } + fn resolve_lockfile_options( + &self, + request: &crate::toolset::ToolRequest, + _target: &crate::backend::platform_target::PlatformTarget, + ) -> BTreeMap { + let raw_opts = request.options(); + SpmOptions::new(&raw_opts).lockfile_options() + } + async fn _list_remote_versions(&self, config: &Arc) -> eyre::Result> { let raw_opts = config.get_tool_opts_with_overrides(&self.ba).await?; let opts = SpmOptions::new(&raw_opts); @@ -221,6 +255,16 @@ impl Backend for SPMBackend { } } +pub fn install_time_option_keys() -> Vec { + vec![ + "provider".into(), + "api_url".into(), + "artifactbundle".into(), + "artifactbundle_asset".into(), + "filter_bins".into(), + ] +} + impl SPMBackend { pub fn from_arg(ba: BackendArg) -> Self { Self { ba: Arc::new(ba) } @@ -1071,6 +1115,59 @@ mod tests { } } + #[test] + fn test_lockfile_options_include_artifact_inputs_not_filter_bins() { + let mut opts = ToolVersionOptions::default(); + opts.opts.insert( + "provider".to_string(), + toml::Value::String("gitlab".to_string()), + ); + opts.opts.insert( + "api_url".to_string(), + toml::Value::String("https://gitlab.example.com/api/v4".to_string()), + ); + opts.opts + .insert("artifactbundle".to_string(), toml::Value::Boolean(true)); + opts.opts.insert( + "artifactbundle_asset".to_string(), + toml::Value::String("tool.artifactbundle.zip".to_string()), + ); + opts.opts.insert( + "filter_bins".to_string(), + toml::Value::String("tool".to_string()), + ); + + assert_eq!( + SpmOptions::new(&opts).lockfile_options(), + BTreeMap::from([ + ( + "api_url".to_string(), + "https://gitlab.example.com/api/v4".to_string() + ), + ("artifactbundle".to_string(), "true".to_string()), + ( + "artifactbundle_asset".to_string(), + "tool.artifactbundle.zip".to_string() + ), + ("provider".to_string(), "gitlab".to_string()), + ]) + ); + } + + #[test] + fn test_install_time_options_include_layout_and_artifact_inputs() { + assert_eq!( + install_time_option_keys(), + vec![ + "provider".to_string(), + "api_url".to_string(), + "artifactbundle".to_string(), + "artifactbundle_asset".to_string(), + "filter_bins".to_string(), + ] + ); + } + fn release_asset(name: &str) -> ArtifactBundleReleaseAsset { ArtifactBundleReleaseAsset { name: name.to_string(), From 435092005273c76b56f5d3b7d6826c81bbbe2d82 Mon Sep 17 00:00:00 2001 From: Taku Kodma <79110363+risu729@users.noreply.github.com> Date: Tue, 19 May 2026 22:33:16 +1000 Subject: [PATCH 2/7] fix(spm): honor target artifact options --- src/backend/spm.rs | 163 +++++++++++++++++++++++++++++++-------------- 1 file changed, 114 insertions(+), 49 deletions(-) diff --git a/src/backend/spm.rs b/src/backend/spm.rs index 26362f7d30..224806f471 100644 --- a/src/backend/spm.rs +++ b/src/backend/spm.rs @@ -1,7 +1,8 @@ use crate::backend::Backend; use crate::backend::VersionInfo; use crate::backend::backend_type::BackendType; -use crate::backend::options::{BackendOptions, bool_value}; +use crate::backend::options::{BackendOptions, is_falsey, is_truthy}; +use crate::backend::platform_target::PlatformTarget; use crate::cli::args::BackendArg; use crate::cmd::CmdLineRunner; use crate::config::{Config, Settings}; @@ -46,55 +47,65 @@ impl<'a> SpmOptions<'a> { } } - fn provider(&self) -> &'a str { - self.values - .str("provider") - .unwrap_or(GitProviderKind::GitHub.as_ref()) + fn option_string(&self, key: &str, target: Option<&PlatformTarget>) -> Option { + target + .and_then(|target| self.values.platform_string_for_target(key, target)) + .or_else(|| self.values.platform_string(key)) } - fn api_url(&self) -> Option<&'a str> { - self.values.str("api_url") + fn provider(&self, target: Option<&PlatformTarget>) -> String { + self.option_string("provider", target) + .unwrap_or_else(|| GitProviderKind::GitHub.as_ref().to_string()) } - fn artifactbundle_asset(&self) -> Option<&'a str> { - self.values.str("artifactbundle_asset") + fn api_url(&self, target: Option<&PlatformTarget>) -> Option { + self.option_string("api_url", target) } - fn artifactbundle_mode(&self) -> ArtifactBundleMode { - let Some(value) = self.values.raw().opts.get("artifactbundle") else { - return ArtifactBundleMode::Auto; + fn artifactbundle_asset(&self, target: Option<&PlatformTarget>) -> Option { + self.option_string("artifactbundle_asset", target) + } + + fn artifactbundle_mode( + &self, + target: Option<&PlatformTarget>, + ) -> eyre::Result { + let Some(value) = self.option_string("artifactbundle", target) else { + return Ok(ArtifactBundleMode::Auto); }; - match bool_value("artifactbundle", value) { - Some(true) => ArtifactBundleMode::Required, - Some(false) => ArtifactBundleMode::SourceOnly, - None => ArtifactBundleMode::Auto, + if is_truthy(&value) { + Ok(ArtifactBundleMode::Required) + } else if is_falsey(&value) { + Ok(ArtifactBundleMode::SourceOnly) + } else { + bail!("artifactbundle must be true, false, 1, or 0, got {value}"); } } fn requires_artifactbundle(&self, mode: ArtifactBundleMode) -> bool { - mode.requires_artifactbundle() || self.artifactbundle_asset().is_some() + mode.requires_artifactbundle() || self.artifactbundle_asset(None).is_some() } - fn lockfile_options(&self) -> BTreeMap { + fn lockfile_options(&self, target: &PlatformTarget) -> BTreeMap { let mut opts = BTreeMap::new(); - let provider = self.provider(); + let provider = self.provider(Some(target)); if provider != GitProviderKind::GitHub.as_ref() { - opts.insert("provider".to_string(), provider.to_string()); + opts.insert("provider".to_string(), provider); } - if let Some(api_url) = self.api_url() { - opts.insert("api_url".to_string(), api_url.to_string()); + if let Some(api_url) = self.api_url(Some(target)) { + opts.insert("api_url".to_string(), api_url); } - match self.artifactbundle_mode() { - ArtifactBundleMode::Required => { + match self.artifactbundle_mode(Some(target)) { + Ok(ArtifactBundleMode::Required) => { opts.insert("artifactbundle".to_string(), "true".to_string()); } - ArtifactBundleMode::SourceOnly => { + Ok(ArtifactBundleMode::SourceOnly) => { opts.insert("artifactbundle".to_string(), "false".to_string()); } - ArtifactBundleMode::Auto => {} + Ok(ArtifactBundleMode::Auto) | Err(_) => {} } - if let Some(asset) = self.artifactbundle_asset() { - opts.insert("artifactbundle_asset".to_string(), asset.to_string()); + if let Some(asset) = self.artifactbundle_asset(Some(target)) { + opts.insert("artifactbundle_asset".to_string(), asset); } opts } @@ -143,10 +154,10 @@ impl Backend for SPMBackend { fn resolve_lockfile_options( &self, request: &crate::toolset::ToolRequest, - _target: &crate::backend::platform_target::PlatformTarget, + target: &PlatformTarget, ) -> BTreeMap { let raw_opts = request.options(); - SpmOptions::new(&raw_opts).lockfile_options() + SpmOptions::new(&raw_opts).lockfile_options(target) } async fn _list_remote_versions(&self, config: &Arc) -> eyre::Result> { @@ -213,7 +224,7 @@ impl Backend for SPMBackend { tv.version.clone() }; - let artifactbundle_mode = opts.artifactbundle_mode(); + let artifactbundle_mode = opts.artifactbundle_mode(None)?; if artifactbundle_mode == ArtifactBundleMode::SourceOnly && Settings::get().spm.artifactbundle_only { @@ -566,7 +577,7 @@ impl GitProvider { } fn from_ba_with_opts(ba: &BackendArg, opts: &SpmOptions<'_>) -> Self { - let provider = opts.provider(); + let provider = opts.provider(None); let kind = if ba.tool_name.contains("gitlab.com") { GitProviderKind::GitLab } else { @@ -576,7 +587,7 @@ impl GitProvider { } }; - let api_url = match opts.api_url() { + let api_url = match opts.api_url(None) { Some(api_url) => api_url.trim_end_matches('/').to_string(), None => { Self::derive_api_url_from_tool_name(&ba.tool_name, &kind).unwrap_or_else(|| { @@ -742,9 +753,9 @@ fn select_artifactbundle_asset( assets: Vec, opts: &SpmOptions<'_>, ) -> eyre::Result> { - let artifactbundle_asset = opts.artifactbundle_asset(); + let artifactbundle_asset = opts.artifactbundle_asset(None); if let Some(name) = artifactbundle_asset { - if !is_artifactbundle_zip(name) { + if !is_artifactbundle_zip(&name) { bail!("artifactbundle_asset must end with .artifactbundle.zip, got {name}"); } return assets @@ -1138,7 +1149,7 @@ mod tests { ); assert_eq!( - SpmOptions::new(&opts).lockfile_options(), + SpmOptions::new(&opts).lockfile_options(&PlatformTarget::from_current()), BTreeMap::from([ ( "api_url".to_string(), @@ -1154,6 +1165,44 @@ mod tests { ); } + #[test] + fn test_lockfile_options_use_target_platform_artifact_inputs() { + let mut opts = ToolVersionOptions::default(); + let mut platforms = toml::Table::new(); + let mut linux = toml::Table::new(); + let mut windows = toml::Table::new(); + linux.insert( + "artifactbundle_asset".to_string(), + toml::Value::String("linux.artifactbundle.zip".to_string()), + ); + windows.insert( + "artifactbundle_asset".to_string(), + toml::Value::String("windows.artifactbundle.zip".to_string()), + ); + platforms.insert("linux-x64".to_string(), toml::Value::Table(linux)); + platforms.insert("windows-x64".to_string(), toml::Value::Table(windows)); + opts.opts + .insert("platforms".to_string(), toml::Value::Table(platforms)); + + let linux = PlatformTarget::new(crate::platform::Platform::parse("linux-x64").unwrap()); + let windows = PlatformTarget::new(crate::platform::Platform::parse("windows-x64").unwrap()); + + assert_eq!( + SpmOptions::new(&opts).lockfile_options(&linux), + BTreeMap::from([( + "artifactbundle_asset".to_string(), + "linux.artifactbundle.zip".to_string() + )]) + ); + assert_eq!( + SpmOptions::new(&opts).lockfile_options(&windows), + BTreeMap::from([( + "artifactbundle_asset".to_string(), + "windows.artifactbundle.zip".to_string() + )]) + ); + } + #[test] fn test_install_time_options_include_layout_and_artifact_inputs() { assert_eq!( @@ -1193,52 +1242,68 @@ mod tests { fn test_resolve_artifactbundle_mode() { let default_opts = ToolVersionOptions::default(); assert_eq!( - SpmOptions::new(&default_opts).artifactbundle_mode(), + SpmOptions::new(&default_opts) + .artifactbundle_mode(None) + .unwrap(), ArtifactBundleMode::Auto ); let required_opts = opts_with("artifactbundle", toml::Value::Boolean(true)); assert_eq!( - SpmOptions::new(&required_opts).artifactbundle_mode(), + SpmOptions::new(&required_opts) + .artifactbundle_mode(None) + .unwrap(), ArtifactBundleMode::Required ); let source_only_opts = opts_with("artifactbundle", toml::Value::Boolean(false)); assert_eq!( - SpmOptions::new(&source_only_opts).artifactbundle_mode(), + SpmOptions::new(&source_only_opts) + .artifactbundle_mode(None) + .unwrap(), ArtifactBundleMode::SourceOnly ); let required_opts = opts_with("artifactbundle", toml::Value::String("TRUE".to_string())); assert_eq!( - SpmOptions::new(&required_opts).artifactbundle_mode(), + SpmOptions::new(&required_opts) + .artifactbundle_mode(None) + .unwrap(), ArtifactBundleMode::Required ); let required_opts = opts_with("artifactbundle", toml::Value::String("1".to_string())); assert_eq!( - SpmOptions::new(&required_opts).artifactbundle_mode(), + SpmOptions::new(&required_opts) + .artifactbundle_mode(None) + .unwrap(), ArtifactBundleMode::Required ); let source_only_opts = opts_with("artifactbundle", toml::Value::String("FALSE".to_string())); assert_eq!( - SpmOptions::new(&source_only_opts).artifactbundle_mode(), + SpmOptions::new(&source_only_opts) + .artifactbundle_mode(None) + .unwrap(), ArtifactBundleMode::SourceOnly ); let source_only_opts = opts_with("artifactbundle", toml::Value::String("0".to_string())); assert_eq!( - SpmOptions::new(&source_only_opts).artifactbundle_mode(), + SpmOptions::new(&source_only_opts) + .artifactbundle_mode(None) + .unwrap(), ArtifactBundleMode::SourceOnly ); let invalid_opts = opts_with("artifactbundle", toml::Value::String("00".to_string())); - assert_eq!( - SpmOptions::new(&invalid_opts).artifactbundle_mode(), - ArtifactBundleMode::Auto + assert!( + SpmOptions::new(&invalid_opts) + .artifactbundle_mode(None) + .is_err() ); let invalid_opts = opts_with( "artifactbundle", toml::Value::String("sometimes".to_string()), ); - assert_eq!( - SpmOptions::new(&invalid_opts).artifactbundle_mode(), - ArtifactBundleMode::Auto + assert!( + SpmOptions::new(&invalid_opts) + .artifactbundle_mode(None) + .is_err() ); } From e7445c0013495ba6b33abe0a187dead5cdcf0583 Mon Sep 17 00:00:00 2001 From: Taku Kodma <79110363+risu729@users.noreply.github.com> Date: Tue, 19 May 2026 22:55:34 +1000 Subject: [PATCH 3/7] fix(spm): avoid host fallback for target options --- src/backend/spm.rs | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/src/backend/spm.rs b/src/backend/spm.rs index 224806f471..b56df551ff 100644 --- a/src/backend/spm.rs +++ b/src/backend/spm.rs @@ -48,9 +48,10 @@ impl<'a> SpmOptions<'a> { } fn option_string(&self, key: &str, target: Option<&PlatformTarget>) -> Option { - target - .and_then(|target| self.values.platform_string_for_target(key, target)) - .or_else(|| self.values.platform_string(key)) + match target { + Some(target) => self.values.platform_string_for_target(key, target), + None => self.values.platform_string(key), + } } fn provider(&self, target: Option<&PlatformTarget>) -> String { @@ -1201,6 +1202,24 @@ mod tests { "windows.artifactbundle.zip".to_string() )]) ); + + let mut current_host_only_opts = ToolVersionOptions::default(); + let mut platforms = toml::Table::new(); + let mut linux = toml::Table::new(); + linux.insert( + "artifactbundle_asset".to_string(), + toml::Value::String("linux.artifactbundle.zip".to_string()), + ); + platforms.insert("linux-x64".to_string(), toml::Value::Table(linux)); + current_host_only_opts + .opts + .insert("platforms".to_string(), toml::Value::Table(platforms)); + + assert!( + SpmOptions::new(¤t_host_only_opts) + .lockfile_options(&windows) + .is_empty() + ); } #[test] From 20f1f20fb0210e7fc0d83d7972153db65a6da55f Mon Sep 17 00:00:00 2001 From: Taku Kodma <79110363+risu729@users.noreply.github.com> Date: Sun, 31 May 2026 19:19:03 +1000 Subject: [PATCH 4/7] fix(spm): canonicalize artifact lock options --- src/backend/spm.rs | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/src/backend/spm.rs b/src/backend/spm.rs index b56df551ff..6fe6e0646b 100644 --- a/src/backend/spm.rs +++ b/src/backend/spm.rs @@ -56,6 +56,7 @@ impl<'a> SpmOptions<'a> { fn provider(&self, target: Option<&PlatformTarget>) -> String { self.option_string("provider", target) + .map(|provider| provider.to_lowercase()) .unwrap_or_else(|| GitProviderKind::GitHub.as_ref().to_string()) } @@ -103,7 +104,12 @@ impl<'a> SpmOptions<'a> { Ok(ArtifactBundleMode::SourceOnly) => { opts.insert("artifactbundle".to_string(), "false".to_string()); } - Ok(ArtifactBundleMode::Auto) | Err(_) => {} + Err(_) => { + if let Some(artifactbundle) = self.option_string("artifactbundle", Some(target)) { + opts.insert("artifactbundle".to_string(), artifactbundle); + } + } + Ok(ArtifactBundleMode::Auto) => {} } if let Some(asset) = self.artifactbundle_asset(Some(target)) { opts.insert("artifactbundle_asset".to_string(), asset); @@ -1132,7 +1138,7 @@ mod tests { let mut opts = ToolVersionOptions::default(); opts.opts.insert( "provider".to_string(), - toml::Value::String("gitlab".to_string()), + toml::Value::String("GitLab".to_string()), ); opts.opts.insert( "api_url".to_string(), @@ -1166,6 +1172,19 @@ mod tests { ); } + #[test] + fn test_lockfile_options_include_invalid_artifactbundle_value() { + let opts = opts_with( + "artifactbundle", + toml::Value::String("sometimes".to_string()), + ); + + assert_eq!( + SpmOptions::new(&opts).lockfile_options(&PlatformTarget::from_current()), + BTreeMap::from([("artifactbundle".to_string(), "sometimes".to_string())]) + ); + } + #[test] fn test_lockfile_options_use_target_platform_artifact_inputs() { let mut opts = ToolVersionOptions::default(); From 74806c98300fc77e32bc611389ee05f83c14bfda Mon Sep 17 00:00:00 2001 From: Taku Kodma <79110363+risu729@users.noreply.github.com> Date: Mon, 1 Jun 2026 03:19:31 +1000 Subject: [PATCH 5/7] fix(spm): normalize SPM lock option metadata --- src/backend/mod.rs | 11 ++++++----- src/backend/spm.rs | 7 ++++++- 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/backend/mod.rs b/src/backend/mod.rs index d69f4d87bc..7fcf54e066 100644 --- a/src/backend/mod.rs +++ b/src/backend/mod.rs @@ -369,9 +369,11 @@ pub fn arg_to_backend(ba: BackendArg) -> Option { } } -/// Returns install-time-only option keys for a backend type. -/// These are options that only affect installation/download, not post-install behavior. -/// Used to filter cached options when config provides its own options. +/// Returns backend option keys whose cached values should be replaced by current config. +/// +/// Most keys affect installation/download identity, but backend-specific lists may also +/// include layout options that are stored in the install manifest and should not be +/// reused from stale cached options when config provides its own options. pub fn install_time_option_keys_for_type(backend_type: &BackendType) -> Vec { match backend_type { BackendType::Http => http::install_time_option_keys(), @@ -390,8 +392,7 @@ pub fn install_time_option_keys_for_type(backend_type: &BackendType) -> Vec bool { if matches!(backend_type, BackendType::Aqua) { return aqua::is_install_time_option_key(key); diff --git a/src/backend/spm.rs b/src/backend/spm.rs index 6fe6e0646b..962c1da209 100644 --- a/src/backend/spm.rs +++ b/src/backend/spm.rs @@ -47,6 +47,10 @@ impl<'a> SpmOptions<'a> { } } + /// Resolves an SPM option for either install-time host use or lockfile target use. + /// + /// Lockfiles can be generated for platforms other than the current host, so callers + /// that are building lock identity must not fall back to the host-specific option. fn option_string(&self, key: &str, target: Option<&PlatformTarget>) -> Option { match target { Some(target) => self.values.platform_string_for_target(key, target), @@ -62,6 +66,7 @@ impl<'a> SpmOptions<'a> { fn api_url(&self, target: Option<&PlatformTarget>) -> Option { self.option_string("api_url", target) + .map(|api_url| api_url.trim_end_matches('/').to_string()) } fn artifactbundle_asset(&self, target: Option<&PlatformTarget>) -> Option { @@ -1142,7 +1147,7 @@ mod tests { ); opts.opts.insert( "api_url".to_string(), - toml::Value::String("https://gitlab.example.com/api/v4".to_string()), + toml::Value::String("https://gitlab.example.com/api/v4/".to_string()), ); opts.opts .insert("artifactbundle".to_string(), toml::Value::Boolean(true)); From 2550c2bc53deb78b1edb10f844ce287826ddb9e8 Mon Sep 17 00:00:00 2001 From: Taku Kodma <79110363+risu729@users.noreply.github.com> Date: Mon, 1 Jun 2026 03:50:21 +1000 Subject: [PATCH 6/7] fix(spm): avoid duplicate api url normalization --- src/backend/spm.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/backend/spm.rs b/src/backend/spm.rs index 962c1da209..c1c8e85942 100644 --- a/src/backend/spm.rs +++ b/src/backend/spm.rs @@ -600,7 +600,7 @@ impl GitProvider { }; let api_url = match opts.api_url(None) { - Some(api_url) => api_url.trim_end_matches('/').to_string(), + Some(api_url) => api_url, None => { Self::derive_api_url_from_tool_name(&ba.tool_name, &kind).unwrap_or_else(|| { match kind { From 2edbfb8e24ff30513f5a6c0fb2143a5d0c2bf9cd Mon Sep 17 00:00:00 2001 From: Taku Kodma <79110363+risu729@users.noreply.github.com> Date: Mon, 1 Jun 2026 07:55:30 +1000 Subject: [PATCH 7/7] fix(spm): stop locking invalid artifact bundle options --- src/backend/spm.rs | 20 +------------------- 1 file changed, 1 insertion(+), 19 deletions(-) diff --git a/src/backend/spm.rs b/src/backend/spm.rs index c1c8e85942..732a6eac7e 100644 --- a/src/backend/spm.rs +++ b/src/backend/spm.rs @@ -109,12 +109,7 @@ impl<'a> SpmOptions<'a> { Ok(ArtifactBundleMode::SourceOnly) => { opts.insert("artifactbundle".to_string(), "false".to_string()); } - Err(_) => { - if let Some(artifactbundle) = self.option_string("artifactbundle", Some(target)) { - opts.insert("artifactbundle".to_string(), artifactbundle); - } - } - Ok(ArtifactBundleMode::Auto) => {} + Ok(ArtifactBundleMode::Auto) | Err(_) => {} } if let Some(asset) = self.artifactbundle_asset(Some(target)) { opts.insert("artifactbundle_asset".to_string(), asset); @@ -1177,19 +1172,6 @@ mod tests { ); } - #[test] - fn test_lockfile_options_include_invalid_artifactbundle_value() { - let opts = opts_with( - "artifactbundle", - toml::Value::String("sometimes".to_string()), - ); - - assert_eq!( - SpmOptions::new(&opts).lockfile_options(&PlatformTarget::from_current()), - BTreeMap::from([("artifactbundle".to_string(), "sometimes".to_string())]) - ); - } - #[test] fn test_lockfile_options_use_target_platform_artifact_inputs() { let mut opts = ToolVersionOptions::default();