cargo-tag 0.1.14

Cargo plugin to bump crate's versions and Git tag them for release
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
103
104
105
106
107
108
109
110
111
112
113
114

use std::fmt;

use anyhow::{Context, Result};
use semver::Version as SemVer;

pub struct Version {
    pub(crate) ver: SemVer,
}

enum Digit {
    Major,
    Minor,
    Patch,
}

impl Version {
    pub fn bump_major(&mut self) {
        self.bump(Digit::Major)
    }

    pub fn bump_minor(&mut self) {
        self.bump(Digit::Minor)
    }

    pub fn bump_patch(&mut self) {
        self.bump(Digit::Patch)
    }

    fn bump(&mut self, digit: Digit) {
        match digit {
            Digit::Major => {
                self.ver.major += 1;
                self.ver.minor = 0;
                self.ver.patch = 0;
            }
            Digit::Minor => {
                self.ver.minor += 1;
                self.ver.patch = 0;
            }
            Digit::Patch => {
                self.ver.patch += 1;
            }
        }
    }

    pub fn set_prerelease(&mut self, prerelease: &str) -> Result<()> {
        self.ver.pre = semver::Prerelease::new(prerelease)
            .context(format!("Failed to set prerelase value \"{prerelease}\""))?;
        Ok(())
    }
}

impl fmt::Display for Version {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.ver)
    }
}

impl From<Version> for SemVer {
    fn from(ver: Version) -> Self {
        ver.ver
    }
}

impl From<&SemVer> for Version {
    fn from(ver: &SemVer) -> Self {
        Version {
            ver: ver.to_owned(),
        }
    }
}

#[cfg(test)]
mod tests {
    use semver::Version as SemVer;

    use super::Version;

    #[test]
    fn bumps_major_version() {
        let current = SemVer::new(1, 1, 1);
        let mut version = Version::from(&current);

        version.bump_major();

        assert_eq!(version.ver.major, 2);
        assert_eq!(version.ver.minor, 0);
        assert_eq!(version.ver.patch, 0);
    }

    #[test]
    fn bumps_minor_version() {
        let current = SemVer::new(1, 1, 1);
        let mut version = Version::from(&current);

        version.bump_minor();

        assert_eq!(version.ver.major, 1);
        assert_eq!(version.ver.minor, 2);
        assert_eq!(version.ver.patch, 0);
    }

    #[test]
    fn bumps_patch_version() {
        let current = SemVer::new(1, 1, 1);
        let mut version = Version::from(&current);

        version.bump_patch();

        assert_eq!(version.ver.major, 1);
        assert_eq!(version.ver.minor, 1);
        assert_eq!(version.ver.patch, 2);
    }
}