Skip to main content

cargo_version_upgrade/
lib.rs

1use semver::{Prerelease, Version};
2use std::error::Error;
3use std::fmt;
4use std::fs;
5use std::path::Path;
6use std::process::Command;
7use toml_edit::{DocumentMut, Item, Value};
8
9#[derive(Debug)]
10pub enum VersionUpgradeError {
11    InvalidVersionFormat,
12    InvalidIncrement,
13    FileReadError(std::io::Error),
14    FileWriteError(std::io::Error),
15    InvalidPrereleaseTag,
16    GitCommitError,
17    GitTagError,
18    BuildError,
19}
20
21impl fmt::Display for VersionUpgradeError {
22    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
23        match self {
24            VersionUpgradeError::InvalidVersionFormat => write!(f, "Invalid version format"),
25            VersionUpgradeError::InvalidIncrement => write!(f, "Invalid increment type"),
26            VersionUpgradeError::FileReadError(err) => write!(f, "Error reading file: {}", err),
27            VersionUpgradeError::FileWriteError(err) => write!(f, "Error writing file: {}", err),
28            VersionUpgradeError::InvalidPrereleaseTag => write!(f, "Invalid prerelease tag format"),
29            VersionUpgradeError::GitCommitError => write!(f, "Failed to create Git commit"),
30            VersionUpgradeError::GitTagError => write!(f, "Failed to create Git tag"),
31            VersionUpgradeError::BuildError => write!(f, "Failed to build cargo"),
32        }
33    }
34}
35
36impl Error for VersionUpgradeError {}
37
38pub fn update_version_and_commit(
39    cargo_toml_path: &Path,
40    increment: &str,
41    tag: Option<&str>,
42) -> Result<(), VersionUpgradeError> {
43    // Read and update Cargo.toml
44    let content =
45        fs::read_to_string(cargo_toml_path).map_err(VersionUpgradeError::FileReadError)?;
46    let mut doc: DocumentMut = content
47        .parse()
48        .map_err(|_| VersionUpgradeError::InvalidVersionFormat)?;
49
50    let version_str = doc["package"]["version"]
51        .as_str()
52        .ok_or(VersionUpgradeError::InvalidVersionFormat)?;
53    let version =
54        Version::parse(version_str).map_err(|_| VersionUpgradeError::InvalidVersionFormat)?;
55    let suffix = &version.pre.clone();
56
57    let incremented_version = match increment {
58        "patch" => increment_version(version, IncrementType::Patch, tag, suffix),
59        "minor" => increment_version(version, IncrementType::Minor, tag, suffix),
60        "major" => increment_version(version, IncrementType::Major, tag, suffix),
61        "pre" => increment_version(version, IncrementType::Pre, tag, suffix),
62        _ => return Err(VersionUpgradeError::InvalidIncrement),
63    }?;
64
65    doc["package"]["version"] = Item::from(Value::from(incremented_version.to_string()));
66    fs::write(cargo_toml_path, doc.to_string()).map_err(VersionUpgradeError::FileWriteError)?;
67
68    // Commit the changes and create a Git tag
69    commit_and_tag(&incremented_version)?;
70    Ok(())
71}
72
73#[derive(Debug)]
74enum IncrementType {
75    Patch,
76    Minor,
77    Major,
78    Pre,
79}
80
81fn increment_version(
82    mut version: Version,
83    increment_type: IncrementType,
84    tag: Option<&str>,
85    suffix: &Prerelease,
86) -> Result<Version, VersionUpgradeError> {
87    /*
88     * patch (0.0.4 -> 0.0.5)
89     * patch --tags <name> (0.0.4 -> 0.0.5-tagname.0 , 0.0.5-tagname.0 -> 0.0.6-tagname.0)
90     * minor (0.0.4 -> 0.1.4)
91     * minor --tags <name> (0.0.4 -> 0.1.0-tagname.0 , 0.0.4-tagname.0 -> 0.1.0-tagname.0)
92     * major (0.0.4 -> 0.0.5)
93     * major --tags <name> (0.0.4 -> 1.0.0-tagname.0 , 0.0.4-tagname.0 -> 1.0.0-tagname.0)
94     * pre (0.0.4 -> err msg, 0.0.4-tagname.0 -> 0.0.4-tagname.1, 0.4.4-tagname.4 -> 0.4.4-tagname.5)
95     */
96    fn set_prerelease(tag: &Option<&str>, version: &mut Version) {
97        if let Some(tag) = tag {
98            let pr = format!("{}.0", tag);
99            version.pre = Prerelease::new(&pr).unwrap();
100        } else {
101            version.pre = Prerelease::EMPTY;
102        }
103    }
104
105    match increment_type {
106        IncrementType::Patch => {
107            version.patch += 1;
108            set_prerelease(&tag, &mut version);
109        }
110        IncrementType::Minor => {
111            version.minor += 1;
112            version.patch = 0;
113            set_prerelease(&tag, &mut version);
114        }
115        IncrementType::Major => {
116            version.major += 1;
117            version.minor = 0;
118            version.patch = 0;
119            set_prerelease(&tag, &mut version);
120        }
121        IncrementType::Pre => {
122            let mut prerelease = suffix.as_str().to_string();
123            let parts: Vec<_> = prerelease.split('.').collect();
124            let mut parts2 = parts.clone();
125            if let Some(last) = parts.last() {
126                parts2.pop();
127                let tag_ref = parts2.join(".");
128                prerelease = match last.parse::<u32>() {
129                    Ok(num) => format!("{}.{}", tag_ref, num + 1),
130                    Err(_) => return Err(VersionUpgradeError::InvalidPrereleaseTag),
131                };
132            }
133            version.pre = Prerelease::new(&prerelease).unwrap();
134        }
135    }
136    Ok(version)
137}
138
139fn commit_and_tag(version: &Version) -> Result<(), VersionUpgradeError> {
140    let version_str = version.to_string();
141
142    let build_output = Command::new("cargo")
143        .arg("build")
144        .output()
145        .map_err(|_| VersionUpgradeError::BuildError)?;
146
147    if !build_output.status.success() {
148        return Err(VersionUpgradeError::BuildError);
149    }
150
151    // Commit the changes
152    let commit_message = format!("v{}", version_str);
153    let commit_output = Command::new("git")
154        .arg("commit")
155        .arg("-am")
156        .arg(&commit_message)
157        .output()
158        .map_err(|_| VersionUpgradeError::GitCommitError)?;
159
160    if !commit_output.status.success() {
161        return Err(VersionUpgradeError::GitCommitError);
162    }
163
164    // Create the git tag
165    let tag_output = Command::new("git")
166        .arg("tag")
167        .arg(&version_str)
168        .output()
169        .map_err(|_| VersionUpgradeError::GitTagError)?;
170
171    if !tag_output.status.success() {
172        return Err(VersionUpgradeError::GitTagError);
173    }
174
175    println!("Git commit and tag '{}' created successfully", version_str);
176    Ok(())
177}