cargo_version_upgrade/
lib.rs1use 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 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_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 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 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 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}