jayver 1.0.0

A calendar versioning scheme for binaries developed by Emmett Jayhart
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Tests for the public API as a whole, using components together
use jayver::{is_valid, parse, today, Version, VersionReq};

#[test]
fn test_public_api_workflow() {
    // Test top-level API functions
    let version_str = "25.16.3";
    assert!(is_valid(version_str));

    let version = parse(version_str).unwrap();
    assert_eq!(version.year, 25);
    assert_eq!(version.week, 16);
    assert_eq!(version.patch, 3);

    // Create today's version - can't test exact values, but ensure valid
    let today_version = today();
    assert!(today_version.week >= 1 && today_version.week <= 53);
    assert_eq!(today_version.patch, 0);

    // Test all components working together
    let base_version = Version::parse("25.10.0").unwrap();

    // Use single requirement instead of complex requirement
    let req = VersionReq::parse(">=25.10.0").unwrap();

    assert!(req.matches(&base_version));

    // Version manipulation and requirement checking
    let mut updated = base_version;
    updated.increment_patch();
    assert!(req.matches(&updated));

    // Week boundary transitions (components working together)
    let mut week_end = Version::parse("25.12.0").unwrap(); // Use a clearly valid week
    week_end.next_week().unwrap();
    assert!(req.matches(&week_end));
}

#[test]
fn test_requirement_patterns() {
    // Test various requirement patterns with version checking
    let v = Version::parse("25.10.5").unwrap();

    // Exact match
    let exact = VersionReq::parse("=25.10.5").unwrap();
    assert!(exact.matches(&v));

    // Week compatibility
    let compatible = VersionReq::parse("~>25.10.0").unwrap();
    assert!(compatible.matches(&v));

    // Complex requirements need to be parsed separately
    let req1 = VersionReq::parse(">=25.10.0").unwrap();
    let req2 = VersionReq::parse("<25.11.0").unwrap();

    assert!(req1.matches(&v));
    assert!(req2.matches(&v));

    // OR behavior via AnyVersionReq
    let any_req = VersionReq::any([">25.20.0", "<25.5.0"]).unwrap();

    assert!(!any_req.matches(&v)); // Neither condition met

    let early = Version::parse("25.4.0").unwrap();
    assert!(any_req.matches(&early)); // Matches second condition

    let late = Version::parse("25.30.0").unwrap();
    assert!(any_req.matches(&late)); // Matches first condition
}

#[test]
fn test_year_boundaries() {
    // Week 53 to week 1 transition
    // Try with a known valid year/week combination
    let mut v = Version::parse("20.52.0").unwrap(); // 2020 week 52
    v.next_week().unwrap();

    // Since 2020 was a leap year, week 53 is valid
    assert_eq!(v.year, 20);
    assert_eq!(v.week, 53);

    // Now transition to the next year
    v.next_week().unwrap();
    assert_eq!(v.year, 21);
    assert_eq!(v.week, 1);

    // Requirements crossing year boundaries
    let req = VersionReq::parse(">=20.52.0").unwrap();
    assert!(req.matches(&v));
}

#[test]
fn test_empty_requirements() {
    // Empty requirement should match any version
    let req = VersionReq::parse("").unwrap();
    let v = Version::parse("25.10.0").unwrap();
    assert!(req.matches(&v));

    // Same with "*"
    let req = VersionReq::parse("*").unwrap();
    assert!(req.matches(&v));
}