Unified · Split
| @@ -48,12 +48,12 @@ pub(in crate::command::release_impl) fn edit_version_and_fixup_dependent_crates_ · 47 unmodified lines | ||
| 48 | 48 | |
| 49 | 49 | let crates_with_version_change: Vec<_> = crates |
| 50 | 50 | .iter() |
| 51 | − .filter_map(|c| c.mode.version_adjustment_bump().map(|b| (c.package, b.next_release()))) | |
| 51 | + .filter_map(|c| c.mode.version_adjustment_bump().map(|b| (c.package, &b.next_release))) | |
| 52 | 52 | .collect(); |
| 53 | 53 | for (package, possibly_new_version) in crates |
| 54 | 54 | .iter() |
| 55 | 55 | .filter(|c| c.mode.manifest_will_change()) |
| 56 | − .map(|c| (c.package, c.mode.version_adjustment_bump().map(|b| b.next_release()))) | |
| 56 | + .map(|c| (c.package, c.mode.version_adjustment_bump().map(|b| &b.next_release))) | |
| 57 | 57 | { |
| 58 | 58 | let mut entry_store; |
| 59 | 59 | let lock = match locks_by_manifest_path.entry(&package.manifest_path) { |
| @@ -80,7 +80,7 @@ pub(in crate::command::release_impl) fn edit_version_and_fixup_dependent_crates_ · 20 unmodified lines | ||
| 80 | 80 | && changelog_ids_probably_lacking_user_edits.is_empty()); |
| 81 | 81 | let safety_bumped_packages = crates |
| 82 | 82 | .iter() |
| 83 | − .filter_map(|c| c.mode.safety_bump().map(|b| (c.package, b.next_release()))) | |
| 83 | + .filter_map(|c| c.mode.safety_bump().map(|b| (c.package, &b.next_release))) | |
| 84 | 84 | .collect::<Vec<_>>(); |
| 85 | 85 | let commit_message = generate_commit_message( |
| 86 | 86 | &crates_and_versions_to_be_published, |
| @@ -205,58 +205,58 @@ fn present_dependencies( · 204 unmodified lines | ||
| 205 | 205 | } => (bump, Some(causing_dependency_names)), |
| 206 | 206 | VersionAdjustment::Changed { bump, .. } => (bump, None), |
| 207 | 207 | }; |
| 208 | − match &bump.next_release { | |
| 209 | − Ok(next_release) => { | |
| 210 | − if next_release > &dep.package.version { | |
| 211 | − log::info!( | |
| 212 | − "{} {}-bump {} package '{}' from {} to {} for publishing{}{}{}", | |
| 213 | − will(dry_run), | |
| 214 | − bump_spec, | |
| 215 | − kind, | |
| 216 | − dep.package.name, | |
| 217 | − dep.package.version, | |
| 218 | − next_release, | |
| 219 | − bump.latest_release | |
| 220 | − .as_ref() | |
| 221 | − .and_then(|latest_release| { | |
| 222 | − (dep.package.version != *latest_release) | |
| 223 | − .then(|| format!(", {} on crates.io", latest_release)) | |
| 224 | − }) | |
| 225 | − .unwrap_or_default(), | |
| 226 | − breaking_dependencies | |
| 227 | − .map(|causes| format!( | |
| 228 | − ", for SAFETY due to breaking package{} {}", | |
| 229 | − if causes.len() == 1 { "" } else { "s" }, | |
| 230 | − causes.iter().map(|n| format!("'{}'", n)).collect::<Vec<_>>().join(", ") | |
| 231 | − )) | |
| 232 | − .unwrap_or_default(), | |
| 233 | − (*next_release != bump.desired_release) | |
| 234 | − .then(|| format!(", ignoring computed version {}", bump.desired_release)) | |
| 235 | − .unwrap_or_default(), | |
| 236 | − ); | |
| 237 | − } else { | |
| 238 | − log::info!( | |
| 239 | − "Manifest version of {} package '{}' at {} is sufficient{}, ignoring computed version {}", | |
| 240 | − kind, | |
| 241 | − dep.package.name, | |
| 242 | − dep.package.version, | |
| 243 | − bump.latest_release | |
| 244 | − .as_ref() | |
| 245 | − .map(|latest_release| format!(" to succeed latest released version {}", latest_release)) | |
| 246 | − .unwrap_or_else(|| ", creating a new release 🎉".into()), | |
| 247 | − bump.desired_release | |
| 248 | − ); | |
| 249 | − } | |
| 250 | − } | |
| 251 | − Err(version::bump::Error::LatestReleaseMoreRecentThanDesiredOne(latest_release)) => { | |
| 252 | − log::warn!( | |
| 208 | + if let Some(latest_release) = bump | |
| 209 | + .latest_release | |
| 210 | + .as_ref() | |
| 211 | + .and_then(|lr| (*lr >= bump.desired_release).then(|| lr)) | |
| 212 | + { | |
| 213 | + log::warn!( | |
| 253 | 214 | "Latest published version of '{}' is {}, the new version is {}. Consider using --bump <level> or --bump-dependencies <level> or update the index with --update-crates-index.", |
| 254 | 215 | dep.package.name, |
| 255 | 216 | latest_release, |
| 256 | 217 | bump.desired_release |
| 257 | 218 | ); |
| 258 | − error = true; | |
| 259 | − } | |
| 219 | + error = true; | |
| 220 | + } | |
| 221 | + if bump.next_release > dep.package.version { | |
| 222 | + log::info!( | |
| 223 | + "{} {}-bump {} package '{}' from {} to {} for publishing{}{}{}", | |
| 224 | + will(dry_run), | |
| 225 | + bump_spec, | |
| 226 | + kind, | |
| 227 | + dep.package.name, | |
| 228 | + dep.package.version, | |
| 229 | + bump.next_release, | |
| 230 | + bump.latest_release | |
| 231 | + .as_ref() | |
| 232 | + .and_then(|latest_release| { | |
| 233 | + (dep.package.version != *latest_release) | |
| 234 | + .then(|| format!(", {} on crates.io", latest_release)) | |
| 235 | + }) | |
| 236 | + .unwrap_or_default(), | |
| 237 | + breaking_dependencies | |
| 238 | + .map(|causes| format!( | |
| 239 | + ", for SAFETY due to breaking package{} {}", | |
| 240 | + if causes.len() == 1 { "" } else { "s" }, | |
| 241 | + causes.iter().map(|n| format!("'{}'", n)).collect::<Vec<_>>().join(", ") | |
| 242 | + )) | |
| 243 | + .unwrap_or_default(), | |
| 244 | + (bump.next_release != bump.desired_release) | |
| 245 | + .then(|| format!(", ignoring computed version {}", bump.desired_release)) | |
| 246 | + .unwrap_or_default(), | |
| 247 | + ); | |
| 248 | + } else { | |
| 249 | + log::info!( | |
| 250 | + "Manifest version of {} package '{}' at {} is sufficient{}, ignoring computed version {}", | |
| 251 | + kind, | |
| 252 | + dep.package.name, | |
| 253 | + dep.package.version, | |
| 254 | + bump.latest_release | |
| 255 | + .as_ref() | |
| 256 | + .map(|latest_release| format!(" to succeed latest released version {}", latest_release)) | |
| 257 | + .unwrap_or_else(|| ", creating a new release 🎉".into()), | |
| 258 | + bump.desired_release | |
| 259 | + ); | |
| 260 | 260 | }; |
| 261 | 261 | } |
| 262 | 262 | dependency::Mode::NotForPublishing { .. } => {} |
| @@ -300,14 +300,7 @@ fn present_dependencies( · 37 unmodified lines | ||
| 300 | 300 | cause, |
| 301 | 301 | deps_and_bumps |
| 302 | 302 | .into_iter() |
| 303 | − .map(|(dep_name, bump)| format!( | |
| 304 | − "'{}' {} ➡ {}", | |
| 305 | − dep_name, | |
| 306 | − bump.package_version, | |
| 307 | − bump.next_release | |
| 308 | − .as_ref() | |
| 309 | − .expect("bailed earlier if there was an error") | |
| 310 | − )) | |
| 303 | + .map(|(dep_name, bump)| format!("'{}' {} ➡ {}", dep_name, bump.package_version, bump.next_release)) | |
| 311 | 304 | .collect::<Vec<_>>() |
| 312 | 305 | .join(", ") |
| 313 | 306 | ); |
| @@ -40,7 +40,7 @@ pub fn try_to_published_crate_and_new_version<'meta, 'a>( · 39 unmodified lines | ||
| 40 | 40 | ) -> Option<(&'meta Package, &'a semver::Version)> { |
| 41 | 41 | match &c.mode { |
| 42 | 42 | crate::traverse::dependency::Mode::ToBePublished { adjustment } => { |
| 43 | − Some((c.package, adjustment.bump().next_release())) | |
| 43 | + Some((c.package, &adjustment.bump().next_release)) | |
| 44 | 44 | } |
| 45 | 45 | _ => None, |
| 46 | 46 | } |
| @@ -59,31 +59,20 @@ fn bump_major_minor_patch(v: &mut semver::Version, bump_spec: BumpSpec) -> bool · 58 unmodified lines | ||
| 59 | 59 | } |
| 60 | 60 | } |
| 61 | 61 | |
| 62 | −pub mod bump { | |
| 63 | − #[derive(Clone, Debug)] | |
| 64 | − pub enum Error { | |
| 65 | − LatestReleaseMoreRecentThanDesiredOne(semver::Version), | |
| 66 | − } | |
| 67 | −} | |
| 68 | − | |
| 69 | 62 | #[derive(Clone, Debug)] |
| 70 | 63 | pub struct Bump { |
| 71 | − pub next_release: Result<semver::Version, bump::Error>, | |
| 64 | + pub next_release: semver::Version, | |
| 72 | 65 | pub package_version: semver::Version, |
| 73 | 66 | pub latest_release: Option<semver::Version>, |
| 74 | 67 | pub desired_release: semver::Version, |
| 75 | 68 | } |
| 76 | 69 | |
| 77 | 70 | impl Bump { |
| 78 | − pub(crate) fn next_release(&self) -> &semver::Version { | |
| 79 | − self.next_release.as_ref().expect("only valid versions here") | |
| 80 | − } | |
| 81 | − | |
| 82 | 71 | pub(crate) fn next_release_changes_manifest(&self) -> bool { |
| 83 | − self.next_release() > &self.package_version | |
| 72 | + self.next_release > self.package_version | |
| 84 | 73 | } |
| 85 | 74 | pub(crate) fn is_breaking(&self) -> bool { |
| 86 | − rhs_is_breaking_bump_for_lhs(&self.package_version, self.next_release()) | |
| 75 | + rhs_is_breaking_bump_for_lhs(&self.package_version, &self.next_release) | |
| 87 | 76 | } |
| 88 | 77 | } |
| 89 | 78 | |
| @@ -147,9 +136,7 @@ pub(crate) fn bump_package_with_spec( · 57 unmodified lines | ||
| 147 | 136 | let latest_release = semver::Version::parse(published_crate.latest_version().version()) |
| 148 | 137 | .expect("valid version in crate index"); |
| 149 | 138 | let next_release = if latest_release >= desired_release { |
| 150 | − Err(bump::Error::LatestReleaseMoreRecentThanDesiredOne( | |
| 151 | − latest_release.clone(), | |
| 152 | − )) | |
| 139 | + desired_release.clone() | |
| 153 | 140 | } else { |
| 154 | 141 | let mut next_release = desired_release.clone(); |
| 155 | 142 | if bump_when_needed && package.version > latest_release && desired_release != package.version { |
| @@ -161,17 +148,17 @@ pub(crate) fn bump_package_with_spec( · 5 unmodified lines | ||
| 161 | 148 | next_release = package.version.clone(); |
| 162 | 149 | }; |
| 163 | 150 | } |
| 164 | − Ok(next_release) | |
| 151 | + next_release | |
| 165 | 152 | }; |
| 166 | 153 | (Some(latest_release), next_release) |
| 167 | 154 | } |
| 168 | 155 | None => ( |
| 169 | 156 | None, |
| 170 | − Ok(if bump_when_needed { | |
| 157 | + if bump_when_needed { | |
| 171 | 158 | package.version.clone() |
| 172 | 159 | } else { |
| 173 | 160 | desired_release.clone() |
| 174 | − }), | |
| 161 | + }, | |
| 175 | 162 | ), |
| 176 | 163 | }; |
| 177 | 164 | Ok(Bump { |