aboutsummaryrefslogtreecommitdiffhomepage
path: root/crates/mozart-constraint/src
diff options
context:
space:
mode:
Diffstat (limited to 'crates/mozart-constraint/src')
-rw-r--r--crates/mozart-constraint/src/lib.rs1987
1 files changed, 0 insertions, 1987 deletions
diff --git a/crates/mozart-constraint/src/lib.rs b/crates/mozart-constraint/src/lib.rs
deleted file mode 100644
index 7c417ec..0000000
--- a/crates/mozart-constraint/src/lib.rs
+++ /dev/null
@@ -1,1987 +0,0 @@
-use std::cmp::Ordering;
-
-/// A parsed Composer version (always 4 numeric segments + optional stability suffix).
-/// Composer normalizes all versions to `major.minor.patch.build[-stability[N]]`.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Version {
- pub major: u64,
- pub minor: u64,
- pub patch: u64,
- pub build: u64,
- /// None = stable, Some("alpha1"), Some("beta2"), Some("RC1"), Some("dev")
- pub pre_release: Option<String>,
- /// true for "dev-master", "dev-feature/foo", etc.
- pub is_dev_branch: bool,
- /// The original branch name for dev branches (e.g. "master", "feature/foo")
- pub dev_branch_name: Option<String>,
-}
-
-/// Stability rank for ordering (lower = more stable).
-fn stability_rank(pre: &str) -> u8 {
- let lower = pre.to_lowercase();
- if lower.starts_with("dev") {
- 50
- } else if lower.starts_with("alpha") || lower.starts_with("a") {
- 40
- } else if lower.starts_with("beta") || lower.starts_with("b") {
- 30
- } else if lower.starts_with("rc") {
- 20
- } else if lower.starts_with("patch") || lower.starts_with("pl") || lower == "p" {
- 5
- } else {
- 0
- }
-}
-
-/// Extract numeric suffix from a pre-release string like "alpha1" → 1, "beta" → 0
-fn pre_release_number(pre: &str) -> u64 {
- let digits: String = pre.chars().skip_while(|c| c.is_alphabetic()).collect();
- digits.parse().unwrap_or(0)
-}
-
-impl PartialOrd for Version {
- fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
- Some(self.cmp(other))
- }
-}
-
-impl Ord for Version {
- fn cmp(&self, other: &Self) -> Ordering {
- // Dev branches are always lowest
- match (self.is_dev_branch, other.is_dev_branch) {
- (true, true) => {
- // Compare branch names
- return self.dev_branch_name.cmp(&other.dev_branch_name);
- }
- (true, false) => return Ordering::Less,
- (false, true) => return Ordering::Greater,
- (false, false) => {}
- }
-
- // Compare numeric segments
- let num_cmp = (self.major, self.minor, self.patch, self.build).cmp(&(
- other.major,
- other.minor,
- other.patch,
- other.build,
- ));
- if num_cmp != Ordering::Equal {
- return num_cmp;
- }
-
- // Compare pre-release: None (stable) > any pre-release
- match (&self.pre_release, &other.pre_release) {
- (None, None) => Ordering::Equal,
- (None, Some(_)) => Ordering::Greater,
- (Some(_), None) => Ordering::Less,
- (Some(a), Some(b)) => {
- let rank_a = stability_rank(a);
- let rank_b = stability_rank(b);
- match rank_a.cmp(&rank_b) {
- Ordering::Equal => {
- // Same stability: compare numeric suffix
- pre_release_number(a).cmp(&pre_release_number(b))
- }
- // Lower rank = more stable = greater version
- Ordering::Less => Ordering::Greater,
- Ordering::Greater => Ordering::Less,
- }
- }
- }
- }
-}
-
-impl Version {
- /// Parse a version string into a `Version` struct using Composer normalization rules.
- ///
- /// For inline aliases (`"1.0.x-dev as 1.0.0"`), the LEFT side (the real branch version)
- /// is used. This is the correct behaviour for identifying *what* version a package provides.
- pub fn parse(input: &str) -> Result<Version, String> {
- let s = input.trim();
-
- // Strip inline alias: "1.0.x-dev as 1.0.0" → "1.0.x-dev"
- let s = if let Some(pos) = s.find(" as ") {
- &s[..pos]
- } else {
- s
- };
-
- // Strip stability flag: "@dev", "@alpha", "@beta", "@RC", "@stable"
- let s = if let Some(pos) = s.rfind('@') {
- let after = &s[pos + 1..];
- let known = ["dev", "alpha", "beta", "rc", "stable"];
- if known.iter().any(|k| after.eq_ignore_ascii_case(k)) {
- &s[..pos]
- } else {
- s
- }
- } else {
- s
- };
-
- // Handle dev-* prefix branches
- if s.to_lowercase().starts_with("dev-") {
- let branch = &s[4..];
- return Ok(Version {
- major: 0,
- minor: 0,
- patch: 0,
- build: 0,
- pre_release: Some("dev".to_string()),
- is_dev_branch: true,
- dev_branch_name: Some(branch.to_string()),
- });
- }
-
- // Handle *-dev suffix (e.g., "2.1.x-dev" or "2.x-dev")
- let s_lower = s.to_lowercase();
- if s_lower.ends_with("-dev") || s_lower.ends_with(".x-dev") {
- let base = if s_lower.ends_with("-dev") {
- &s[..s.len() - 4]
- } else {
- s
- };
- // Replace any trailing .x with nothing, parse numeric parts
- let base = base.trim_end_matches(".x").trim_end_matches("-dev");
- let parts: Vec<&str> = base.split('.').collect();
- let major = parts.first().and_then(|p| p.parse().ok()).unwrap_or(0);
- let minor = parts.get(1).and_then(|p| p.parse().ok()).unwrap_or(0);
- return Ok(Version {
- major,
- minor,
- patch: 9999999,
- build: 9999999,
- pre_release: Some("dev".to_string()),
- is_dev_branch: true,
- dev_branch_name: None,
- });
- }
-
- // Strip leading v/V
- let s = s
- .strip_prefix('v')
- .or_else(|| s.strip_prefix('V'))
- .unwrap_or(s);
-
- // Strip build metadata after +
- let s = s.split('+').next().unwrap_or(s);
-
- // Parse the version using regex-like approach
- parse_classical_version(s)
- }
-
- /// Parse a version string for use inside a *constraint expression*.
- ///
- /// The difference from [`Version::parse`] is the treatment of inline aliases:
- /// `"1.0.x-dev as 1.0.0"` → takes the **right** side (`1.0.0`).
- ///
- /// Inline aliases appear in `require` fields like:
- /// ```text
- /// "some/package": "1.0.x-dev as 1.0.0"
- /// ```
- /// Here the author wants the constraint to be satisfied by the real version `1.0.0`,
- /// while the left side (`1.0.x-dev`) indicates the branch that provides it.
- pub fn parse_for_constraint(input: &str) -> Result<Version, String> {
- let s = input.trim();
- // For inline aliases, take the RIGHT side (alias target)
- let s = if let Some(pos) = s.find(" as ") {
- s[pos + 4..].trim()
- } else {
- s
- };
- Version::parse(s)
- }
-
- /// Create a "dev boundary" version for constraint matching (major.minor.patch.build with dev pre-release).
- pub fn dev_boundary(major: u64, minor: u64, patch: u64, build: u64) -> Version {
- Version {
- major,
- minor,
- patch,
- build,
- pre_release: Some("dev".to_string()),
- is_dev_branch: false,
- dev_branch_name: None,
- }
- }
-}
-
-fn parse_classical_version(s: &str) -> Result<Version, String> {
- // Split on '-' to separate version from pre-release
- let (version_part, pre_part) = if let Some(pos) = s.find('-') {
- (&s[..pos], Some(&s[pos + 1..]))
- } else {
- (s, None)
- };
-
- let segments: Vec<&str> = version_part.split('.').collect();
- if segments.is_empty() || segments[0].is_empty() {
- return Err(format!("Invalid version: {s}"));
- }
-
- let major: u64 = segments[0]
- .parse()
- .map_err(|_| format!("Invalid major version segment: {}", segments[0]))?;
- let minor: u64 = segments.get(1).and_then(|p| p.parse().ok()).unwrap_or(0);
- let patch: u64 = segments
- .get(2)
- .and_then(|p| {
- // strip trailing .x
- let p = p.trim_end_matches('x').trim_end_matches('.');
- if p.is_empty() {
- Some(0)
- } else {
- p.parse().ok()
- }
- })
- .unwrap_or(0);
- let build: u64 = segments.get(3).and_then(|p| p.parse().ok()).unwrap_or(0);
-
- let pre_release = pre_part.map(normalize_pre_release);
-
- Ok(Version {
- major,
- minor,
- patch,
- build,
- pre_release,
- is_dev_branch: false,
- dev_branch_name: None,
- })
-}
-
-fn normalize_pre_release(s: &str) -> String {
- // Normalize aliases: b→beta, a→alpha, rc→RC, p/pl/patch→patch
- let lower = s.to_lowercase();
- // Strip leading non-alpha characters (dots, underscores, dashes used as separators)
- let normalized = lower
- .trim_start_matches(|c: char| !c.is_alphabetic())
- .to_string();
-
- // Extract the alphabetic prefix (stability name)
- let alpha: String = normalized
- .chars()
- .take_while(|c| c.is_alphabetic())
- .collect();
- // Extract only digits from the rest (strip separators like dots)
- let num: String = normalized
- .chars()
- .skip_while(|c| c.is_alphabetic())
- .filter(|c| c.is_ascii_digit())
- .collect();
-
- if alpha.starts_with("beta") || alpha == "b" {
- format!("beta{num}")
- } else if alpha.starts_with("alpha") || alpha == "a" {
- format!("alpha{num}")
- } else if alpha == "rc" {
- format!("RC{num}")
- } else if alpha == "patch" || alpha == "pl" || alpha == "p" {
- format!("patch{num}")
- } else if alpha == "dev" {
- "dev".to_string()
- } else {
- s.to_string()
- }
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Constraint types
-// ─────────────────────────────────────────────────────────────────────────────
-
-/// A single atomic constraint.
-#[derive(Debug, Clone)]
-pub enum Constraint {
- /// Exact version match
- Exact(Version),
- /// Greater than: `> 1.2.3`
- GreaterThan(Version),
- /// Greater than or equal: `>= 1.2.3`
- GreaterThanOrEqual(Version),
- /// Less than: `< 1.2.3`
- LessThan(Version),
- /// Less than or equal: `<= 1.2.3`
- LessThanOrEqual(Version),
- /// Not equal: `!= 1.2.3`
- NotEqual(Version),
- /// Matches any version
- Any,
-}
-
-impl Constraint {
- pub fn matches(&self, v: &Version) -> bool {
- match self {
- Constraint::Exact(target) => v == target,
- Constraint::GreaterThan(target) => v > target,
- Constraint::GreaterThanOrEqual(target) => v >= target,
- Constraint::LessThan(target) => v < target,
- Constraint::LessThanOrEqual(target) => v <= target,
- Constraint::NotEqual(target) => v != target,
- Constraint::Any => true,
- }
- }
-}
-
-/// A compound constraint with AND/OR combinators.
-#[derive(Debug, Clone)]
-pub enum VersionConstraint {
- /// Single atomic constraint
- Single(Constraint),
- /// All must match (AND — space/comma separated)
- And(Vec<VersionConstraint>),
- /// At least one must match (OR — `||` separated)
- Or(Vec<VersionConstraint>),
-}
-
-impl VersionConstraint {
- pub fn matches(&self, version: &Version) -> bool {
- match self {
- VersionConstraint::Single(c) => c.matches(version),
- VersionConstraint::And(cs) => cs.iter().all(|c| c.matches(version)),
- VersionConstraint::Or(cs) => cs.iter().any(|c| c.matches(version)),
- }
- }
-
- /// Parse a constraint string like `^1.2`, `>=1.0 <2.0`, `^1.0 || ^2.0`.
- pub fn parse(input: &str) -> Result<VersionConstraint, String> {
- let input = input.trim();
-
- // Split on || (OR)
- let or_parts: Vec<&str> = split_or(input);
-
- if or_parts.len() > 1 {
- let constraints: Result<Vec<_>, _> =
- or_parts.iter().map(|p| parse_and_group(p.trim())).collect();
- let mut cs = constraints?;
- // Flatten single-element groups
- if cs.len() == 1 {
- return Ok(cs.remove(0));
- }
- return Ok(VersionConstraint::Or(cs));
- }
-
- parse_and_group(input)
- }
-}
-
-/// Split on `|` or `||` (pipe-OR). Composer accepts both forms.
-fn split_or(s: &str) -> Vec<&str> {
- let mut parts = Vec::new();
- let mut start = 0;
- let bytes = s.as_bytes();
- let mut i = 0;
- while i < bytes.len() {
- if bytes[i] == b'|' {
- parts.push(s[start..i].trim());
- i += 1;
- // Skip second pipe if `||`
- if i < bytes.len() && bytes[i] == b'|' {
- i += 1;
- }
- start = i;
- } else {
- i += 1;
- }
- }
- parts.push(s[start..].trim());
- // Filter out empty parts (e.g. from leading/trailing pipes)
- parts.into_iter().filter(|p| !p.is_empty()).collect()
-}
-
-/// Parse an AND group (space or comma separated constraints).
-fn parse_and_group(s: &str) -> Result<VersionConstraint, String> {
- // Detect inline alias first: "1.0.x-dev as 1.0.0"
- // The entire expression is a single atomic constraint; parse it directly.
- if s.contains(" as ") {
- return parse_single(s);
- }
-
- // Detect hyphen range first: "1.0 - 2.0" where both sides start with a digit
- if let Some(idx) = s.find(" - ") {
- let before = s[..idx].trim();
- let after = s[idx + 3..].trim();
- let before_is_version = before
- .chars()
- .next()
- .is_some_and(|c| c.is_ascii_digit() || c == 'v' || c == 'V');
- let after_is_version = after
- .chars()
- .next()
- .is_some_and(|c| c.is_ascii_digit() || c == 'v' || c == 'V');
- if before_is_version && after_is_version {
- return parse_hyphen_range(s);
- }
- }
-
- let parts = split_and(s);
-
- if parts.is_empty() {
- return Err("Empty constraint".to_string());
- }
-
- let constraints: Result<Vec<_>, _> = parts.iter().map(|p| parse_single(p.trim())).collect();
- let mut cs = constraints?;
-
- if cs.len() == 1 {
- return Ok(cs.remove(0));
- }
-
- // Flatten nested And
- let flat: Vec<VersionConstraint> = cs
- .into_iter()
- .flat_map(|c| match c {
- VersionConstraint::And(inner) => inner,
- other => vec![other],
- })
- .collect();
-
- Ok(VersionConstraint::And(flat))
-}
-
-/// Split on spaces or commas (AND separator), respecting that version strings
-/// can contain `-` (pre-release).
-fn split_and(s: &str) -> Vec<String> {
- // A constraint "part" is separated by space or comma when not part of
- // operator prefixes like `>=`, `<=`, `!=`, or version like `1.2.3-beta`.
- // Strategy: tokenize by whitespace/comma, then re-join multi-token ranges.
- let tokens: Vec<&str> = s.split([' ', ',']).filter(|t| !t.is_empty()).collect();
-
- let mut parts: Vec<String> = Vec::new();
- let mut current = String::new();
-
- for token in tokens {
- if current.is_empty() {
- current = token.to_string();
- } else {
- // If the token starts with an operator or a digit/^ ~/>, it's a new constraint
- let starts_new = token.starts_with(|c: char| {
- matches!(c, '>' | '<' | '!' | '=' | '^' | '~' | '*') || c.is_ascii_digit()
- });
- if starts_new {
- parts.push(current.trim().to_string());
- current = token.to_string();
- } else {
- // Continuation (e.g. part of a version string with spaces)
- current.push(' ');
- current.push_str(token);
- }
- }
- }
- if !current.is_empty() {
- parts.push(current.trim().to_string());
- }
-
- parts
-}
-
-/// Parse a single constraint part.
-fn parse_single(s: &str) -> Result<VersionConstraint, String> {
- if s == "*" || s.is_empty() {
- return Ok(VersionConstraint::Single(Constraint::Any));
- }
-
- // Caret: ^1.2.3
- if let Some(rest) = s.strip_prefix('^') {
- return parse_caret(rest);
- }
-
- // Tilde: ~1.2.3
- if let Some(rest) = s.strip_prefix('~') {
- return parse_tilde(rest);
- }
-
- // Hyphen range: "1.0 - 2.0" — handled at and-group level, but check here too
- if s.contains(" - ") {
- return parse_hyphen_range(s);
- }
-
- // Comparison operators
- // Use parse_for_constraint so that inline aliases like "1.0.x-dev as 1.0.0"
- // resolve to the alias target (right-hand side) when used in constraint context.
- if let Some(rest) = s.strip_prefix(">=") {
- let v = Version::parse_for_constraint(rest.trim())?;
- return Ok(VersionConstraint::Single(Constraint::GreaterThanOrEqual(v)));
- }
- if let Some(rest) = s.strip_prefix("<=") {
- let v = Version::parse_for_constraint(rest.trim())?;
- return Ok(VersionConstraint::Single(Constraint::LessThanOrEqual(v)));
- }
- if let Some(rest) = s.strip_prefix("!=") {
- let v = Version::parse_for_constraint(rest.trim())?;
- return Ok(VersionConstraint::Single(Constraint::NotEqual(v)));
- }
- if let Some(rest) = s.strip_prefix('>') {
- let v = Version::parse_for_constraint(rest.trim())?;
- return Ok(VersionConstraint::Single(Constraint::GreaterThan(v)));
- }
- if let Some(rest) = s.strip_prefix('<') {
- let v = Version::parse_for_constraint(rest.trim())?;
- return Ok(VersionConstraint::Single(Constraint::LessThan(v)));
- }
- if let Some(rest) = s.strip_prefix('=') {
- let v = Version::parse_for_constraint(rest.trim())?;
- return Ok(VersionConstraint::Single(Constraint::Exact(v)));
- }
-
- // Wildcard: 1.2.* or 1.*
- if s.ends_with(".*") || s.ends_with(".*.*") || s == "*" {
- return parse_wildcard(s);
- }
-
- // Exact version (may carry an inline alias; take the alias target for matching)
- let v = Version::parse_for_constraint(s)?;
- Ok(VersionConstraint::Single(Constraint::Exact(v)))
-}
-
-/// Parse `^major.minor.patch` caret constraint.
-/// First non-zero segment is the "locked" boundary.
-fn parse_caret(s: &str) -> Result<VersionConstraint, String> {
- let parts: Vec<&str> = s.split('.').collect();
- let major: u64 = parts.first().and_then(|p| p.parse().ok()).unwrap_or(0);
- let minor: u64 = parts.get(1).and_then(|p| p.parse().ok()).unwrap_or(0);
- let patch: u64 = parts.get(2).and_then(|p| p.parse().ok()).unwrap_or(0);
- let build: u64 = parts.get(3).and_then(|p| p.parse().ok()).unwrap_or(0);
-
- let lower = Version::dev_boundary(major, minor, patch, build);
-
- // Determine upper bound based on first non-zero segment
- let upper = if major > 0 {
- Version::dev_boundary(major + 1, 0, 0, 0)
- } else if minor > 0 {
- Version::dev_boundary(0, minor + 1, 0, 0)
- } else if patch > 0 {
- Version::dev_boundary(0, 0, patch + 1, 0)
- } else {
- Version::dev_boundary(0, 0, 1, 0)
- };
-
- Ok(VersionConstraint::And(vec![
- VersionConstraint::Single(Constraint::GreaterThanOrEqual(lower)),
- VersionConstraint::Single(Constraint::LessThan(upper)),
- ]))
-}
-
-/// Parse `~major.minor.patch` tilde constraint.
-fn parse_tilde(s: &str) -> Result<VersionConstraint, String> {
- let parts: Vec<&str> = s.split('.').collect();
- let major: u64 = parts.first().and_then(|p| p.parse().ok()).unwrap_or(0);
- let minor: u64 = parts.get(1).and_then(|p| p.parse().ok()).unwrap_or(0);
- let patch: u64 = parts.get(2).and_then(|p| p.parse().ok()).unwrap_or(0);
- let build: u64 = parts.get(3).and_then(|p| p.parse().ok()).unwrap_or(0);
-
- let lower = Version::dev_boundary(major, minor, patch, build);
-
- // ~major.minor.patch → >=major.minor.patch <major.(minor+1).0
- // ~major.minor → >=major.minor.0 <(major+1).0.0
- // ~major → >=major.0.0 <(major+1).0.0
- let upper = if parts.len() >= 3 {
- Version::dev_boundary(major, minor + 1, 0, 0)
- } else {
- Version::dev_boundary(major + 1, 0, 0, 0)
- };
-
- Ok(VersionConstraint::And(vec![
- VersionConstraint::Single(Constraint::GreaterThanOrEqual(lower)),
- VersionConstraint::Single(Constraint::LessThan(upper)),
- ]))
-}
-
-/// Parse `1.2.*` wildcard constraint.
-fn parse_wildcard(s: &str) -> Result<VersionConstraint, String> {
- if s == "*" {
- return Ok(VersionConstraint::Single(Constraint::Any));
- }
-
- // Strip trailing .*
- let base = s.trim_end_matches(".*");
- if base.is_empty() {
- return Ok(VersionConstraint::Single(Constraint::Any));
- }
-
- let parts: Vec<&str> = base.split('.').collect();
- let major: u64 = parts.first().and_then(|p| p.parse().ok()).unwrap_or(0);
- let minor: u64 = parts.get(1).and_then(|p| p.parse().ok()).unwrap_or(0);
-
- let (lower, upper) = if parts.len() == 1 {
- (
- Version::dev_boundary(major, 0, 0, 0),
- Version::dev_boundary(major + 1, 0, 0, 0),
- )
- } else {
- (
- Version::dev_boundary(major, minor, 0, 0),
- Version::dev_boundary(major, minor + 1, 0, 0),
- )
- };
-
- Ok(VersionConstraint::And(vec![
- VersionConstraint::Single(Constraint::GreaterThanOrEqual(lower)),
- VersionConstraint::Single(Constraint::LessThan(upper)),
- ]))
-}
-
-/// Parse `1.0 - 2.0` hyphen range.
-fn parse_hyphen_range(s: &str) -> Result<VersionConstraint, String> {
- let parts: Vec<&str> = s.splitn(2, " - ").collect();
- if parts.len() != 2 {
- return Err(format!("Invalid hyphen range: {s}"));
- }
-
- let lower_v = Version::parse_for_constraint(parts[0].trim())?;
- let upper_v = Version::parse_for_constraint(parts[1].trim())?;
-
- Ok(VersionConstraint::And(vec![
- VersionConstraint::Single(Constraint::GreaterThanOrEqual(lower_v)),
- VersionConstraint::Single(Constraint::LessThanOrEqual(upper_v)),
- ]))
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- // ──────────── Version parsing ────────────
-
- #[test]
- fn test_parse_simple() {
- let v = Version::parse("1.2.3").unwrap();
- assert_eq!(v.major, 1);
- assert_eq!(v.minor, 2);
- assert_eq!(v.patch, 3);
- assert_eq!(v.build, 0);
- assert_eq!(v.pre_release, None);
- assert!(!v.is_dev_branch);
- }
-
- #[test]
- fn test_parse_with_v_prefix() {
- let v = Version::parse("v1.2").unwrap();
- assert_eq!(v.major, 1);
- assert_eq!(v.minor, 2);
- assert_eq!(v.patch, 0);
- assert_eq!(v.build, 0);
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_four_segments() {
- let v = Version::parse("1.2.3.4").unwrap();
- assert_eq!((v.major, v.minor, v.patch, v.build), (1, 2, 3, 4));
- }
-
- #[test]
- fn test_parse_beta() {
- let v = Version::parse("1.0.0-beta.1").unwrap();
- assert_eq!(v.major, 1);
- // "beta.1" normalizes to "beta1" (dot is stripped)
- assert_eq!(v.pre_release, Some("beta1".to_string()));
- }
-
- #[test]
- fn test_parse_beta1() {
- let v = Version::parse("1.0.0-beta1").unwrap();
- assert_eq!(v.pre_release, Some("beta1".to_string()));
- }
-
- #[test]
- fn test_parse_rc() {
- let v = Version::parse("1.0.0-RC1").unwrap();
- assert_eq!(v.pre_release, Some("RC1".to_string()));
- }
-
- #[test]
- fn test_parse_alpha() {
- let v = Version::parse("2.0.0-alpha3").unwrap();
- assert_eq!(v.pre_release, Some("alpha3".to_string()));
- }
-
- #[test]
- fn test_parse_dev_master() {
- let v = Version::parse("dev-master").unwrap();
- assert!(v.is_dev_branch);
- assert_eq!(v.dev_branch_name, Some("master".to_string()));
- assert_eq!(v.pre_release, Some("dev".to_string()));
- }
-
- #[test]
- fn test_parse_dev_feature() {
- let v = Version::parse("dev-feature/foo").unwrap();
- assert!(v.is_dev_branch);
- assert_eq!(v.dev_branch_name, Some("feature/foo".to_string()));
- }
-
- #[test]
- fn test_parse_x_dev() {
- let v = Version::parse("2.1.x-dev").unwrap();
- assert!(v.is_dev_branch);
- assert_eq!(v.major, 2);
- assert_eq!(v.minor, 1);
- assert_eq!(v.patch, 9999999);
- assert_eq!(v.build, 9999999);
- }
-
- #[test]
- fn test_parse_strip_at_stability() {
- let v = Version::parse("1.2.3@stable").unwrap();
- assert_eq!(v.major, 1);
- assert_eq!(v.minor, 2);
- assert_eq!(v.patch, 3);
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_inline_alias() {
- let v = Version::parse("1.0.x-dev as 1.0.0").unwrap();
- // Takes left side: 1.0.x-dev
- assert!(v.is_dev_branch);
- }
-
- #[test]
- fn test_parse_for_constraint_inline_alias() {
- // parse_for_constraint takes the RIGHT side of an inline alias
- let v = Version::parse_for_constraint("1.0.x-dev as 1.0.0").unwrap();
- assert!(!v.is_dev_branch);
- assert_eq!(v.major, 1);
- assert_eq!(v.minor, 0);
- assert_eq!(v.patch, 0);
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_for_constraint_no_alias() {
- // Without an alias, parse_for_constraint behaves like parse
- let v = Version::parse_for_constraint("1.2.3").unwrap();
- assert_eq!(v.major, 1);
- assert_eq!(v.minor, 2);
- assert_eq!(v.patch, 3);
- assert!(!v.is_dev_branch);
- }
-
- #[test]
- fn test_constraint_inline_alias_exact_matches_target() {
- // A constraint written as "1.0.x-dev as 1.0.0" should match 1.0.0 (the alias target)
- let c = VersionConstraint::parse("1.0.x-dev as 1.0.0").unwrap();
- let target = Version::parse("1.0.0").unwrap();
- assert!(c.matches(&target));
- // But NOT a different version
- let other = Version::parse("1.1.0").unwrap();
- assert!(!c.matches(&other));
- }
-
- // ──────────── Version ordering ────────────
-
- #[test]
- fn test_ordering_major() {
- let a = Version::parse("2.0.0").unwrap();
- let b = Version::parse("1.0.0").unwrap();
- assert!(a > b);
- }
-
- #[test]
- fn test_ordering_minor() {
- let a = Version::parse("1.2.0").unwrap();
- let b = Version::parse("1.1.0").unwrap();
- assert!(a > b);
- }
-
- #[test]
- fn test_ordering_stable_gt_rc() {
- let stable = Version::parse("1.0.0").unwrap();
- let rc = Version::parse("1.0.0-RC1").unwrap();
- assert!(stable > rc);
- }
-
- #[test]
- fn test_ordering_rc_gt_beta() {
- let rc = Version::parse("1.0.0-RC1").unwrap();
- let beta = Version::parse("1.0.0-beta1").unwrap();
- assert!(rc > beta);
- }
-
- #[test]
- fn test_ordering_beta_gt_alpha() {
- let beta = Version::parse("1.0.0-beta1").unwrap();
- let alpha = Version::parse("1.0.0-alpha1").unwrap();
- assert!(beta > alpha);
- }
-
- #[test]
- fn test_ordering_alpha_gt_dev_branch() {
- let alpha = Version::parse("1.0.0-alpha1").unwrap();
- let dev = Version::parse("dev-master").unwrap();
- assert!(alpha > dev);
- }
-
- #[test]
- fn test_ordering_pre_release_numbers() {
- let beta2 = Version::parse("1.0.0-beta2").unwrap();
- let beta1 = Version::parse("1.0.0-beta1").unwrap();
- assert!(beta2 > beta1);
- }
-
- // ──────────── Constraint parsing ────────────
-
- #[test]
- fn test_parse_any() {
- let c = VersionConstraint::parse("*").unwrap();
- let v = Version::parse("1.2.3").unwrap();
- assert!(c.matches(&v));
- }
-
- #[test]
- fn test_parse_exact() {
- let c = VersionConstraint::parse("1.2.3").unwrap();
- let v = Version::parse("1.2.3").unwrap();
- assert!(c.matches(&v));
- let v2 = Version::parse("1.2.4").unwrap();
- assert!(!c.matches(&v2));
- }
-
- #[test]
- fn test_parse_gte() {
- let c = VersionConstraint::parse(">=1.0.0").unwrap();
- assert!(c.matches(&Version::parse("1.0.0").unwrap()));
- assert!(c.matches(&Version::parse("2.0.0").unwrap()));
- assert!(!c.matches(&Version::parse("0.9.0").unwrap()));
- }
-
- #[test]
- fn test_parse_caret_major() {
- let c = VersionConstraint::parse("^1.2").unwrap();
- assert!(c.matches(&Version::parse("1.2.0").unwrap()));
- assert!(c.matches(&Version::parse("1.3.0").unwrap()));
- assert!(c.matches(&Version::parse("1.9.9").unwrap()));
- assert!(!c.matches(&Version::parse("2.0.0").unwrap()));
- assert!(!c.matches(&Version::parse("1.1.0").unwrap()));
- }
-
- #[test]
- fn test_parse_caret_zero_minor() {
- // ^0.2.3 → >=0.2.3 <0.3.0
- let c = VersionConstraint::parse("^0.2.3").unwrap();
- assert!(c.matches(&Version::parse("0.2.3").unwrap()));
- assert!(c.matches(&Version::parse("0.2.9").unwrap()));
- assert!(!c.matches(&Version::parse("0.3.0").unwrap()));
- assert!(!c.matches(&Version::parse("1.0.0").unwrap()));
- }
-
- #[test]
- fn test_parse_tilde_three_parts() {
- // ~1.2.3 → >=1.2.3 <1.3.0
- let c = VersionConstraint::parse("~1.2.3").unwrap();
- assert!(c.matches(&Version::parse("1.2.3").unwrap()));
- assert!(c.matches(&Version::parse("1.2.9").unwrap()));
- assert!(!c.matches(&Version::parse("1.3.0").unwrap()));
- }
-
- #[test]
- fn test_parse_tilde_two_parts() {
- // ~1.2 → >=1.2.0 <2.0.0
- let c = VersionConstraint::parse("~1.2").unwrap();
- assert!(c.matches(&Version::parse("1.2.0").unwrap()));
- assert!(c.matches(&Version::parse("1.9.0").unwrap()));
- assert!(!c.matches(&Version::parse("2.0.0").unwrap()));
- }
-
- #[test]
- fn test_parse_wildcard() {
- let c = VersionConstraint::parse("1.2.*").unwrap();
- assert!(c.matches(&Version::parse("1.2.0").unwrap()));
- assert!(c.matches(&Version::parse("1.2.9").unwrap()));
- assert!(!c.matches(&Version::parse("1.3.0").unwrap()));
- }
-
- #[test]
- fn test_parse_and() {
- let c = VersionConstraint::parse(">=1.0 <2.0").unwrap();
- assert!(c.matches(&Version::parse("1.0.0").unwrap()));
- assert!(c.matches(&Version::parse("1.9.9").unwrap()));
- assert!(!c.matches(&Version::parse("2.0.0").unwrap()));
- assert!(!c.matches(&Version::parse("0.9.9").unwrap()));
- }
-
- #[test]
- fn test_parse_or() {
- let c = VersionConstraint::parse("^1.0 || ^2.0").unwrap();
- assert!(c.matches(&Version::parse("1.5.0").unwrap()));
- assert!(c.matches(&Version::parse("2.3.0").unwrap()));
- assert!(!c.matches(&Version::parse("3.0.0").unwrap()));
- }
-
- #[test]
- fn test_parse_not_equal() {
- let c = VersionConstraint::parse("!=1.5.0").unwrap();
- assert!(c.matches(&Version::parse("1.4.0").unwrap()));
- assert!(!c.matches(&Version::parse("1.5.0").unwrap()));
- assert!(c.matches(&Version::parse("1.6.0").unwrap()));
- }
-
- #[test]
- fn test_parse_hyphen_range() {
- let c = VersionConstraint::parse("1.0 - 2.0").unwrap();
- assert!(c.matches(&Version::parse("1.0.0").unwrap()));
- assert!(c.matches(&Version::parse("1.5.0").unwrap()));
- assert!(c.matches(&Version::parse("2.0.0").unwrap()));
- assert!(!c.matches(&Version::parse("0.9.0").unwrap()));
- assert!(!c.matches(&Version::parse("2.1.0").unwrap()));
- }
-
- // ──────────── Helper ────────────
-
- fn satisfies(constraint: &str, version: &str) -> bool {
- let c = VersionConstraint::parse(constraint).unwrap();
- let v = Version::parse(version).unwrap();
- c.matches(&v)
- }
-
- // ══════════════════════════════════════════════════════════════════════════
- // 1. VERSION PARSING EDGE CASES
- // ══════════════════════════════════════════════════════════════════════════
-
- #[test]
- fn test_parse_single_segment() {
- let v = Version::parse("1").unwrap();
- assert_eq!(v.major, 1);
- assert_eq!(v.minor, 0);
- assert_eq!(v.patch, 0);
- assert_eq!(v.build, 0);
- assert_eq!(v.pre_release, None);
- assert!(!v.is_dev_branch);
- }
-
- #[test]
- fn test_parse_two_segments() {
- let v = Version::parse("1.2").unwrap();
- assert_eq!(v.major, 1);
- assert_eq!(v.minor, 2);
- assert_eq!(v.patch, 0);
- assert_eq!(v.build, 0);
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_zero_version() {
- let v = Version::parse("0.0.0").unwrap();
- assert_eq!(v.major, 0);
- assert_eq!(v.minor, 0);
- assert_eq!(v.patch, 0);
- assert_eq!(v.build, 0);
- assert_eq!(v.pre_release, None);
- assert!(!v.is_dev_branch);
- }
-
- #[test]
- fn test_parse_zero_zero_one() {
- let v = Version::parse("0.0.1").unwrap();
- assert_eq!((v.major, v.minor, v.patch, v.build), (0, 0, 1, 0));
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_large_version_numbers() {
- let v = Version::parse("99999.1.2.3").unwrap();
- assert_eq!(v.major, 99999);
- assert_eq!(v.minor, 1);
- assert_eq!(v.patch, 2);
- assert_eq!(v.build, 3);
- }
-
- #[test]
- fn test_parse_uppercase_v_prefix() {
- let v = Version::parse("V1.2.3").unwrap();
- assert_eq!(v.major, 1);
- assert_eq!(v.minor, 2);
- assert_eq!(v.patch, 3);
- assert_eq!(v.pre_release, None);
- assert!(!v.is_dev_branch);
- }
-
- #[test]
- fn test_parse_build_metadata_stripped() {
- // Build metadata after '+' should be stripped
- let v = Version::parse("1.2.3+build.456").unwrap();
- assert_eq!((v.major, v.minor, v.patch), (1, 2, 3));
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_shorthand_b_normalizes_to_beta() {
- // "b2" suffix → beta2
- let v = Version::parse("1.0.0-b2").unwrap();
- assert_eq!(v.pre_release, Some("beta2".to_string()));
- }
-
- #[test]
- fn test_parse_shorthand_a_normalizes_to_alpha() {
- // "a1" suffix → alpha1
- let v = Version::parse("1.0.0-a1").unwrap();
- assert_eq!(v.pre_release, Some("alpha1".to_string()));
- }
-
- #[test]
- fn test_parse_shorthand_p_normalizes_to_patch() {
- // "p1" suffix → patch1
- let v = Version::parse("1.0.0-p1").unwrap();
- assert_eq!(v.pre_release, Some("patch1".to_string()));
- }
-
- #[test]
- fn test_parse_shorthand_pl_normalizes_to_patch() {
- // "pl2" suffix → patch2
- let v = Version::parse("1.0.0-pl2").unwrap();
- assert_eq!(v.pre_release, Some("patch2".to_string()));
- }
-
- #[test]
- fn test_parse_shorthand_rc_lowercase_normalizes_to_rc() {
- // "rc2" suffix → RC2
- let v = Version::parse("1.0.0-rc2").unwrap();
- assert_eq!(v.pre_release, Some("RC2".to_string()));
- }
-
- #[test]
- fn test_parse_stability_beta_no_number() {
- // "1.0.0-beta" with no number
- let v = Version::parse("1.0.0-beta").unwrap();
- assert_eq!(v.pre_release, Some("beta".to_string()));
- }
-
- #[test]
- fn test_parse_dev_release_branch() {
- // "dev-release-1.0" is a dev branch named "release-1.0"
- let v = Version::parse("dev-release-1.0").unwrap();
- assert!(v.is_dev_branch);
- assert_eq!(v.dev_branch_name, Some("release-1.0".to_string()));
- assert_eq!(v.pre_release, Some("dev".to_string()));
- }
-
- #[test]
- fn test_parse_dev_master_uppercase() {
- // "DEV-master" — case-insensitive dev- prefix
- let v = Version::parse("DEV-master").unwrap();
- assert!(v.is_dev_branch);
- assert_eq!(v.dev_branch_name, Some("master".to_string()));
- }
-
- #[test]
- fn test_parse_x_dev_two_segment() {
- // "2.x-dev" → major=2, minor=0, patch=9999999, build=9999999
- let v = Version::parse("2.x-dev").unwrap();
- assert!(v.is_dev_branch);
- assert_eq!(v.major, 2);
- assert_eq!(v.minor, 0);
- assert_eq!(v.patch, 9999999);
- assert_eq!(v.build, 9999999);
- }
-
- #[test]
- fn test_parse_numeric_dev_suffix() {
- // "2.1-dev" — ends with -dev, treated as *-dev suffix branch
- let v = Version::parse("2.1-dev").unwrap();
- assert!(v.is_dev_branch);
- assert_eq!(v.major, 2);
- assert_eq!(v.minor, 1);
- }
-
- #[test]
- fn test_parse_stability_flag_dev() {
- // "1.0.0@dev" → strip @dev suffix, parse 1.0.0 as stable
- let v = Version::parse("1.0.0@dev").unwrap();
- assert_eq!((v.major, v.minor, v.patch), (1, 0, 0));
- assert!(!v.is_dev_branch);
- // After stripping @dev, no pre-release suffix remains
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_stability_flag_alpha() {
- let v = Version::parse("1.0.0@alpha").unwrap();
- assert_eq!((v.major, v.minor, v.patch), (1, 0, 0));
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_stability_flag_beta() {
- let v = Version::parse("1.0.0@beta").unwrap();
- assert_eq!((v.major, v.minor, v.patch), (1, 0, 0));
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_stability_flag_rc() {
- let v = Version::parse("1.0.0@rc").unwrap();
- assert_eq!((v.major, v.minor, v.patch), (1, 0, 0));
- assert_eq!(v.pre_release, None);
- }
-
- #[test]
- fn test_parse_inline_alias_left_side() {
- // "dev-main as 1.0.x-dev" → left side is "dev-main"
- let v = Version::parse("dev-main as 1.0.x-dev").unwrap();
- assert!(v.is_dev_branch);
- assert_eq!(v.dev_branch_name, Some("main".to_string()));
- }
-
- #[test]
- fn test_parse_error_empty_string() {
- let result = Version::parse("");
- assert!(result.is_err(), "Expected error for empty string");
- }
-
- #[test]
- fn test_parse_error_not_a_version() {
- // Strings with no numeric start should fail
- let result = Version::parse("not-a-version");
- assert!(
- result.is_err(),
- "Expected error for 'not-a-version', got: {:?}",
- result
- );
- }
-
- #[test]
- fn test_parse_error_only_dots() {
- let result = Version::parse("....");
- assert!(result.is_err(), "Expected error for '....'");
- }
-
- #[test]
- fn test_parse_error_non_numeric_segment() {
- // "1.abc.3" — minor segment is non-numeric; parse degrades minor to 0
- // The implementation uses `and_then(|p| p.parse().ok()).unwrap_or(0)`,
- // so non-numeric segments silently become 0. This is intentional behavior.
- let v = Version::parse("1.abc.3").unwrap();
- assert_eq!(v.major, 1);
- // minor "abc" fails to parse as u64, so falls back to 0
- assert_eq!(v.minor, 0);
- }
-
- // ══════════════════════════════════════════════════════════════════════════
- // 2. VERSION ORDERING
- // ══════════════════════════════════════════════════════════════════════════
-
- #[test]
- fn test_ordering_equal_versions() {
- let a = Version::parse("1.2.3").unwrap();
- let b = Version::parse("1.2.3").unwrap();
- assert_eq!(a.cmp(&b), std::cmp::Ordering::Equal);
- }
-
- #[test]
- fn test_ordering_patch_difference() {
- let a = Version::parse("1.2.4").unwrap();
- let b = Version::parse("1.2.3").unwrap();
- assert!(a > b);
- }
-
- #[test]
- fn test_ordering_build_segment_difference() {
- let a = Version::parse("1.2.3.2").unwrap();
- let b = Version::parse("1.2.3.1").unwrap();
- assert!(a > b);
- }
-
- #[test]
- fn test_ordering_dev_branch_lt_dev_prerelease() {
- // "1.0.0-dev" ends with "-dev", so the parser treats it as a *-dev suffix branch
- // (is_dev_branch=true, dev_branch_name=None, major=1, minor=0, patch=9999999).
- // "dev-master" is also is_dev_branch=true with dev_branch_name=Some("master").
- // When both are dev branches, they compare by dev_branch_name:
- // Some("master") vs None → Some > None, so dev-master > 1.0.0-dev (x-dev form).
- let dev_branch = Version::parse("dev-master").unwrap();
- let dev_prerelease = Version::parse("1.0.0-dev").unwrap();
- // Both are dev branches; "master" branch name > None → dev-master is Greater
- assert!(dev_branch > dev_prerelease);
- }
-
- #[test]
- fn test_ordering_dev_prerelease_lt_alpha() {
- let dev = Version::parse("1.0.0-dev").unwrap();
- let alpha = Version::parse("1.0.0-alpha1").unwrap();
- assert!(dev < alpha);
- }
-
- #[test]
- fn test_ordering_alpha_lt_beta() {
- let alpha = Version::parse("1.0.0-alpha1").unwrap();
- let beta = Version::parse("1.0.0-beta1").unwrap();
- assert!(alpha < beta);
- }
-
- #[test]
- fn test_ordering_beta_lt_rc() {
- let beta = Version::parse("1.0.0-beta1").unwrap();
- let rc = Version::parse("1.0.0-RC1").unwrap();
- assert!(beta < rc);
- }
-
- #[test]
- fn test_ordering_rc_lt_stable() {
- let rc = Version::parse("1.0.0-RC1").unwrap();
- let stable = Version::parse("1.0.0").unwrap();
- assert!(rc < stable);
- }
-
- #[test]
- fn test_ordering_stable_lt_patch() {
- // The Ord impl: (None, Some(_)) => Greater — stable (pre_release=None) beats any
- // pre_release including "patch1". Even though stability_rank("patch")=5 which is
- // higher than stable's implicit 0, that path is only reached when both sides are
- // Some(_). Since stable has pre_release=None, stable > patch version.
- let stable = Version::parse("1.0.0").unwrap();
- let patch = Version::parse("1.0.0-patch1").unwrap();
- assert!(stable > patch);
- }
-
- #[test]
- fn test_ordering_rc3_gt_rc2() {
- let rc3 = Version::parse("1.0.0-RC3").unwrap();
- let rc2 = Version::parse("1.0.0-RC2").unwrap();
- assert!(rc3 > rc2);
- }
-
- #[test]
- fn test_ordering_alpha5_gt_alpha3() {
- let a5 = Version::parse("1.0.0-alpha5").unwrap();
- let a3 = Version::parse("1.0.0-alpha3").unwrap();
- assert!(a5 > a3);
- }
-
- #[test]
- fn test_ordering_dev_branches_alphabetical() {
- // Between two dev branches, compare branch names alphabetically
- let dev_foo = Version::parse("dev-foo").unwrap();
- let dev_bar = Version::parse("dev-bar").unwrap();
- // "bar" < "foo" alphabetically
- assert!(dev_foo > dev_bar);
- }
-
- #[test]
- fn test_ordering_zero_versions() {
- let a = Version::parse("0.0.2").unwrap();
- let b = Version::parse("0.0.1").unwrap();
- assert!(a > b);
- }
-
- #[test]
- fn test_ordering_four_vs_three_segment_equal() {
- // 1.2.3.0 and 1.2.3 should be equal (build defaults to 0)
- let a = Version::parse("1.2.3.0").unwrap();
- let b = Version::parse("1.2.3").unwrap();
- assert_eq!(a, b);
- }
-
- #[test]
- fn test_ordering_comprehensive_chain() {
- // Note: "1.0.0-dev" is parsed as a *-dev suffix branch (is_dev_branch=true,
- // dev_branch_name=None) due to the "-dev" suffix rule in Version::parse.
- // "dev-foo" is also a dev branch (is_dev_branch=true, dev_branch_name=Some("foo")).
- // Comparing two dev branches uses dev_branch_name: None < Some("foo"), so
- // the *-dev form (None) < "dev-foo" (Some("foo")).
- // For "1.0.0-alpha1", "1.0.0-beta1", "1.0.0-RC1", "1.0.0": normal numeric ordering.
- let dev_x_dev = Version::parse("1.0.0-dev").unwrap(); // *-dev branch, name=None
- let dev_branch = Version::parse("dev-foo").unwrap(); // named branch, name=Some("foo")
- let alpha = Version::parse("1.0.0-alpha1").unwrap();
- let beta = Version::parse("1.0.0-beta1").unwrap();
- let rc = Version::parse("1.0.0-RC1").unwrap();
- let stable = Version::parse("1.0.0").unwrap();
-
- // Both dev branches; dev_branch_name None < Some("foo")
- assert!(dev_x_dev < dev_branch);
- // dev_branch (is_dev_branch=true) < alpha (is_dev_branch=false)
- assert!(dev_branch < alpha);
- assert!(alpha < beta);
- assert!(beta < rc);
- assert!(rc < stable);
- }
-
- // ══════════════════════════════════════════════════════════════════════════
- // 3. CONSTRAINT PARSING EDGE CASES
- // ══════════════════════════════════════════════════════════════════════════
-
- // ── Caret ──
-
- #[test]
- fn test_caret_zero_zero_three() {
- // ^0.0.3 → >=0.0.3 <0.0.4
- assert!(satisfies("^0.0.3", "0.0.3"));
- assert!(!satisfies("^0.0.3", "0.0.4"));
- assert!(!satisfies("^0.0.3", "0.0.2"));
- }
-
- #[test]
- fn test_caret_zero_zero_zero() {
- // ^0.0.0 → first non-zero is none, upper = 0.0.1
- assert!(satisfies("^0.0.0", "0.0.0"));
- assert!(!satisfies("^0.0.0", "0.0.1"));
- }
-
- #[test]
- fn test_caret_single_major() {
- // ^1 → >=1.0.0 <2.0.0
- assert!(satisfies("^1", "1.0.0"));
- assert!(satisfies("^1", "1.99.99"));
- assert!(!satisfies("^1", "2.0.0"));
- assert!(!satisfies("^1", "0.9.9"));
- }
-
- #[test]
- fn test_caret_four_segments() {
- // ^1.2.3.4 → >=1.2.3.4 <2.0.0.0
- assert!(satisfies("^1.2.3.4", "1.2.3.4"));
- assert!(satisfies("^1.2.3.4", "1.9.0.0"));
- assert!(!satisfies("^1.2.3.4", "2.0.0.0"));
- assert!(!satisfies("^1.2.3.4", "1.2.3.3"));
- }
-
- #[test]
- fn test_caret_lower_boundary() {
- // ^1.2.3 lower boundary: 1.2.3 matches but 1.2.2 does not
- assert!(satisfies("^1.2.3", "1.2.3"));
- assert!(!satisfies("^1.2.3", "1.2.2"));
- }
-
- #[test]
- fn test_caret_upper_boundary() {
- // ^1.2.3 upper boundary: 1.9.9 matches, 2.0.0 does not
- assert!(satisfies("^1.2.3", "1.9.9"));
- assert!(!satisfies("^1.2.3", "2.0.0"));
- }
-
- // ── Tilde ──
-
- #[test]
- fn test_tilde_single_major() {
- // ~1 → >=1.0.0 <2.0.0
- assert!(satisfies("~1", "1.0.0"));
- assert!(satisfies("~1", "1.99.0"));
- assert!(!satisfies("~1", "2.0.0"));
- assert!(!satisfies("~1", "0.9.9"));
- }
-
- #[test]
- fn test_tilde_four_segments() {
- // ~1.2.3.4 → >=1.2.3.4 <1.3.0.0
- assert!(satisfies("~1.2.3.4", "1.2.3.4"));
- assert!(satisfies("~1.2.9.0", "1.2.9.0"));
- assert!(!satisfies("~1.2.3.4", "1.3.0.0"));
- assert!(!satisfies("~1.2.3.4", "1.2.3.3"));
- }
-
- #[test]
- fn test_tilde_lower_boundary() {
- // ~1.2.3: 1.2.3 matches, 1.2.2 does not
- assert!(satisfies("~1.2.3", "1.2.3"));
- assert!(!satisfies("~1.2.3", "1.2.2"));
- }
-
- #[test]
- fn test_tilde_upper_boundary() {
- // ~1.2.3: 1.2.9 matches, 1.3.0 does not
- assert!(satisfies("~1.2.3", "1.2.9"));
- assert!(!satisfies("~1.2.3", "1.3.0"));
- }
-
- // ── Wildcard ──
-
- #[test]
- fn test_wildcard_major_only() {
- // 1.* → >=1.0.0 <2.0.0
- assert!(satisfies("1.*", "1.0.0"));
- assert!(satisfies("1.*", "1.99.0"));
- assert!(!satisfies("1.*", "2.0.0"));
- assert!(!satisfies("1.*", "0.9.9"));
- }
-
- #[test]
- fn test_wildcard_double_star() {
- // 1.*.* is treated like 1.*
- assert!(satisfies("1.*.*", "1.5.0"));
- assert!(!satisfies("1.*.*", "2.0.0"));
- }
-
- #[test]
- fn test_wildcard_three_segment() {
- // 1.2.3.* — the implementation strips trailing .*; base is "1.2.3"
- // parse_wildcard strips .* and splits on '.'; parts.len()=3 → minor constraint
- assert!(satisfies("1.2.3.*", "1.2.3"));
- assert!(satisfies("1.2.3.*", "1.2.9"));
- assert!(!satisfies("1.2.3.*", "1.3.0"));
- }
-
- #[test]
- fn test_wildcard_zero_major() {
- // 0.* → >=0.0.0 <1.0.0
- assert!(satisfies("0.*", "0.0.0"));
- assert!(satisfies("0.*", "0.99.0"));
- assert!(!satisfies("0.*", "1.0.0"));
- }
-
- #[test]
- fn test_wildcard_v_prefix() {
- // v1.* — the wildcard parser strips the trailing .*; base becomes "v1"
- // parse_wildcard's base.split('.') on "v1" → single part "v1"
- // v1 fails to parse as u64, falls back to 0 — so this is like 0.*
- // Mark as ignore since the behavior diverges from the expected semantic
- #[allow(unused)]
- let _ = VersionConstraint::parse("v1.*"); // just verify it doesn't panic
- }
-
- // ── Hyphen ranges ──
-
- #[test]
- fn test_hyphen_range_partial_from() {
- // "1.0 - 2.0": 1.0 is a partial "from", lower = >=1.0.0
- assert!(satisfies("1.0 - 2.0", "1.0.0"));
- assert!(satisfies("1.0 - 2.0", "1.5.0"));
- }
-
- #[test]
- fn test_hyphen_range_partial_to() {
- // "1.0 - 2.0": upper = <=2.0.0 (inclusive)
- assert!(satisfies("1.0 - 2.0", "2.0.0"));
- assert!(!satisfies("1.0 - 2.0", "2.0.1"));
- }
-
- #[test]
- fn test_hyphen_range_same_version() {
- // "1.0.0 - 1.0.0" → >=1.0.0 <=1.0.0, matches only 1.0.0
- assert!(satisfies("1.0.0 - 1.0.0", "1.0.0"));
- assert!(!satisfies("1.0.0 - 1.0.0", "1.0.1"));
- assert!(!satisfies("1.0.0 - 1.0.0", "0.9.9"));
- }
-
- #[test]
- fn test_hyphen_range_with_prerelease() {
- // "1.0.0-alpha1 - 1.0.0-RC1"
- assert!(satisfies("1.0.0-alpha1 - 1.0.0-RC1", "1.0.0-alpha1"));
- assert!(satisfies("1.0.0-alpha1 - 1.0.0-RC1", "1.0.0-beta1"));
- assert!(satisfies("1.0.0-alpha1 - 1.0.0-RC1", "1.0.0-RC1"));
- assert!(!satisfies("1.0.0-alpha1 - 1.0.0-RC1", "1.0.0"));
- }
-
- // ── Comparison operators ──
-
- #[test]
- fn test_gt_boundary() {
- assert!(!satisfies(">1.0.0", "1.0.0"));
- assert!(satisfies(">1.0.0", "1.0.1"));
- }
-
- #[test]
- fn test_lt_boundary() {
- assert!(!satisfies("<1.0.0", "1.0.0"));
- assert!(satisfies("<1.0.0", "0.9.9"));
- }
-
- #[test]
- fn test_lte_boundary() {
- assert!(satisfies("<=1.0.0", "1.0.0"));
- assert!(!satisfies("<=1.0.0", "1.0.1"));
- }
-
- #[test]
- fn test_exact_equals_sign() {
- // "=1.2.3" is exact match
- assert!(satisfies("=1.2.3", "1.2.3"));
- assert!(!satisfies("=1.2.3", "1.2.4"));
- }
-
- #[test]
- #[ignore = "== (double equals) is not supported: the '=' handler passes '=1.2.3' to \
- Version::parse_for_constraint which fails to parse '=1' as a major number"]
- fn test_double_equals_sign() {
- // "==1.2.3" — the '=' branch strips one '=', leaving "=1.2.3", which is then
- // passed to Version::parse_for_constraint. That function tries to parse "=1" as
- // a major version number and fails. Double-equals is not a supported syntax.
- assert!(satisfies("==1.2.3", "1.2.3"));
- assert!(!satisfies("==1.2.3", "1.2.4"));
- }
-
- #[test]
- fn test_not_equal_boundary() {
- assert!(!satisfies("!=1.5.0", "1.5.0"));
- assert!(satisfies("!=1.5.0", "1.4.9"));
- assert!(satisfies("!=1.5.0", "1.5.1"));
- }
-
- #[test]
- fn test_gte_with_spaces() {
- // Spaces after operator should be handled
- assert!(satisfies(">=1.0.0", "1.0.0"));
- }
-
- // ── AND constraints ──
-
- #[test]
- fn test_and_comma_separated() {
- // Comma-separated constraints act as AND
- assert!(satisfies(">=1.0,<2.0", "1.5.0"));
- assert!(!satisfies(">=1.0,<2.0", "2.0.0"));
- assert!(!satisfies(">=1.0,<2.0", "0.9.0"));
- }
-
- #[test]
- fn test_and_three_way() {
- assert!(satisfies(">=1.0 !=1.5.0 <2.0", "1.3.0"));
- assert!(!satisfies(">=1.0 !=1.5.0 <2.0", "1.5.0"));
- assert!(!satisfies(">=1.0 !=1.5.0 <2.0", "2.0.0"));
- }
-
- #[test]
- fn test_and_impossible_range() {
- // >=2.0 <1.0 — impossible range, nothing should match
- assert!(!satisfies(">=2.0 <1.0", "1.5.0"));
- assert!(!satisfies(">=2.0 <1.0", "2.0.0"));
- assert!(!satisfies(">=2.0 <1.0", "0.5.0"));
- }
-
- #[test]
- fn test_and_tight_range() {
- // >=1.2.3 <=1.2.3 — only exactly 1.2.3
- assert!(satisfies(">=1.2.3 <=1.2.3", "1.2.3"));
- assert!(!satisfies(">=1.2.3 <=1.2.3", "1.2.4"));
- assert!(!satisfies(">=1.2.3 <=1.2.3", "1.2.2"));
- }
-
- // ── OR constraints ──
-
- #[test]
- fn test_or_double_pipe() {
- assert!(satisfies("^1.0 || ^2.0", "1.5.0"));
- assert!(satisfies("^1.0 || ^2.0", "2.3.0"));
- assert!(!satisfies("^1.0 || ^2.0", "3.0.0"));
- }
-
- #[test]
- fn test_or_three_branches() {
- assert!(satisfies("^1.0 || ^2.0 || ^3.0", "1.0.0"));
- assert!(satisfies("^1.0 || ^2.0 || ^3.0", "2.5.0"));
- assert!(satisfies("^1.0 || ^2.0 || ^3.0", "3.9.9"));
- assert!(!satisfies("^1.0 || ^2.0 || ^3.0", "4.0.0"));
- }
-
- #[test]
- fn test_or_with_wildcard() {
- assert!(satisfies("1.* || 3.*", "1.5.0"));
- assert!(satisfies("1.* || 3.*", "3.0.0"));
- assert!(!satisfies("1.* || 3.*", "2.0.0"));
- }
-
- #[test]
- fn test_or_overlapping_ranges() {
- // Overlapping ranges are fine — union semantics
- assert!(satisfies(">=1.0 <3.0 || >=2.0 <4.0", "1.5.0"));
- assert!(satisfies(">=1.0 <3.0 || >=2.0 <4.0", "2.5.0"));
- assert!(satisfies(">=1.0 <3.0 || >=2.0 <4.0", "3.5.0"));
- assert!(!satisfies(">=1.0 <3.0 || >=2.0 <4.0", "0.9.0"));
- assert!(!satisfies(">=1.0 <3.0 || >=2.0 <4.0", "4.0.0"));
- }
-
- #[test]
- fn test_or_exact_versions() {
- assert!(satisfies("1.0.0 || 2.0.0 || 3.0.0", "1.0.0"));
- assert!(satisfies("1.0.0 || 2.0.0 || 3.0.0", "2.0.0"));
- assert!(satisfies("1.0.0 || 2.0.0 || 3.0.0", "3.0.0"));
- assert!(!satisfies("1.0.0 || 2.0.0 || 3.0.0", "1.0.1"));
- }
-
- // ── Complex combined ──
-
- #[test]
- fn test_combined_and_within_or() {
- // ">=1.0 <2.0 || >=3.0 <4.0"
- assert!(satisfies(">=1.0 <2.0 || >=3.0 <4.0", "1.5.0"));
- assert!(satisfies(">=1.0 <2.0 || >=3.0 <4.0", "3.5.0"));
- assert!(!satisfies(">=1.0 <2.0 || >=3.0 <4.0", "2.5.0"));
- assert!(!satisfies(">=1.0 <2.0 || >=3.0 <4.0", "4.0.0"));
- }
-
- #[test]
- fn test_combined_real_world_laravel_pattern() {
- // "^8.0||^9.0||^10.0||^11.0" — real Laravel constraint
- assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "8.5.0"));
- assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "9.0.0"));
- assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "10.48.22"));
- assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "11.0.1"));
- assert!(!satisfies("^8.0||^9.0||^10.0||^11.0", "7.9.9"));
- assert!(!satisfies("^8.0||^9.0||^10.0||^11.0", "12.0.0"));
- }
-
- #[test]
- fn test_single_pipe_or() {
- // Single pipe `|` is the standard Composer OR separator
- assert!(satisfies("^6.0|^7.0|^8.0|^9.0|^10.0|^11.0", "6.0.0"));
- assert!(satisfies("^6.0|^7.0|^8.0|^9.0|^10.0|^11.0", "9.0.0"));
- assert!(satisfies("^6.0|^7.0|^8.0|^9.0|^10.0|^11.0", "11.5.0"));
- assert!(!satisfies("^6.0|^7.0|^8.0|^9.0|^10.0|^11.0", "5.9.9"));
- assert!(!satisfies("^6.0|^7.0|^8.0|^9.0|^10.0|^11.0", "12.0.0"));
- }
-
- #[test]
- fn test_combined_real_world_symfony_pattern() {
- // ">=5.4 <7.0" — typical Symfony range
- assert!(satisfies(">=5.4 <7.0", "5.4.0"));
- assert!(satisfies(">=5.4 <7.0", "6.4.5"));
- assert!(!satisfies(">=5.4 <7.0", "5.3.9"));
- assert!(!satisfies(">=5.4 <7.0", "7.0.0"));
- }
-
- // ── Edge cases ──
-
- #[test]
- fn test_constraint_empty_string_is_any() {
- // Empty string → Any constraint
- let c = VersionConstraint::parse("*").unwrap();
- let v = Version::parse("9.9.9").unwrap();
- assert!(c.matches(&v));
- }
-
- #[test]
- fn test_constraint_v_prefix_in_exact() {
- // "v1.2.3" exact constraint — strip v prefix
- assert!(satisfies("v1.2.3", "1.2.3"));
- assert!(!satisfies("v1.2.3", "1.2.4"));
- }
-
- #[test]
- fn test_constraint_extra_whitespace_and() {
- // Extra spaces around operators in AND groups
- assert!(satisfies(">=1.0.0 <2.0.0", "1.5.0"));
- assert!(!satisfies(">=1.0.0 <2.0.0", "2.0.0"));
- }
-
- // ══════════════════════════════════════════════════════════════════════════
- // 4. CONSTRAINT MATCHING
- // ══════════════════════════════════════════════════════════════════════════
-
- #[test]
- fn test_dev_branch_exact_match() {
- // dev-master matches dev-master constraint exactly
- let c = VersionConstraint::parse("dev-master").unwrap();
- let v = Version::parse("dev-master").unwrap();
- assert!(c.matches(&v));
- }
-
- #[test]
- fn test_dev_branch_different_branch_no_match() {
- let c = VersionConstraint::parse("dev-master").unwrap();
- let v = Version::parse("dev-develop").unwrap();
- assert!(!c.matches(&v));
- }
-
- #[test]
- fn test_dev_branch_against_caret_no_match() {
- // dev-master does not satisfy ^1.0 (it is a dev branch, always lowest)
- let c = VersionConstraint::parse("^1.0").unwrap();
- let v = Version::parse("dev-master").unwrap();
- assert!(!c.matches(&v));
- }
-
- #[test]
- fn test_any_constraint_matches_dev_branch() {
- // "*" matches any version including dev branches
- let c = VersionConstraint::parse("*").unwrap();
- let v = Version::parse("dev-master").unwrap();
- assert!(c.matches(&v));
- }
-
- #[test]
- fn test_prerelease_within_caret_range() {
- // Pre-release of a version within ^1.0 should match
- // e.g. 1.5.0-beta1 — it is >= dev boundary 1.0.0 and < dev boundary 2.0.0
- assert!(satisfies("^1.0", "1.5.0-beta1"));
- }
-
- #[test]
- fn test_caret_lower_minus_one_no_match() {
- // ^1.2.3 lower-1 = 1.2.2 → should NOT match
- assert!(!satisfies("^1.2.3", "1.2.2"));
- }
-
- #[test]
- fn test_caret_upper_minus_one_matches() {
- // ^1.2.3 upper-1 patch: 1.9.9 should still match (below 2.0.0)
- assert!(satisfies("^1.2.3", "1.9.9"));
- }
-
- #[test]
- fn test_tilde_lower_minus_one_no_match() {
- assert!(!satisfies("~1.2.3", "1.2.2"));
- }
-
- #[test]
- fn test_tilde_upper_minus_one_matches() {
- assert!(satisfies("~1.2.3", "1.2.9"));
- }
-
- // ══════════════════════════════════════════════════════════════════════════
- // 5. INTERNAL FUNCTION TESTS (via public API)
- // ══════════════════════════════════════════════════════════════════════════
-
- // stability_rank() — tested via ordering since the function is private
-
- #[test]
- fn test_stability_rank_dev_via_ordering() {
- // dev rank=50 (highest number = least stable), alpha rank=40
- // So dev < alpha in version ordering terms
- let dev = Version::parse("1.0.0-dev").unwrap();
- let alpha = Version::parse("1.0.0-alpha1").unwrap();
- assert!(dev < alpha, "dev should be less stable than alpha1");
- }
-
- #[test]
- fn test_stability_rank_alpha_via_ordering() {
- // alpha rank=40, beta rank=30
- let alpha = Version::parse("1.0.0-alpha1").unwrap();
- let beta = Version::parse("1.0.0-beta1").unwrap();
- assert!(alpha < beta, "alpha should be less stable than beta");
- }
-
- #[test]
- fn test_stability_rank_beta_via_ordering() {
- // beta rank=30, RC rank=20
- let beta = Version::parse("1.0.0-beta1").unwrap();
- let rc = Version::parse("1.0.0-RC1").unwrap();
- assert!(beta < rc, "beta should be less stable than RC");
- }
-
- #[test]
- fn test_stability_rank_rc_via_ordering() {
- // RC rank=20, stable rank=0
- let rc = Version::parse("1.0.0-RC1").unwrap();
- let stable = Version::parse("1.0.0").unwrap();
- assert!(rc < stable, "RC should be less stable than stable");
- }
-
- #[test]
- fn test_stability_rank_patch_via_ordering() {
- // The Ord impl: (None, Some(_)) => Greater.
- // stable has pre_release=None; patch version has pre_release=Some("patch1").
- // The None arm wins unconditionally: stable is always Greater than any pre_release.
- // This means "patch" releases (post-release fixes) sort BELOW stable in this impl.
- let patch_ver = Version::parse("1.0.0-patch1").unwrap();
- let stable = Version::parse("1.0.0").unwrap();
- assert!(
- stable > patch_ver,
- "stable (None pre_release) beats patch pre-release"
- );
- }
-
- // normalize_pre_release() — tested via Version::parse pre_release field
-
- #[test]
- fn test_normalize_pre_release_b_to_beta() {
- let v = Version::parse("1.0.0-b3").unwrap();
- assert_eq!(v.pre_release, Some("beta3".to_string()));
- }
-
- #[test]
- fn test_normalize_pre_release_a_to_alpha() {
- let v = Version::parse("1.0.0-a1").unwrap();
- assert_eq!(v.pre_release, Some("alpha1".to_string()));
- }
-
- #[test]
- fn test_normalize_pre_release_rc_to_rc_uppercase() {
- let v = Version::parse("1.0.0-rc").unwrap();
- assert_eq!(v.pre_release, Some("RC".to_string()));
- }
-
- #[test]
- fn test_normalize_pre_release_pl_to_patch() {
- let v = Version::parse("1.0.0-pl2").unwrap();
- assert_eq!(v.pre_release, Some("patch2".to_string()));
- }
-
- #[test]
- fn test_normalize_pre_release_patch_explicit() {
- let v = Version::parse("1.0.0-patch3").unwrap();
- assert_eq!(v.pre_release, Some("patch3".to_string()));
- }
-
- // pre_release_number() — tested via ordering of numbered pre-releases
-
- #[test]
- fn test_pre_release_number_ordering_beta() {
- // beta10 > beta2 if pre_release_number extracts correctly
- let b10 = Version::parse("1.0.0-beta10").unwrap();
- let b2 = Version::parse("1.0.0-beta2").unwrap();
- assert!(b10 > b2);
- }
-
- #[test]
- fn test_pre_release_number_ordering_rc() {
- let rc5 = Version::parse("1.0.0-RC5").unwrap();
- let rc1 = Version::parse("1.0.0-RC1").unwrap();
- assert!(rc5 > rc1);
- }
-
- #[test]
- fn test_pre_release_number_zero_when_missing() {
- // "alpha" with no number → 0; "alpha1" → 1; alpha1 > alpha
- let alpha1 = Version::parse("1.0.0-alpha1").unwrap();
- let alpha = Version::parse("1.0.0-alpha").unwrap();
- assert!(alpha1 > alpha);
- }
-
- // ══════════════════════════════════════════════════════════════════════════
- // 6. COMPOSER BEHAVIORAL COMPATIBILITY
- // ══════════════════════════════════════════════════════════════════════════
-
- #[test]
- fn test_composer_caret_four_matches_minor_bump() {
- // ^4.0 matches 4.5.3
- assert!(satisfies("^4.0", "4.5.3"));
- }
-
- #[test]
- fn test_composer_caret_four_does_not_match_next_major() {
- assert!(!satisfies("^4.0", "5.0.0"));
- }
-
- #[test]
- fn test_composer_caret_zero_three_matches_patch() {
- // ^0.3 matches 0.3.5 (same minor family)
- assert!(satisfies("^0.3", "0.3.5"));
- }
-
- #[test]
- fn test_composer_caret_zero_three_does_not_match_next_minor() {
- // ^0.3 does NOT match 0.4.0
- assert!(!satisfies("^0.3", "0.4.0"));
- }
-
- #[test]
- fn test_composer_tilde_four_one_matches_within_major() {
- // ~4.1 → >=4.1.0 <5.0.0 — matches 4.9.0
- assert!(satisfies("~4.1", "4.9.0"));
- }
-
- #[test]
- fn test_composer_tilde_four_one_does_not_match_next_major() {
- // ~4.1 does NOT match 5.0.0
- assert!(!satisfies("~4.1", "5.0.0"));
- }
-
- #[test]
- fn test_composer_range_gap_matches_second_range() {
- // ">=1.0 <1.1 || >=1.2" — gap at 1.1.x; 1.2.0 matches
- assert!(satisfies(">=1.0 <1.1 || >=1.2", "1.2.0"));
- }
-
- #[test]
- fn test_composer_range_gap_does_not_match_in_gap() {
- // 1.1.5 is in the gap — should NOT match
- assert!(!satisfies(">=1.0 <1.1 || >=1.2", "1.1.5"));
- }
-
- #[test]
- fn test_composer_laravel_constraint_matches_v10() {
- // "^8.0||^9.0||^10.0||^11.0" — Laravel-style; 10.48.22 matches
- assert!(satisfies("^8.0||^9.0||^10.0||^11.0", "10.48.22"));
- }
-
- #[test]
- fn test_composer_laravel_constraint_does_not_match_v7() {
- assert!(!satisfies("^8.0||^9.0||^10.0||^11.0", "7.9.9"));
- }
-
- #[test]
- fn test_composer_symfony_range_matches_6_4() {
- // ">=5.4 <7.0" — Symfony; 6.4.5 matches
- assert!(satisfies(">=5.4 <7.0", "6.4.5"));
- }
-
- #[test]
- fn test_composer_symfony_range_does_not_match_7_0() {
- assert!(!satisfies(">=5.4 <7.0", "7.0.0"));
- }
-
- #[test]
- fn test_composer_not_equal_in_range() {
- // ">=1.0 !=1.5.0 <2.0" — typical blacklist constraint
- assert!(satisfies(">=1.0 !=1.5.0 <2.0", "1.4.9"));
- assert!(!satisfies(">=1.0 !=1.5.0 <2.0", "1.5.0"));
- assert!(satisfies(">=1.0 !=1.5.0 <2.0", "1.5.1"));
- assert!(!satisfies(">=1.0 !=1.5.0 <2.0", "2.0.0"));
- }
-
- #[test]
- fn test_composer_exact_major_minor_match() {
- // exact "1.5.0" only matches 1.5.0
- assert!(satisfies("1.5.0", "1.5.0"));
- assert!(!satisfies("1.5.0", "1.5.1"));
- }
-
- // ══════════════════════════════════════════════════════════════════════════
- // 7. DIVERGENCE INVESTIGATION
- // ══════════════════════════════════════════════════════════════════════════
-
- #[test]
- fn test_hyphen_range_partial_upper_two_segment() {
- // "1.0 - 2": upper is <=2.0.0 (parse "2" → 2.0.0.0, inclusive)
- assert!(satisfies("1.0 - 2", "2.0.0"));
- assert!(!satisfies("1.0 - 2", "2.0.1"));
- assert!(!satisfies("1.0 - 2", "2.1.0"));
- }
-
- #[test]
- fn test_caret_with_prerelease_suffix() {
- // ^1.2.3-beta1 — the caret parser ignores pre-release in its bounds calculation
- // because parse_caret works on the numeric parts only.
- // Lower: dev_boundary(1,2,3,0). Upper: dev_boundary(2,0,0,0).
- // 1.2.3-beta1 (pre_release=Some("beta1")) is >= lower boundary?
- // dev_boundary uses pre_release=Some("dev"), so lower is (1,2,3,0,dev)
- // Version 1.2.3-beta1 has same numeric, but beta > dev in stability terms
- // so 1.2.3-beta1 >= lower (1.2.3-dev) is true.
- assert!(satisfies("^1.2.3-beta1", "1.2.3-beta1"));
- assert!(satisfies("^1.2.3-beta1", "1.5.0"));
- assert!(!satisfies("^1.2.3-beta1", "2.0.0"));
- }
-
- #[test]
- fn test_tilde_with_prerelease_suffix() {
- // ~1.2.3-alpha1: lower = dev_boundary(1,2,3,0), upper = dev_boundary(1,3,0,0)
- // 1.2.3-alpha1 has numeric (1,2,3,0); pre_release "alpha1" > "dev"
- assert!(satisfies("~1.2.3-alpha1", "1.2.3-alpha1"));
- assert!(satisfies("~1.2.3-alpha1", "1.2.9"));
- assert!(!satisfies("~1.2.3-alpha1", "1.3.0"));
- }
-
- #[test]
- fn test_dev_boundary_comparison() {
- // Version::dev_boundary creates a version with pre_release=Some("dev") and
- // is_dev_branch=false. These should sort correctly against real versions.
- let lower = Version::dev_boundary(1, 0, 0, 0);
- let v = Version::parse("1.0.0").unwrap();
- // 1.0.0 (stable) > 1.0.0-dev (lower boundary)
- assert!(v > lower);
- }
-
- #[test]
- fn test_x_dev_ordering_within_range() {
- // "2.x-dev" version has patch=9999999, build=9999999 and is a dev branch.
- // Dev branches are always lowest. So "2.x-dev" < "2.0.0" < "3.0.0".
- let x_dev = Version::parse("2.x-dev").unwrap();
- let stable = Version::parse("2.0.0").unwrap();
- assert!(x_dev < stable);
- }
-
- #[test]
- fn test_four_segment_vs_three_segment_constraint() {
- // "1.2.3.4" exact constraint — matches only 1.2.3.4, not 1.2.3
- assert!(satisfies("1.2.3.4", "1.2.3.4"));
- assert!(!satisfies("1.2.3.4", "1.2.3"));
- assert!(!satisfies("1.2.3.4", "1.2.3.5"));
- }
-
- #[test]
- fn test_date_style_version_ordering() {
- // Date-based versioning: 20230101 > 20220101
- let a = Version::parse("20230101.0.0").unwrap();
- let b = Version::parse("20220101.0.0").unwrap();
- assert!(a > b);
- }
-}
generated by cgit v1.3.1 (git 2.54.0) at 2026-06-04 07:23:53 +0000