diff --git a/CHANGELOG.md b/CHANGELOG.md index 0542d61b8..f1bf06c0b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -98,7 +98,7 @@ - Match wheel tags against `Requires-Python` major-minor ([#5289](https://github.com/astral-sh/uv/pull/5289)) - Remove Simple API cache files for alternative indexes in `cache clean` ([#5353](https://github.com/astral-sh/uv/pull/5353)) - Remove extraneous `are` from wheel tag error messages ([#5303](https://github.com/astral-sh/uv/pull/5303)) -- Allow conflicting prerelease strategies when forking ([#5150](https://github.com/astral-sh/uv/pull/5150)) +- Allow conflicting pre-release strategies when forking ([#5150](https://github.com/astral-sh/uv/pull/5150)) - Use tag error rather than requires-python error for ABI filtering ([#5296](https://github.com/astral-sh/uv/pull/5296)) ## 0.2.27 @@ -1107,7 +1107,7 @@ See [#2976](https://github.com/astral-sh/uv/pull/2976#discussion_r1566521453) fo - Accept `setup.py` and `setup.cfg` files in compile ([#2634](https://github.com/astral-sh/uv/pull/2634)) - Add `--no-binary` and `--only-binary` support to `requirements.txt` ([#2680](https://github.com/astral-sh/uv/pull/2680)) -- Allow prereleases, locals, and URLs in non-editable path requirements ([#2671](https://github.com/astral-sh/uv/pull/2671)) +- Allow pre-releases, locals, and URLs in non-editable path requirements ([#2671](https://github.com/astral-sh/uv/pull/2671)) - Use PEP 517 to extract dynamic `pyproject.toml` metadata ([#2633](https://github.com/astral-sh/uv/pull/2633)) - Add `Editable project location` and `Required-by` to `pip show` ([#2589](https://github.com/astral-sh/uv/pull/2589)) - Avoid `prepare_metadata_for_build_wheel` calls for Hatch packages with dynamic dependencies ([#2645](https://github.com/astral-sh/uv/pull/2645)) @@ -1457,7 +1457,7 @@ pass the `--native-tls` command-line flag to enable this behavior. - Expand scope of archive timestamping ([#1960](https://github.com/astral-sh/uv/pull/1960)) - Gracefully handle virtual environments with conflicting packages ([#1893](https://github.com/astral-sh/uv/pull/1893)) - Invalidate dependencies when editables are updated ([#1955](https://github.com/astral-sh/uv/pull/1955)) -- Make < exclusive for non-prerelease markers ([#1878](https://github.com/astral-sh/uv/pull/1878)) +- Make < exclusive for non-pre-release markers ([#1878](https://github.com/astral-sh/uv/pull/1878)) - Properly apply constraints in venv audit ([#1956](https://github.com/astral-sh/uv/pull/1956)) - Re-sync editables on-change ([#1959](https://github.com/astral-sh/uv/pull/1959)) - Remove current directory from PATH in PEP 517 hooks ([#1975](https://github.com/astral-sh/uv/pull/1975)) diff --git a/STYLE.md b/STYLE.md index 8484e8ecf..c169e07fa 100644 --- a/STYLE.md +++ b/STYLE.md @@ -30,6 +30,7 @@ Just uv, please. ## Terminology 1. Use "lockfile" not "lock file". +2. Use "pre-release", not "prerelease" (except in code, in which case: use `Prerelease`, not `PreRelease`; and `prerelease`, not `pre_release`). ## Documentation diff --git a/crates/pep440-rs/Readme.md b/crates/pep440-rs/Readme.md index 7fa8fb3f5..78b534151 100644 --- a/crates/pep440-rs/Readme.md +++ b/crates/pep440-rs/Readme.md @@ -38,16 +38,16 @@ PEP 440 has a lot of unintuitive features, including: * An epoch that you can prefix the version which, e.g. `1!1.2.3`. Lower epoch always means lower version (`1.0 <=2!0.1`) -* post versions, which can be attached to both stable releases and prereleases -* dev versions, which can be attached to sbpth table releases and prereleases. When attached to a - prerelease the dev version is ordered just below the normal prerelease, however when attached - to a stable version, the dev version is sorted before a prereleases -* prerelease handling is a mess: "Pre-releases of any kind, including developmental releases, +* post versions, which can be attached to both stable releases and pre-releases +* dev versions, which can be attached to sbpth table releases and pre-releases. When attached to a + pre-release the dev version is ordered just below the normal pre-release, however when attached + to a stable version, the dev version is sorted before a pre-releases +* pre-release handling is a mess: "Pre-releases of any kind, including developmental releases, are implicitly excluded from all version specifiers, unless they are already present on the system, explicitly requested by the user, or if the only available version that satisfies the version specifier is a pre-release.". This means that we can't say whether a specifier matches without also looking at the environment -* prelease vs. prerelease incl. dev is fuzzy +* pre-release vs. pre-release incl. dev is fuzzy * local versions on top of all the others, which are added with a + and have implicitly typed string and number segments * no semver-caret (`^`), but a pseudo-semver tilde (`~=`) diff --git a/crates/pep440-rs/python/Readme.md b/crates/pep440-rs/python/Readme.md index 01a88d249..2803c8eec 100644 --- a/crates/pep440-rs/python/Readme.md +++ b/crates/pep440-rs/python/Readme.md @@ -24,16 +24,16 @@ PEP 440 has a lot of unintuitive features, including: * An epoch that you can prefix the version which, e.g. `1!1.2.3`. Lower epoch always means lower version (`1.0 <=2!0.1`) -* post versions, which can be attached to both stable releases and prereleases -* dev versions, which can be attached to sbpth table releases and prereleases. When attached to a - prerelease the dev version is ordered just below the normal prerelease, however when attached - to a stable version, the dev version is sorted before a prereleases -* prerelease handling is a mess: "Pre-releases of any kind, including developmental releases, +* post versions, which can be attached to both stable releases and pre-releases +* dev versions, which can be attached to both table releases and pre-releases. When attached to a + pre-release the dev version is ordered just below the normal pre-release, however when attached + to a stable version, the dev version is sorted before a pre-releases +* pre-release handling is a mess: "Pre-releases of any kind, including developmental releases, are implicitly excluded from all version specifiers, unless they are already present on the system, explicitly requested by the user, or if the only available version that satisfies the version specifier is a pre-release.". This means that we can't say whether a specifier matches without also looking at the environment -* prelease vs. prerelease incl. dev is fuzzy +* pre-release vs. pre-release incl. dev is fuzzy * local versions on top of all the others, which are added with a + and have implicitly typed string and number segments * no semver-caret (`^`), but a pseudo-semver tilde (`~=`) diff --git a/crates/pep440-rs/src/lib.rs b/crates/pep440-rs/src/lib.rs index 754b03915..8af854047 100644 --- a/crates/pep440-rs/src/lib.rs +++ b/crates/pep440-rs/src/lib.rs @@ -16,16 +16,16 @@ //! //! * An epoch that you can prefix the version which, e.g. `1!1.2.3`. Lower epoch always means lower //! version (`1.0 <=2!0.1`) -//! * post versions, which can be attached to both stable releases and prereleases -//! * dev versions, which can be attached to sbpth table releases and prereleases. When attached to a -//! prerelease the dev version is ordered just below the normal prerelease, however when attached -//! to a stable version, the dev version is sorted before a prereleases -//! * prerelease handling is a mess: "Pre-releases of any kind, including developmental releases, +//! * post versions, which can be attached to both stable releases and pre-releases +//! * dev versions, which can be attached to both table releases and pre-releases. When attached to a +//! pre-release the dev version is ordered just below the normal pre-release, however when attached +//! to a stable version, the dev version is sorted before a pre-releases +//! * pre-release handling is a mess: "Pre-releases of any kind, including developmental releases, //! are implicitly excluded from all version specifiers, unless they are already present on the //! system, explicitly requested by the user, or if the only available version that satisfies //! the version specifier is a pre-release.". This means that we can't say whether a specifier //! matches without also looking at the environment -//! * prelease vs. prerelease incl. dev is fuzzy +//! * pre-release vs. pre-release incl. dev is fuzzy //! * local versions on top of all the others, which are added with a + and have implicitly typed //! string and number segments //! * no semver-caret (`^`), but a pseudo-semver tilde (`~=`) @@ -38,7 +38,7 @@ pub use version::PyVersion; pub use { version::{ - LocalSegment, Operator, OperatorParseError, PreRelease, PreReleaseKind, Version, + LocalSegment, Operator, OperatorParseError, Prerelease, PrereleaseKind, Version, VersionParseError, VersionPattern, VersionPatternParseError, MIN_VERSION, }, version_specifier::{ diff --git a/crates/pep440-rs/src/version.rs b/crates/pep440-rs/src/version.rs index b1eab39f4..5bd768475 100644 --- a/crates/pep440-rs/src/version.rs +++ b/crates/pep440-rs/src/version.rs @@ -371,7 +371,7 @@ impl Version { /// Returns the pre-release part of this version, if it exists. #[inline] - pub fn pre(&self) -> Option { + pub fn pre(&self) -> Option { match *self.inner { VersionInner::Small { ref small } => small.pre(), VersionInner::Full { ref full } => full.pre, @@ -501,7 +501,7 @@ impl Version { /// Set the pre-release component and return the updated version. #[inline] #[must_use] - pub fn with_pre(mut self, value: Option) -> Self { + pub fn with_pre(mut self, value: Option) -> Self { if let VersionInner::Small { ref mut small } = Arc::make_mut(&mut self.inner) { if small.set_pre(value) { return self; @@ -709,7 +709,7 @@ impl std::fmt::Display for Version { let pre = self .pre() .as_ref() - .map(|PreRelease { kind, number }| format!("{kind}{number}")) + .map(|Prerelease { kind, number }| format!("{kind}{number}")) .unwrap_or_default(); let post = self .post() @@ -1014,21 +1014,21 @@ impl VersionSmall { } #[inline] - fn pre(&self) -> Option { + fn pre(&self) -> Option { let (kind, number) = (self.suffix_kind(), self.suffix_version()); if kind == Self::SUFFIX_PRE_ALPHA { - Some(PreRelease { - kind: PreReleaseKind::Alpha, + Some(Prerelease { + kind: PrereleaseKind::Alpha, number, }) } else if kind == Self::SUFFIX_PRE_BETA { - Some(PreRelease { - kind: PreReleaseKind::Beta, + Some(Prerelease { + kind: PrereleaseKind::Beta, number, }) } else if kind == Self::SUFFIX_PRE_RC { - Some(PreRelease { - kind: PreReleaseKind::Rc, + Some(Prerelease { + kind: PrereleaseKind::Rc, number, }) } else { @@ -1037,7 +1037,7 @@ impl VersionSmall { } #[inline] - fn set_pre(&mut self, value: Option) -> bool { + fn set_pre(&mut self, value: Option) -> bool { if self.min().is_some() || self.dev().is_some() || self.post().is_some() @@ -1049,18 +1049,18 @@ impl VersionSmall { None => { self.set_suffix_kind(Self::SUFFIX_NONE); } - Some(PreRelease { kind, number }) => { + Some(Prerelease { kind, number }) => { if number > Self::SUFFIX_MAX_VERSION { return false; } match kind { - PreReleaseKind::Alpha => { + PrereleaseKind::Alpha => { self.set_suffix_kind(Self::SUFFIX_PRE_ALPHA); } - PreReleaseKind::Beta => { + PrereleaseKind::Beta => { self.set_suffix_kind(Self::SUFFIX_PRE_BETA); } - PreReleaseKind::Rc => { + PrereleaseKind::Rc => { self.set_suffix_kind(Self::SUFFIX_PRE_RC); } } @@ -1234,8 +1234,8 @@ struct VersionFull { /// i.e. alpha, beta or rc plus a number /// /// Note that whether this is Some influences the version range - /// matching since normally we exclude all prerelease versions - pre: Option, + /// matching since normally we exclude all pre-release versions + pre: Option, /// The [Post release /// version](https://peps.python.org/pep-0440/#post-releases), higher /// post version are preferred over lower post or none-post versions @@ -1353,14 +1353,14 @@ impl FromStr for VersionPattern { #[archive(check_bytes)] #[archive_attr(derive(Debug, Eq, PartialEq, PartialOrd, Ord))] #[cfg_attr(feature = "pyo3", pyclass)] -pub struct PreRelease { +pub struct Prerelease { /// The kind of pre-release. - pub kind: PreReleaseKind, + pub kind: PrereleaseKind, /// The number associated with the pre-release. pub number: u64, } -/// Optional prerelease modifier (alpha, beta or release candidate) appended to version +/// Optional pre-release modifier (alpha, beta or release candidate) appended to version /// /// #[derive( @@ -1379,16 +1379,16 @@ pub struct PreRelease { #[archive(check_bytes)] #[archive_attr(derive(Debug, Eq, PartialEq, PartialOrd, Ord))] #[cfg_attr(feature = "pyo3", pyclass)] -pub enum PreReleaseKind { - /// alpha prerelease +pub enum PrereleaseKind { + /// alpha pre-release Alpha, - /// beta prerelease + /// beta pre-release Beta, - /// release candidate prerelease + /// release candidate pre-release Rc, } -impl std::fmt::Display for PreReleaseKind { +impl std::fmt::Display for PrereleaseKind { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::Alpha => write!(f, "a"), @@ -1470,7 +1470,7 @@ struct Parser<'a> { /// The release numbers extracted from the version. release: ReleaseNumbers, /// The pre-release version, if any. - pre: Option, + pre: Option, /// The post-release version, if any. post: Option, /// The dev release, if any. @@ -1687,22 +1687,22 @@ impl<'a> Parser<'a> { // SPELLINGS and MAP are in correspondence. SPELLINGS is used to look // for what spelling is used in the version string (if any), and // the index of the element found is used to lookup which type of - // PreRelease it is. + // pre-release it is. // // Note also that the order of the strings themselves matters. If 'pre' // were before 'preview' for example, then 'preview' would never match // since the strings are matched in order. const SPELLINGS: StringSet = StringSet::new(&["alpha", "beta", "preview", "pre", "rc", "a", "b", "c"]); - const MAP: &[PreReleaseKind] = &[ - PreReleaseKind::Alpha, - PreReleaseKind::Beta, - PreReleaseKind::Rc, - PreReleaseKind::Rc, - PreReleaseKind::Rc, - PreReleaseKind::Alpha, - PreReleaseKind::Beta, - PreReleaseKind::Rc, + const MAP: &[PrereleaseKind] = &[ + PrereleaseKind::Alpha, + PrereleaseKind::Beta, + PrereleaseKind::Rc, + PrereleaseKind::Rc, + PrereleaseKind::Rc, + PrereleaseKind::Alpha, + PrereleaseKind::Beta, + PrereleaseKind::Rc, ]; let oldpos = self.i; @@ -1720,7 +1720,7 @@ impl<'a> Parser<'a> { // Under the normalization rules, a pre-release without an // explicit number defaults to `0`. let number = self.parse_number()?.unwrap_or(0); - self.pre = Some(PreRelease { kind, number }); + self.pre = Some(Prerelease { kind, number }); Ok(()) } @@ -2294,13 +2294,13 @@ impl PyVersion { pub fn release(&self) -> Vec { self.0.release().to_vec() } - /// The [prerelease](https://peps.python.org/pep-0440/#pre-releases), i.e. alpha, beta or rc + /// The [pre-release](https://peps.python.org/pep-0440/#pre-releases), i.e. alpha, beta or rc /// plus a number /// /// Note that whether this is Some influences the version - /// range matching since normally we exclude all prerelease versions + /// range matching since normally we exclude all pre-release versions #[getter] - pub fn pre(&self) -> Option { + pub fn pre(&self) -> Option { self.0.pre() } /// The [Post release version](https://peps.python.org/pep-0440/#post-releases), @@ -2452,8 +2452,8 @@ fn sortable_tuple(version: &Version) -> (u64, u64, Option, u64, &[LocalSegm (None, None, Some(n), None) => (1, 0, None, n, version.local()), // alpha release ( - Some(PreRelease { - kind: PreReleaseKind::Alpha, + Some(Prerelease { + kind: PrereleaseKind::Alpha, number: n, }), post, @@ -2462,8 +2462,8 @@ fn sortable_tuple(version: &Version) -> (u64, u64, Option, u64, &[LocalSegm ) => (2, n, post, dev.unwrap_or(u64::MAX), version.local()), // beta release ( - Some(PreRelease { - kind: PreReleaseKind::Beta, + Some(Prerelease { + kind: PrereleaseKind::Beta, number: n, }), post, @@ -2472,8 +2472,8 @@ fn sortable_tuple(version: &Version) -> (u64, u64, Option, u64, &[LocalSegm ) => (3, n, post, dev.unwrap_or(u64::MAX), version.local()), // alpha release ( - Some(PreRelease { - kind: PreReleaseKind::Rc, + Some(Prerelease { + kind: PrereleaseKind::Rc, number: n, }), post, @@ -2554,16 +2554,16 @@ mod tests { ("1.0.dev456", Version::new([1, 0]).with_dev(Some(456))), ( "1.0a1", - Version::new([1, 0]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([1, 0]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 1, })), ), ( "1.0a2.dev456", Version::new([1, 0]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 2, })) .with_dev(Some(456)), @@ -2571,40 +2571,40 @@ mod tests { ( "1.0a12.dev456", Version::new([1, 0]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 12, })) .with_dev(Some(456)), ), ( "1.0a12", - Version::new([1, 0]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([1, 0]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 12, })), ), ( "1.0b1.dev456", Version::new([1, 0]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 1, })) .with_dev(Some(456)), ), ( "1.0b2", - Version::new([1, 0]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + Version::new([1, 0]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 2, })), ), ( "1.0b2.post345.dev456", Version::new([1, 0]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 2, })) .with_dev(Some(456)) @@ -2613,8 +2613,8 @@ mod tests { ( "1.0b2.post345", Version::new([1, 0]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 2, })) .with_post(Some(345)), @@ -2622,8 +2622,8 @@ mod tests { ( "1.0b2-346", Version::new([1, 0]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 2, })) .with_post(Some(346)), @@ -2631,30 +2631,30 @@ mod tests { ( "1.0c1.dev456", Version::new([1, 0]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 1, })) .with_dev(Some(456)), ), ( "1.0c1", - Version::new([1, 0]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + Version::new([1, 0]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 1, })), ), ( "1.0rc2", - Version::new([1, 0]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + Version::new([1, 0]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 2, })), ), ( "1.0c3", - Version::new([1, 0]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + Version::new([1, 0]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 3, })), ), @@ -2719,8 +2719,8 @@ mod tests { "1!1.0a1", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 1, })), ), @@ -2728,8 +2728,8 @@ mod tests { "1!1.0a2.dev456", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 2, })) .with_dev(Some(456)), @@ -2738,8 +2738,8 @@ mod tests { "1!1.0a12.dev456", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 12, })) .with_dev(Some(456)), @@ -2748,8 +2748,8 @@ mod tests { "1!1.0a12", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 12, })), ), @@ -2757,8 +2757,8 @@ mod tests { "1!1.0b1.dev456", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 1, })) .with_dev(Some(456)), @@ -2767,8 +2767,8 @@ mod tests { "1!1.0b2", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 2, })), ), @@ -2776,8 +2776,8 @@ mod tests { "1!1.0b2.post345.dev456", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 2, })) .with_post(Some(345)) @@ -2787,8 +2787,8 @@ mod tests { "1!1.0b2.post345", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 2, })) .with_post(Some(345)), @@ -2797,8 +2797,8 @@ mod tests { "1!1.0b2-346", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 2, })) .with_post(Some(346)), @@ -2807,8 +2807,8 @@ mod tests { "1!1.0c1.dev456", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 1, })) .with_dev(Some(456)), @@ -2817,8 +2817,8 @@ mod tests { "1!1.0c1", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 1, })), ), @@ -2826,8 +2826,8 @@ mod tests { "1!1.0rc2", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 2, })), ), @@ -2835,8 +2835,8 @@ mod tests { "1!1.0c3", Version::new([1, 0]) .with_epoch(1) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 3, })), ), @@ -3254,134 +3254,134 @@ mod tests { // pre-release tests assert_eq!( p("5a1"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 1 })) ); assert_eq!( p("5alpha1"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 1 })) ); assert_eq!( p("5b1"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 1 })) ); assert_eq!( p("5beta1"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Beta, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Beta, number: 1 })) ); assert_eq!( p("5rc1"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 1 })) ); assert_eq!( p("5c1"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 1 })) ); assert_eq!( p("5preview1"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 1 })) ); assert_eq!( p("5pre1"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 1 })) ); assert_eq!( p("5.6.7pre1"), - Version::new([5, 6, 7]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Rc, + Version::new([5, 6, 7]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Rc, number: 1 })) ); assert_eq!( p("5alpha789"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 789 })) ); assert_eq!( p("5.alpha789"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 789 })) ); assert_eq!( p("5-alpha789"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 789 })) ); assert_eq!( p("5_alpha789"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 789 })) ); assert_eq!( p("5alpha.789"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 789 })) ); assert_eq!( p("5alpha-789"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 789 })) ); assert_eq!( p("5alpha_789"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 789 })) ); assert_eq!( p("5ALPHA789"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 789 })) ); assert_eq!( p("5aLpHa789"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 789 })) ); assert_eq!( p("5alpha"), - Version::new([5]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([5]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 0 })) ); @@ -3501,8 +3501,8 @@ mod tests { assert_eq!( p("5a2post3"), Version::new([5]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 2 })) .with_post(Some(3)) @@ -3510,8 +3510,8 @@ mod tests { assert_eq!( p("5.a-2_post-3"), Version::new([5]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 2 })) .with_post(Some(3)) @@ -3519,8 +3519,8 @@ mod tests { assert_eq!( p("5a2-3"), Version::new([5]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 2 })) .with_post(Some(3)) @@ -3769,8 +3769,8 @@ mod tests { // Ensure that the `.max` suffix plays nicely with pre-release versions. let greater = Version::new([1, 0]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 1, })) .with_max(Some(0)); @@ -3790,8 +3790,8 @@ mod tests { // Ensure that the `.max` suffix plays nicely with pre-release versions. let less = Version::new([1, 0]) - .with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + .with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 1, })) .with_max(Some(0)); diff --git a/crates/pep440-rs/src/version_specifier.rs b/crates/pep440-rs/src/version_specifier.rs index 4ac98c917..03bbd2872 100644 --- a/crates/pep440-rs/src/version_specifier.rs +++ b/crates/pep440-rs/src/version_specifier.rs @@ -537,7 +537,7 @@ impl VersionSpecifier { return false; } - // According to PEP 440, this ignores the prerelease special rules + // According to PEP 440, this ignores the pre-release special rules // pypa/packaging disagrees: https://github.com/pypa/packaging/issues/617 other >= this } diff --git a/crates/uv-cli/src/lib.rs b/crates/uv-cli/src/lib.rs index 2ca2f733d..96a9605b6 100644 --- a/crates/uv-cli/src/lib.rs +++ b/crates/uv-cli/src/lib.rs @@ -16,7 +16,7 @@ use uv_configuration::{ }; use uv_normalize::{ExtraName, PackageName}; use uv_python::{PythonFetch, PythonPreference, PythonVersion}; -use uv_resolver::{AnnotationStyle, ExcludeNewer, PreReleaseMode, ResolutionMode}; +use uv_resolver::{AnnotationStyle, ExcludeNewer, PrereleaseMode, ResolutionMode}; pub mod compat; pub mod options; @@ -2868,7 +2868,7 @@ pub struct ResolverArgs { /// along with first-party requirements that contain an explicit pre-release marker in the /// declared specifiers (`if-necessary-or-explicit`). #[arg(long, value_enum, env = "UV_PRERELEASE")] - pub prerelease: Option, + pub prerelease: Option, #[arg(long, hide = true)] pub pre: bool, @@ -2957,7 +2957,7 @@ pub struct ResolverInstallerArgs { /// along with first-party requirements that contain an explicit pre-release marker in the /// declared specifiers (`if-necessary-or-explicit`). #[arg(long, value_enum, env = "UV_PRERELEASE")] - pub prerelease: Option, + pub prerelease: Option, #[arg(long, hide = true)] pub pre: bool, diff --git a/crates/uv-cli/src/options.rs b/crates/uv-cli/src/options.rs index bed053794..d47f0fc28 100644 --- a/crates/uv-cli/src/options.rs +++ b/crates/uv-cli/src/options.rs @@ -1,6 +1,6 @@ use uv_cache::Refresh; use uv_configuration::ConfigSettings; -use uv_resolver::PreReleaseMode; +use uv_resolver::PrereleaseMode; use uv_settings::{PipOptions, ResolverInstallerOptions, ResolverOptions}; use crate::{ @@ -53,7 +53,7 @@ impl From for PipOptions { keyring_provider, resolution, prerelease: if pre { - Some(PreReleaseMode::Allow) + Some(PrereleaseMode::Allow) } else { prerelease }, @@ -128,7 +128,7 @@ impl From for PipOptions { keyring_provider, resolution, prerelease: if pre { - Some(PreReleaseMode::Allow) + Some(PrereleaseMode::Allow) } else { prerelease }, @@ -212,7 +212,7 @@ pub fn resolver_options(resolver_args: ResolverArgs, build_args: BuildArgs) -> R keyring_provider, resolution, prerelease: if pre { - Some(PreReleaseMode::Allow) + Some(PrereleaseMode::Allow) } else { prerelease }, @@ -283,7 +283,7 @@ pub fn resolver_installer_options( keyring_provider, resolution, prerelease: if pre { - Some(PreReleaseMode::Allow) + Some(PrereleaseMode::Allow) } else { prerelease }, diff --git a/crates/uv-python/src/python_version.rs b/crates/uv-python/src/python_version.rs index df52a4306..d261e2564 100644 --- a/crates/uv-python/src/python_version.rs +++ b/crates/uv-python/src/python_version.rs @@ -177,7 +177,7 @@ impl PythonVersion { mod tests { use std::str::FromStr; - use pep440_rs::{PreRelease, PreReleaseKind, Version}; + use pep440_rs::{Prerelease, PrereleaseKind, Version}; use crate::PythonVersion; @@ -200,8 +200,8 @@ mod tests { assert_eq!(version.python_version().to_string(), "3.11"); assert_eq!( version.python_full_version(), - Version::new([3, 11, 8]).with_pre(Some(PreRelease { - kind: PreReleaseKind::Alpha, + Version::new([3, 11, 8]).with_pre(Some(Prerelease { + kind: PrereleaseKind::Alpha, number: 1 })) ); diff --git a/crates/uv-resolver/src/candidate_selector.rs b/crates/uv-resolver/src/candidate_selector.rs index 9c66473d7..d866d0064 100644 --- a/crates/uv-resolver/src/candidate_selector.rs +++ b/crates/uv-resolver/src/candidate_selector.rs @@ -12,7 +12,7 @@ use uv_normalize::PackageName; use uv_types::InstalledPackagesProvider; use crate::preferences::Preferences; -use crate::prerelease_mode::{AllowPreRelease, PreReleaseStrategy}; +use crate::prerelease::{AllowPrerelease, PrereleaseStrategy}; use crate::resolution_mode::ResolutionStrategy; use crate::version_map::{VersionMap, VersionMapDistHandle}; use crate::{Exclusions, Manifest, Options, ResolverMarkers}; @@ -21,7 +21,7 @@ use crate::{Exclusions, Manifest, Options, ResolverMarkers}; #[allow(clippy::struct_field_names)] pub(crate) struct CandidateSelector { resolution_strategy: ResolutionStrategy, - prerelease_strategy: PreReleaseStrategy, + prerelease_strategy: PrereleaseStrategy, index_strategy: IndexStrategy, } @@ -39,7 +39,7 @@ impl CandidateSelector { markers, options.dependency_mode, ), - prerelease_strategy: PreReleaseStrategy::from_mode( + prerelease_strategy: PrereleaseStrategy::from_mode( options.prerelease_mode, manifest, markers, @@ -57,7 +57,7 @@ impl CandidateSelector { #[inline] #[allow(dead_code)] - pub(crate) fn prerelease_strategy(&self) -> &PreReleaseStrategy { + pub(crate) fn prerelease_strategy(&self) -> &PrereleaseStrategy { &self.prerelease_strategy } @@ -244,7 +244,7 @@ impl CandidateSelector { && self .prerelease_strategy .allows(package_name, resolver_markers) - != AllowPreRelease::Yes + != AllowPrerelease::Yes { continue; } @@ -404,10 +404,10 @@ impl CandidateSelector { versions: impl Iterator)>, package_name: &'a PackageName, range: &Range, - allow_prerelease: AllowPreRelease, + allow_prerelease: AllowPrerelease, ) -> Option> { #[derive(Debug)] - enum PreReleaseCandidate<'a> { + enum PrereleaseCandidate<'a> { NotNecessary, IfNecessary(&'a Version, &'a PrioritizedDist), } @@ -419,7 +419,7 @@ impl CandidateSelector { let candidate = if version.any_prerelease() { if range.contains(version) { match allow_prerelease { - AllowPreRelease::Yes => { + AllowPrerelease::Yes => { let Some(dist) = maybe_dist.prioritized_dist() else { continue; }; @@ -440,18 +440,18 @@ impl CandidateSelector { VersionChoiceKind::Compatible, ) } - AllowPreRelease::IfNecessary => { + AllowPrerelease::IfNecessary => { let Some(dist) = maybe_dist.prioritized_dist() else { continue; }; // If pre-releases are allowed as a fallback, store the // first-matching prerelease. if prerelease.is_none() { - prerelease = Some(PreReleaseCandidate::IfNecessary(version, dist)); + prerelease = Some(PrereleaseCandidate::IfNecessary(version, dist)); } continue; } - AllowPreRelease::No => { + AllowPrerelease::No => { continue; } } @@ -462,7 +462,7 @@ impl CandidateSelector { // If we have at least one stable release, we shouldn't allow the "if-necessary" // pre-release strategy, regardless of whether that stable release satisfies the // current range. - prerelease = Some(PreReleaseCandidate::NotNecessary); + prerelease = Some(PrereleaseCandidate::NotNecessary); // Return the first-matching stable distribution. if range.contains(version) { @@ -507,8 +507,8 @@ impl CandidateSelector { ); match prerelease { None => None, - Some(PreReleaseCandidate::NotNecessary) => None, - Some(PreReleaseCandidate::IfNecessary(version, dist)) => Some(Candidate::new( + Some(PrereleaseCandidate::NotNecessary) => None, + Some(PrereleaseCandidate::IfNecessary(version, dist)) => Some(Candidate::new( package_name, version, dist, diff --git a/crates/uv-resolver/src/lib.rs b/crates/uv-resolver/src/lib.rs index 8131804c3..934280dc4 100644 --- a/crates/uv-resolver/src/lib.rs +++ b/crates/uv-resolver/src/lib.rs @@ -7,7 +7,7 @@ pub use lock::{Lock, LockError}; pub use manifest::Manifest; pub use options::{Options, OptionsBuilder}; pub use preferences::{Preference, PreferenceError, Preferences}; -pub use prerelease_mode::PreReleaseMode; +pub use prerelease::PrereleaseMode; pub use pubgrub::{PubGrubSpecifier, PubGrubSpecifierError}; pub use python_requirement::PythonRequirement; pub use requires_python::{RequiresPython, RequiresPythonBound, RequiresPythonError}; @@ -37,7 +37,7 @@ mod marker; mod options; mod pins; mod preferences; -mod prerelease_mode; +mod prerelease; mod pubgrub; mod python_requirement; mod redirect; diff --git a/crates/uv-resolver/src/lock.rs b/crates/uv-resolver/src/lock.rs index f2e05979e..459000a3a 100644 --- a/crates/uv-resolver/src/lock.rs +++ b/crates/uv-resolver/src/lock.rs @@ -42,7 +42,7 @@ use uv_workspace::VirtualProject; use crate::resolution::{AnnotatedDist, ResolutionGraphNode}; use crate::resolver::FxOnceMap; use crate::{ - ExcludeNewer, InMemoryIndex, MetadataResponse, PreReleaseMode, RequiresPython, ResolutionGraph, + ExcludeNewer, InMemoryIndex, MetadataResponse, PrereleaseMode, RequiresPython, ResolutionGraph, ResolutionMode, VersionMap, VersionsResponse, }; @@ -61,8 +61,8 @@ pub struct Lock { requires_python: Option, /// The [`ResolutionMode`] used to generate this lock. resolution_mode: ResolutionMode, - /// The [`PreReleaseMode`] used to generate this lock. - prerelease_mode: PreReleaseMode, + /// The [`PrereleaseMode`] used to generate this lock. + prerelease_mode: PrereleaseMode, /// The [`ExcludeNewer`] used to generate this lock. exclude_newer: Option, /// The actual locked version and their metadata. @@ -180,7 +180,7 @@ impl Lock { mut distributions: Vec, requires_python: Option, resolution_mode: ResolutionMode, - prerelease_mode: PreReleaseMode, + prerelease_mode: PrereleaseMode, exclude_newer: Option, fork_markers: Option>, ) -> Result { @@ -367,7 +367,7 @@ impl Lock { } /// Returns the pre-release mode used to generate this lock. - pub fn prerelease_mode(&self) -> PreReleaseMode { + pub fn prerelease_mode(&self) -> PrereleaseMode { self.prerelease_mode } @@ -482,7 +482,7 @@ impl Lock { if self.resolution_mode != ResolutionMode::default() { doc.insert("resolution-mode", value(self.resolution_mode.to_string())); } - if self.prerelease_mode != PreReleaseMode::default() { + if self.prerelease_mode != PrereleaseMode::default() { doc.insert("prerelease-mode", value(self.prerelease_mode.to_string())); } if let Some(exclude_newer) = self.exclude_newer { @@ -604,7 +604,7 @@ struct LockWire { #[serde(default)] resolution_mode: ResolutionMode, #[serde(default)] - prerelease_mode: PreReleaseMode, + prerelease_mode: PrereleaseMode, #[serde(default)] exclude_newer: Option, #[serde(rename = "distribution", default)] diff --git a/crates/uv-resolver/src/options.rs b/crates/uv-resolver/src/options.rs index 88dd8131d..8351eaef9 100644 --- a/crates/uv-resolver/src/options.rs +++ b/crates/uv-resolver/src/options.rs @@ -1,12 +1,12 @@ use uv_configuration::IndexStrategy; -use crate::{DependencyMode, ExcludeNewer, PreReleaseMode, ResolutionMode}; +use crate::{DependencyMode, ExcludeNewer, PrereleaseMode, ResolutionMode}; /// Options for resolving a manifest. #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, serde::Deserialize)] pub struct Options { pub resolution_mode: ResolutionMode, - pub prerelease_mode: PreReleaseMode, + pub prerelease_mode: PrereleaseMode, pub dependency_mode: DependencyMode, pub exclude_newer: Option, pub index_strategy: IndexStrategy, @@ -16,7 +16,7 @@ pub struct Options { #[derive(Debug, Default, Clone)] pub struct OptionsBuilder { resolution_mode: ResolutionMode, - prerelease_mode: PreReleaseMode, + prerelease_mode: PrereleaseMode, dependency_mode: DependencyMode, exclude_newer: Option, index_strategy: IndexStrategy, @@ -35,9 +35,9 @@ impl OptionsBuilder { self } - /// Sets the [`PreReleaseMode`]. + /// Sets the [`PrereleaseMode`]. #[must_use] - pub fn prerelease_mode(mut self, prerelease_mode: PreReleaseMode) -> Self { + pub fn prerelease_mode(mut self, prerelease_mode: PrereleaseMode) -> Self { self.prerelease_mode = prerelease_mode; self } diff --git a/crates/uv-resolver/src/prerelease_mode.rs b/crates/uv-resolver/src/prerelease.rs similarity index 78% rename from crates/uv-resolver/src/prerelease_mode.rs rename to crates/uv-resolver/src/prerelease.rs index 05578d773..c5b59d539 100644 --- a/crates/uv-resolver/src/prerelease_mode.rs +++ b/crates/uv-resolver/src/prerelease.rs @@ -10,7 +10,7 @@ use crate::{DependencyMode, Manifest, ResolverMarkers}; #[serde(deny_unknown_fields, rename_all = "kebab-case")] #[cfg_attr(feature = "clap", derive(clap::ValueEnum))] #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] -pub enum PreReleaseMode { +pub enum PrereleaseMode { /// Disallow all pre-release versions. Disallow, @@ -30,7 +30,7 @@ pub enum PreReleaseMode { IfNecessaryOrExplicit, } -impl std::fmt::Display for PreReleaseMode { +impl std::fmt::Display for PrereleaseMode { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::Disallow => write!(f, "disallow"), @@ -42,10 +42,10 @@ impl std::fmt::Display for PreReleaseMode { } } -/// Like [`PreReleaseMode`], but with any additional information required to select a candidate, +/// Like [`PrereleaseMode`], but with any additional information required to select a candidate, /// like the set of direct dependencies. #[derive(Debug, Clone)] -pub(crate) enum PreReleaseStrategy { +pub(crate) enum PrereleaseStrategy { /// Disallow all pre-release versions. Disallow, @@ -64,9 +64,9 @@ pub(crate) enum PreReleaseStrategy { IfNecessaryOrExplicit(ForkSet), } -impl PreReleaseStrategy { +impl PrereleaseStrategy { pub(crate) fn from_mode( - mode: PreReleaseMode, + mode: PrereleaseMode, manifest: &Manifest, markers: Option<&MarkerEnvironment>, dependencies: DependencyMode, @@ -74,9 +74,9 @@ impl PreReleaseStrategy { let mut packages = ForkSet::default(); match mode { - PreReleaseMode::Disallow => Self::Disallow, - PreReleaseMode::Allow => Self::Allow, - PreReleaseMode::IfNecessary => Self::IfNecessary, + PrereleaseMode::Disallow => Self::Disallow, + PrereleaseMode::Allow => Self::Allow, + PrereleaseMode::IfNecessary => Self::IfNecessary, _ => { for requirement in manifest.requirements(markers, dependencies) { let RequirementSource::Registry { specifier, .. } = &requirement.source else { @@ -92,8 +92,8 @@ impl PreReleaseStrategy { } match mode { - PreReleaseMode::Explicit => Self::Explicit(packages), - PreReleaseMode::IfNecessaryOrExplicit => Self::IfNecessaryOrExplicit(packages), + PrereleaseMode::Explicit => Self::Explicit(packages), + PrereleaseMode::IfNecessaryOrExplicit => Self::IfNecessaryOrExplicit(packages), _ => unreachable!(), } } @@ -105,23 +105,23 @@ impl PreReleaseStrategy { &self, package_name: &PackageName, markers: &ResolverMarkers, - ) -> AllowPreRelease { + ) -> AllowPrerelease { match self { - PreReleaseStrategy::Disallow => AllowPreRelease::No, - PreReleaseStrategy::Allow => AllowPreRelease::Yes, - PreReleaseStrategy::IfNecessary => AllowPreRelease::IfNecessary, - PreReleaseStrategy::Explicit(packages) => { + PrereleaseStrategy::Disallow => AllowPrerelease::No, + PrereleaseStrategy::Allow => AllowPrerelease::Yes, + PrereleaseStrategy::IfNecessary => AllowPrerelease::IfNecessary, + PrereleaseStrategy::Explicit(packages) => { if packages.contains(package_name, markers) { - AllowPreRelease::Yes + AllowPrerelease::Yes } else { - AllowPreRelease::No + AllowPrerelease::No } } - PreReleaseStrategy::IfNecessaryOrExplicit(packages) => { + PrereleaseStrategy::IfNecessaryOrExplicit(packages) => { if packages.contains(package_name, markers) { - AllowPreRelease::Yes + AllowPrerelease::Yes } else { - AllowPreRelease::IfNecessary + AllowPrerelease::IfNecessary } } } @@ -130,7 +130,7 @@ impl PreReleaseStrategy { /// The pre-release strategy for a given package. #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] -pub(crate) enum AllowPreRelease { +pub(crate) enum AllowPrerelease { /// Allow all pre-release versions. Yes, diff --git a/crates/uv-resolver/src/pubgrub/report.rs b/crates/uv-resolver/src/pubgrub/report.rs index 9edd287d9..336385328 100644 --- a/crates/uv-resolver/src/pubgrub/report.rs +++ b/crates/uv-resolver/src/pubgrub/report.rs @@ -15,7 +15,7 @@ use uv_normalize::PackageName; use crate::candidate_selector::CandidateSelector; use crate::fork_urls::ForkUrls; -use crate::prerelease_mode::AllowPreRelease; +use crate::prerelease::AllowPrerelease; use crate::python_requirement::{PythonRequirement, PythonTarget}; use crate::resolver::{IncompletePackage, UnavailablePackage, UnavailableReason}; use crate::{RequiresPython, ResolverMarkers}; @@ -591,8 +591,8 @@ impl PubGrubReportFormatter<'_> { if any_prerelease { // A pre-release marker appeared in the version requirements. - if selector.prerelease_strategy().allows(name, markers) != AllowPreRelease::Yes { - hints.insert(PubGrubHint::PreReleaseRequested { + if selector.prerelease_strategy().allows(name, markers) != AllowPrerelease::Yes { + hints.insert(PubGrubHint::PrereleaseRequested { package: package.clone(), range: self.simplify_set(set, package).into_owned(), }); @@ -605,8 +605,8 @@ impl PubGrubReportFormatter<'_> { .find(|version| set.contains(version)) }) { // There are pre-release versions available for the package. - if selector.prerelease_strategy().allows(name, markers) != AllowPreRelease::Yes { - hints.insert(PubGrubHint::PreReleaseAvailable { + if selector.prerelease_strategy().allows(name, markers) != AllowPrerelease::Yes { + hints.insert(PubGrubHint::PrereleaseAvailable { package: package.clone(), version: version.clone(), }); @@ -621,14 +621,14 @@ pub(crate) enum PubGrubHint { /// There are pre-release versions available for a package, but pre-releases weren't enabled /// for that package. /// - PreReleaseAvailable { + PrereleaseAvailable { package: PubGrubPackage, #[derivative(PartialEq = "ignore", Hash = "ignore")] version: Version, }, /// A requirement included a pre-release marker, but pre-releases weren't enabled for that /// package. - PreReleaseRequested { + PrereleaseRequested { package: PubGrubPackage, #[derivative(PartialEq = "ignore", Hash = "ignore")] range: Range, @@ -698,7 +698,7 @@ pub(crate) enum PubGrubHint { impl std::fmt::Display for PubGrubHint { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - Self::PreReleaseAvailable { package, version } => { + Self::PrereleaseAvailable { package, version } => { write!( f, "{}{} Pre-releases are available for {} in the requested range (e.g., {}), but pre-releases weren't enabled (try: `--prerelease=allow`)", @@ -708,7 +708,7 @@ impl std::fmt::Display for PubGrubHint { version.bold() ) } - Self::PreReleaseRequested { package, range } => { + Self::PrereleaseRequested { package, range } => { write!( f, "{}{} {} was requested with a pre-release marker (e.g., {}), but pre-releases weren't enabled (try: `--prerelease=allow`)", diff --git a/crates/uv-resolver/src/pubgrub/specifier.rs b/crates/uv-resolver/src/pubgrub/specifier.rs index ef8f27b83..15b969802 100644 --- a/crates/uv-resolver/src/pubgrub/specifier.rs +++ b/crates/uv-resolver/src/pubgrub/specifier.rs @@ -4,7 +4,7 @@ use itertools::Itertools; use pubgrub::Range; use thiserror::Error; -use pep440_rs::{Operator, PreRelease, Version, VersionSpecifier, VersionSpecifiers}; +use pep440_rs::{Operator, Prerelease, Version, VersionSpecifier, VersionSpecifiers}; #[derive(Debug, Error)] pub enum PubGrubSpecifierError { @@ -115,7 +115,7 @@ impl PubGrubSpecifier { if let Some(post) = high.post() { high = high.with_post(Some(post + 1)); } else if let Some(pre) = high.pre() { - high = high.with_pre(Some(PreRelease { + high = high.with_pre(Some(Prerelease { kind: pre.kind, number: pre.number + 1, })); @@ -132,7 +132,7 @@ impl PubGrubSpecifier { if let Some(post) = high.post() { high = high.with_post(Some(post + 1)); } else if let Some(pre) = high.pre() { - high = high.with_pre(Some(PreRelease { + high = high.with_pre(Some(Prerelease { kind: pre.kind, number: pre.number + 1, })); diff --git a/crates/uv-settings/src/combine.rs b/crates/uv-settings/src/combine.rs index 0b337ecce..70ba2f9a6 100644 --- a/crates/uv-settings/src/combine.rs +++ b/crates/uv-settings/src/combine.rs @@ -5,7 +5,7 @@ use distribution_types::IndexUrl; use install_wheel_rs::linker::LinkMode; use uv_configuration::{ConfigSettings, IndexStrategy, KeyringProviderType, TargetTriple}; use uv_python::{PythonFetch, PythonPreference, PythonVersion}; -use uv_resolver::{AnnotationStyle, ExcludeNewer, PreReleaseMode, ResolutionMode}; +use uv_resolver::{AnnotationStyle, ExcludeNewer, PrereleaseMode, ResolutionMode}; use crate::{FilesystemOptions, PipOptions}; @@ -64,7 +64,7 @@ impl_combine_or!(KeyringProviderType); impl_combine_or!(LinkMode); impl_combine_or!(NonZeroUsize); impl_combine_or!(PathBuf); -impl_combine_or!(PreReleaseMode); +impl_combine_or!(PrereleaseMode); impl_combine_or!(PythonVersion); impl_combine_or!(ResolutionMode); impl_combine_or!(String); diff --git a/crates/uv-settings/src/settings.rs b/crates/uv-settings/src/settings.rs index 18e07da19..b8671faf7 100644 --- a/crates/uv-settings/src/settings.rs +++ b/crates/uv-settings/src/settings.rs @@ -12,7 +12,7 @@ use uv_configuration::{ use uv_macros::{CombineOptions, OptionsMetadata}; use uv_normalize::{ExtraName, PackageName}; use uv_python::{PythonFetch, PythonPreference, PythonVersion}; -use uv_resolver::{AnnotationStyle, ExcludeNewer, PreReleaseMode, ResolutionMode}; +use uv_resolver::{AnnotationStyle, ExcludeNewer, PrereleaseMode, ResolutionMode}; /// A `pyproject.toml` with an (optional) `[tool.uv]` section. #[allow(dead_code)] @@ -174,7 +174,7 @@ pub struct ResolverOptions { pub index_strategy: Option, pub keyring_provider: Option, pub resolution: Option, - pub prerelease: Option, + pub prerelease: Option, pub config_settings: Option, pub exclude_newer: Option, pub link_mode: Option, @@ -305,7 +305,7 @@ pub struct ResolverInstallerOptions { "#, possible_values = true )] - pub prerelease: Option, + pub prerelease: Option, /// Settings to pass to the [PEP 517](https://peps.python.org/pep-0517/) build backend, /// specified as `KEY=VALUE` pairs. #[option( @@ -750,7 +750,7 @@ pub struct PipOptions { "#, possible_values = true )] - pub prerelease: Option, + pub prerelease: Option, /// Write the requirements generated by `uv pip compile` to the given `requirements.txt` file. /// /// If the file already exists, the existing versions will be preferred when resolving diff --git a/crates/uv/src/commands/pip/compile.rs b/crates/uv/src/commands/pip/compile.rs index 08f8688af..32d14d4ad 100644 --- a/crates/uv/src/commands/pip/compile.rs +++ b/crates/uv/src/commands/pip/compile.rs @@ -32,7 +32,7 @@ use uv_requirements::{ }; use uv_resolver::{ AnnotationStyle, DependencyMode, DisplayResolutionGraph, ExcludeNewer, FlatIndex, - InMemoryIndex, OptionsBuilder, PreReleaseMode, PythonRequirement, RequiresPython, + InMemoryIndex, OptionsBuilder, PrereleaseMode, PythonRequirement, RequiresPython, ResolutionMode, ResolverMarkers, }; use uv_types::{BuildIsolation, EmptyInstalledPackages, HashStrategy, InFlight}; @@ -53,7 +53,7 @@ pub(crate) async fn pip_compile( extras: ExtrasSpecification, output_file: Option<&Path>, resolution_mode: ResolutionMode, - prerelease_mode: PreReleaseMode, + prerelease_mode: PrereleaseMode, dependency_mode: DependencyMode, upgrade: Upgrade, generate_hashes: bool, diff --git a/crates/uv/src/commands/pip/install.rs b/crates/uv/src/commands/pip/install.rs index d25c4f7cd..0a9faed6f 100644 --- a/crates/uv/src/commands/pip/install.rs +++ b/crates/uv/src/commands/pip/install.rs @@ -24,7 +24,7 @@ use uv_python::{ }; use uv_requirements::{RequirementsSource, RequirementsSpecification}; use uv_resolver::{ - DependencyMode, ExcludeNewer, FlatIndex, OptionsBuilder, PreReleaseMode, PythonRequirement, + DependencyMode, ExcludeNewer, FlatIndex, OptionsBuilder, PrereleaseMode, PythonRequirement, ResolutionMode, ResolverMarkers, }; use uv_types::{BuildIsolation, HashStrategy}; @@ -44,7 +44,7 @@ pub(crate) async fn pip_install( overrides_from_workspace: Vec, extras: &ExtrasSpecification, resolution_mode: ResolutionMode, - prerelease_mode: PreReleaseMode, + prerelease_mode: PrereleaseMode, dependency_mode: DependencyMode, upgrade: Upgrade, index_locations: IndexLocations, diff --git a/crates/uv/src/commands/pip/sync.rs b/crates/uv/src/commands/pip/sync.rs index aa71e37c9..e16729bb1 100644 --- a/crates/uv/src/commands/pip/sync.rs +++ b/crates/uv/src/commands/pip/sync.rs @@ -23,7 +23,7 @@ use uv_python::{ }; use uv_requirements::{RequirementsSource, RequirementsSpecification}; use uv_resolver::{ - DependencyMode, ExcludeNewer, FlatIndex, OptionsBuilder, PreReleaseMode, PythonRequirement, + DependencyMode, ExcludeNewer, FlatIndex, OptionsBuilder, PrereleaseMode, PythonRequirement, ResolutionMode, ResolverMarkers, }; use uv_types::{BuildIsolation, HashStrategy}; @@ -77,7 +77,7 @@ pub(crate) async fn pip_sync( let extras = ExtrasSpecification::default(); let upgrade = Upgrade::default(); let resolution_mode = ResolutionMode::default(); - let prerelease_mode = PreReleaseMode::default(); + let prerelease_mode = PrereleaseMode::default(); let dependency_mode = DependencyMode::Direct; // Read all requirements from the provided sources. diff --git a/crates/uv/src/commands/project/lock.rs b/crates/uv/src/commands/project/lock.rs index f06d3f15a..3a423a4d6 100644 --- a/crates/uv/src/commands/project/lock.rs +++ b/crates/uv/src/commands/project/lock.rs @@ -312,7 +312,7 @@ async fn do_lock( if lock.prerelease_mode() != options.prerelease_mode { let _ = writeln!( printer.stderr(), - "Ignoring existing lockfile due to change in prerelease mode: `{}` vs. `{}`", + "Ignoring existing lockfile due to change in pre-release mode: `{}` vs. `{}`", lock.prerelease_mode().cyan(), options.prerelease_mode.cyan() ); diff --git a/crates/uv/src/settings.rs b/crates/uv/src/settings.rs index 762ac215e..168c2dc6b 100644 --- a/crates/uv/src/settings.rs +++ b/crates/uv/src/settings.rs @@ -26,7 +26,7 @@ use uv_configuration::{ use uv_normalize::PackageName; use uv_python::{Prefix, PythonFetch, PythonPreference, PythonVersion, Target}; use uv_requirements::RequirementsSource; -use uv_resolver::{AnnotationStyle, DependencyMode, ExcludeNewer, PreReleaseMode, ResolutionMode}; +use uv_resolver::{AnnotationStyle, DependencyMode, ExcludeNewer, PrereleaseMode, ResolutionMode}; use uv_settings::{ Combine, FilesystemOptions, Options, PipOptions, ResolverInstallerOptions, ResolverOptions, }; @@ -1499,7 +1499,7 @@ pub(crate) struct ResolverSettings { pub(crate) index_strategy: IndexStrategy, pub(crate) keyring_provider: KeyringProviderType, pub(crate) resolution: ResolutionMode, - pub(crate) prerelease: PreReleaseMode, + pub(crate) prerelease: PrereleaseMode, pub(crate) config_setting: ConfigSettings, pub(crate) exclude_newer: Option, pub(crate) link_mode: LinkMode, @@ -1513,7 +1513,7 @@ pub(crate) struct ResolverSettingsRef<'a> { pub(crate) index_strategy: IndexStrategy, pub(crate) keyring_provider: KeyringProviderType, pub(crate) resolution: ResolutionMode, - pub(crate) prerelease: PreReleaseMode, + pub(crate) prerelease: PrereleaseMode, pub(crate) config_setting: &'a ConfigSettings, pub(crate) exclude_newer: Option, pub(crate) link_mode: LinkMode, @@ -1629,7 +1629,7 @@ pub(crate) struct ResolverInstallerSettings { pub(crate) index_strategy: IndexStrategy, pub(crate) keyring_provider: KeyringProviderType, pub(crate) resolution: ResolutionMode, - pub(crate) prerelease: PreReleaseMode, + pub(crate) prerelease: PrereleaseMode, pub(crate) config_setting: ConfigSettings, pub(crate) exclude_newer: Option, pub(crate) link_mode: LinkMode, @@ -1645,7 +1645,7 @@ pub(crate) struct ResolverInstallerSettingsRef<'a> { pub(crate) index_strategy: IndexStrategy, pub(crate) keyring_provider: KeyringProviderType, pub(crate) resolution: ResolutionMode, - pub(crate) prerelease: PreReleaseMode, + pub(crate) prerelease: PrereleaseMode, pub(crate) config_setting: &'a ConfigSettings, pub(crate) exclude_newer: Option, pub(crate) link_mode: LinkMode, @@ -1788,7 +1788,7 @@ pub(crate) struct PipSettings { pub(crate) strict: bool, pub(crate) dependency_mode: DependencyMode, pub(crate) resolution: ResolutionMode, - pub(crate) prerelease: PreReleaseMode, + pub(crate) prerelease: PrereleaseMode, pub(crate) output_file: Option, pub(crate) no_strip_extras: bool, pub(crate) no_strip_markers: bool, diff --git a/crates/uv/tests/pip_compile.rs b/crates/uv/tests/pip_compile.rs index 3baab4ae5..8e04ccf77 100644 --- a/crates/uv/tests/pip_compile.rs +++ b/crates/uv/tests/pip_compile.rs @@ -7523,7 +7523,7 @@ fn universal_nested_disjoint_local_requirement() -> Result<()> { Ok(()) } -// Requested distinct prerelease strategies with disjoint markers. +/// Requested distinct pre-release strategies with disjoint markers. #[test] fn universal_disjoint_prereleases() -> Result<()> { static EXCLUDE_NEWER: &str = "2024-07-17T00:00:00Z"; @@ -7559,8 +7559,8 @@ fn universal_disjoint_prereleases() -> Result<()> { Ok(()) } -// Requested distinct prerelease strategies with disjoint markers for a package -// that is also present as a transitive dependency. +/// Requested distinct pre-release strategies with disjoint markers for a package +/// that is also present as a transitive dependency. #[test] fn universal_transitive_disjoint_prerelease_requirement() -> Result<()> { static EXCLUDE_NEWER: &str = "2024-07-17T00:00:00Z"; @@ -7603,7 +7603,7 @@ fn universal_transitive_disjoint_prerelease_requirement() -> Result<()> { Ok(()) } -// Ensure that the global prerelease mode is respected across forks. +/// Ensure that the global pre-release mode is respected across forks. #[test] fn universal_prerelease_mode() -> Result<()> { static EXCLUDE_NEWER: &str = "2024-07-17T00:00:00Z"; @@ -7638,8 +7638,8 @@ fn universal_prerelease_mode() -> Result<()> { Ok(()) } -/// If a dependency requests a prerelease version with an overlapping marker expression, -/// we should prefer the prerelease version in both forks. +/// If a dependency requests a pre-release version with an overlapping marker expression, +/// we should prefer the pre-release version in both forks. #[test] fn universal_overlapping_prerelease_requirement() -> Result<()> { static EXCLUDE_NEWER: &str = "2024-07-17T00:00:00Z"; @@ -7689,7 +7689,7 @@ fn universal_overlapping_prerelease_requirement() -> Result<()> { Ok(()) } -/// If a dependency requests distinct prerelease strategies with disjoint marker expressions, +/// If a dependency requests distinct pre-release strategies with disjoint marker expressions, /// we should fork the root requirement. #[test] fn universal_disjoint_prerelease_requirement() -> Result<()> { @@ -7716,7 +7716,7 @@ fn universal_disjoint_prerelease_requirement() -> Result<()> { "})?; // Some marker expressions on the output here are missing due to https://github.com/astral-sh/uv/issues/5086, - // but the prerelease versions are still respected correctly. + // but the pre-release versions are still respected correctly. uv_snapshot!(context.filters(), windows_filters=false, context.pip_compile() .env("UV_EXCLUDE_NEWER", EXCLUDE_NEWER) .arg("requirements.in") @@ -8418,7 +8418,7 @@ fn unsafe_package() -> Result<()> { /// Resolve a package with a strict upper bound, allowing pre-releases. Per PEP 440, pre-releases /// that match the bound (e.g., `2.0.0rc1`) should be _not_ allowed. #[test] -fn pre_release_upper_bound_exclude() -> Result<()> { +fn prerelease_upper_bound_exclude() -> Result<()> { let context = TestContext::new("3.12"); let requirements_in = context.temp_dir.child("requirements.in"); requirements_in.write_str("flask<2.0.0")?; @@ -8455,7 +8455,7 @@ fn pre_release_upper_bound_exclude() -> Result<()> { /// Resolve a package with a strict upper bound that includes a pre-release. Per PEP 440, /// pre-releases _should_ be allowed. #[test] -fn pre_release_upper_bound_include() -> Result<()> { +fn prerelease_upper_bound_include() -> Result<()> { let context = TestContext::new("3.12"); let requirements_in = context.temp_dir.child("requirements.in"); requirements_in.write_str("flask<2.0.0rc4")?; @@ -8529,7 +8529,7 @@ fn pre_alias() -> Result<()> { /// Allow a pre-release for a version specifier in a constraint file. #[test] -fn pre_release_constraint() -> Result<()> { +fn prerelease_constraint() -> Result<()> { let context = TestContext::new("3.12"); let requirements_in = context.temp_dir.child("requirements.in"); requirements_in.write_str("flask")?; @@ -10349,7 +10349,7 @@ requires-python = ">3.8" /// Allow pre-releases for dependencies of source path requirements. #[test] -fn pre_release_path_requirement() -> Result<()> { +fn prerelease_path_requirement() -> Result<()> { let context = TestContext::new("3.12"); // Create an a package that requires a pre-release version of `flask`. @@ -10403,7 +10403,7 @@ requires-python = ">3.8" /// Allow pre-releases for dependencies of editable requirements. #[test] -fn pre_release_editable_requirement() -> Result<()> { +fn prerelease_editable_requirement() -> Result<()> { let context = TestContext::new("3.12"); // Create an a package that requires a pre-release version of `flask`.r diff --git a/uv.schema.json b/uv.schema.json index c69e9e0ba..0d48ad530 100644 --- a/uv.schema.json +++ b/uv.schema.json @@ -216,7 +216,7 @@ "description": "The strategy to use when considering pre-release versions.\n\nBy default, uv will accept pre-releases for packages that _only_ publish pre-releases, along with first-party requirements that contain an explicit pre-release marker in the declared specifiers (`if-necessary-or-explicit`).", "anyOf": [ { - "$ref": "#/definitions/PreReleaseMode" + "$ref": "#/definitions/PrereleaseMode" }, { "type": "null" @@ -808,7 +808,7 @@ "description": "The strategy to use when considering pre-release versions.\n\nBy default, uv will accept pre-releases for packages that _only_ publish pre-releases, along with first-party requirements that contain an explicit pre-release marker in the declared specifiers (`if-necessary-or-explicit`).", "anyOf": [ { - "$ref": "#/definitions/PreReleaseMode" + "$ref": "#/definitions/PrereleaseMode" }, { "type": "null" @@ -934,7 +934,7 @@ }, "additionalProperties": false }, - "PreReleaseMode": { + "PrereleaseMode": { "oneOf": [ { "description": "Disallow all pre-release versions.",