semver_bump_trait/lib.rs
1#![doc = include_str!("../README.md")]
2
3use semver::BuildMetadata;
4use semver::Prerelease;
5use semver::Version;
6
7/// Trait for incrementing parts of a semver version
8pub trait SemverBump {
9 /// Increment the major version, resetting minor, patch, pre, and build.
10 /// # Example
11 /// ```
12 /// use semver::Version;
13 /// use semver_bump_trait::SemverBump;
14 /// let mut version = Version::parse("1.2.3").unwrap();
15 /// version.mut_increment_major();
16 /// assert_eq!(version.to_string(), "2.0.0");
17 /// ```
18 fn mut_increment_major(&mut self);
19
20 /// Increment the minor version, resetting patch, pre, and build.
21 /// # Example
22 /// ```
23 /// use semver::Version;
24 /// use semver_bump_trait::SemverBump;
25 /// let mut version = Version::parse("1.2.3").unwrap();
26 /// version.mut_increment_minor();
27 /// assert_eq!(version.to_string(), "1.3.0");
28 /// ```
29 fn mut_increment_minor(&mut self);
30
31 /// Increment the patch version, resetting pre, and build.
32 /// # Example
33 /// ```
34 /// use semver::Version;
35 /// use semver_bump_trait::SemverBump;
36 /// let mut version = Version::parse("1.2.3").unwrap();
37 /// version.mut_increment_patch();
38 /// assert_eq!(version.to_string(), "1.2.4");
39 /// ```
40 fn mut_increment_patch(&mut self);
41
42 /// Set the major version to `major` without affecting other fields.
43 /// # Example
44 /// ```
45 /// use semver::Version;
46 /// use semver_bump_trait::SemverBump;
47 /// let mut version = Version::parse("1.2.3").unwrap();
48 /// version.mut_set_major(3);
49 /// assert_eq!(version.to_string(), "3.2.3");
50 /// ```
51 fn mut_set_major(&mut self, major: u64);
52
53 /// Set the minor version to `minor` without affecting other fields.
54 /// # Example
55 /// ```
56 /// use semver::Version;
57 /// use semver_bump_trait::SemverBump;
58 /// let mut version = Version::parse("1.2.3").unwrap();
59 /// version.mut_set_minor(4);
60 /// assert_eq!(version.to_string(), "1.4.3");
61 /// ```
62 fn mut_set_minor(&mut self, minor: u64);
63
64 /// Set the patch version to `patch` without affecting other fields.
65 /// Set the patch version to `patch`, resetting pre, and build.
66 /// # Example
67 /// ```
68 /// use semver::Version;
69 /// use semver_bump_trait::SemverBump;
70 /// let mut version = Version::parse("1.2.3").unwrap();
71 /// version.mut_set_patch(5);
72 /// assert_eq!(version.to_string(), "1.2.5");
73 /// ```
74 fn mut_set_patch(&mut self, patch: u64);
75
76 /// Set the prerelease version to `pre` without affecting other fields.
77 /// # Example
78 /// ```
79 /// use semver::{Version, Prerelease};
80 /// use semver_bump_trait::SemverBump;
81 /// let mut version = Version::parse("1.2.3").unwrap();
82 /// version.mut_set_pre(Prerelease::new("beta.1").unwrap());
83 /// assert_eq!(version.to_string(), "1.2.3-beta.1");
84 /// ```
85 fn mut_set_pre(&mut self, pre: Prerelease);
86
87 /// Set the build version to `build` without affecting other fields.
88 /// # Example
89 /// ```
90 /// use semver::{Version, BuildMetadata};
91 /// use semver_bump_trait::SemverBump;
92 /// let mut version = Version::parse("1.2.3").unwrap();
93 /// version.mut_set_build(BuildMetadata::new("build.456").unwrap());
94 /// assert_eq!(version.to_string(), "1.2.3+build.456");
95 /// ```
96 fn mut_set_build(&mut self, build: BuildMetadata);
97
98 /// Increment the major version, resetting minor, patch, pre, and build.
99 /// # Example
100 /// ```
101 /// use semver::Version;
102 /// use semver_bump_trait::SemverBump;
103 /// let version = Version::parse("1.2.3").unwrap();
104 /// let new_version = version.increment_major();
105 /// assert_eq!(new_version.to_string(), "2.0.0");
106 /// ```
107 fn increment_major(&self) -> Self;
108
109 /// Increment the minor version, resetting patch, pre, and build.
110 /// # Example
111 /// ```
112 /// use semver::Version;
113 /// use semver_bump_trait::SemverBump;
114 /// let version = Version::parse("1.2.3").unwrap();
115 /// let new_version = version.increment_minor();
116 /// assert_eq!(new_version.to_string(), "1.3.0");
117 /// ```
118 fn increment_minor(&self) -> Self;
119
120 /// Increment the patch version, resetting pre, and build.
121 /// # Example
122 /// ```
123 /// use semver::Version;
124 /// use semver_bump_trait::SemverBump;
125 /// let version = Version::parse("1.2.3").unwrap();
126 /// let new_version = version.increment_patch();
127 /// assert_eq!(new_version.to_string(), "1.2.4");
128 /// ```
129 fn increment_patch(&self) -> Self;
130
131 /// Set the major version to `major` without affecting other fields.
132 /// # Example
133 /// ```
134 /// use semver::Version;
135 /// use semver_bump_trait::SemverBump;
136 /// let version = Version::parse("1.2.3").unwrap();
137 /// let new_version = version.set_major(2);
138 /// assert_eq!(new_version.to_string(), "2.2.3");
139 /// ```
140 fn set_major(&self, major: u64) -> Self;
141
142 /// Set the minor version to `minor` without affecting other fields.
143 /// # Example
144 /// ```
145 /// use semver::Version;
146 /// use semver_bump_trait::SemverBump;
147 /// let version = Version::parse("1.2.3").unwrap();
148 /// let new_version = version.set_minor(5);
149 /// assert_eq!(new_version.to_string(), "1.5.3");
150 /// ```
151 fn set_minor(&self, minor: u64) -> Self;
152
153 /// Set the patch version to `patch` without affecting other fields.
154 /// # Example
155 /// ```
156 /// use semver::Version;
157 /// use semver_bump_trait::SemverBump;
158 /// let version = Version::parse("1.2.3").unwrap();
159 /// let new_version = version.set_patch(7);
160 /// assert_eq!(new_version.to_string(), "1.2.7");
161 /// ```
162 fn set_patch(&self, patch: u64) -> Self;
163
164 /// Set the prerelease version to `pre` without affecting other fields.
165 /// # Example
166 /// ```
167 /// use semver::{Version, Prerelease};
168 /// use semver_bump_trait::SemverBump;
169 /// let version = Version::parse("1.2.3").unwrap();
170 /// let new_version = version.set_pre(Prerelease::new("alpha.2").unwrap());
171 /// assert_eq!(new_version.to_string(), "1.2.3-alpha.2");
172 /// ```
173 fn set_pre(&self, pre: Prerelease) -> Self;
174
175 /// Set the build version to `build` without affecting other fields.
176 /// # Example
177 /// ```
178 /// use semver::{Version, BuildMetadata};
179 /// use semver_bump_trait::SemverBump;
180 /// let version = Version::parse("1.2.3-alpha.2").unwrap();
181 /// let new_version = version.set_build(BuildMetadata::new("build.789").unwrap());
182 /// assert_eq!(new_version.to_string(), "1.2.3-alpha.2+build.789");
183 /// ```
184 fn set_build(&self, build: BuildMetadata) -> Self;
185}
186
187impl SemverBump for Version {
188 /// Increment the major version
189 fn mut_increment_major(&mut self) {
190 self.major += 1;
191 self.minor = 0;
192 self.patch = 0;
193 self.pre = Prerelease::EMPTY;
194 self.build = BuildMetadata::EMPTY;
195 }
196
197 /// Increment the minor version
198 fn mut_increment_minor(&mut self) {
199 self.minor += 1;
200 self.patch = 0;
201 self.pre = Prerelease::EMPTY;
202 self.build = BuildMetadata::EMPTY;
203 }
204
205 /// Increment the patch version
206 fn mut_increment_patch(&mut self) {
207 self.patch += 1;
208 self.pre = Prerelease::EMPTY;
209 self.build = BuildMetadata::EMPTY;
210 }
211
212 /// Set the major version to this value
213 fn mut_set_major(&mut self, major: u64) {
214 self.major = major;
215 }
216
217 /// Set the minor version to this value
218 fn mut_set_minor(&mut self, minor: u64) {
219 self.minor = minor;
220 }
221
222 /// Set the patch version to this value
223 fn mut_set_patch(&mut self, patch: u64) {
224 self.patch = patch;
225 }
226
227 /// Set the prerelease version to this value
228 fn mut_set_pre(&mut self, pre: Prerelease) {
229 self.pre = pre;
230 }
231
232 /// Set the build version to this value
233 fn mut_set_build(&mut self, build: BuildMetadata) {
234 self.build = build;
235 }
236
237 /// Increment the major version
238 fn increment_major(&self) -> Self {
239 Version {
240 major: self.major + 1,
241 minor: 0,
242 patch: 0,
243 pre: Prerelease::EMPTY,
244 build: BuildMetadata::EMPTY,
245 }
246 }
247
248 /// Increment the minor version
249 fn increment_minor(&self) -> Self {
250 Version {
251 major: self.major,
252 minor: self.minor + 1,
253 patch: 0,
254 pre: Prerelease::EMPTY,
255 build: BuildMetadata::EMPTY,
256 }
257 }
258
259 /// Increment the patch version
260 fn increment_patch(&self) -> Self {
261 Version {
262 major: self.major,
263 minor: self.minor,
264 patch: self.patch + 1,
265 pre: Prerelease::EMPTY,
266 build: BuildMetadata::EMPTY,
267 }
268 }
269
270 /// Set the major version to this value
271 fn set_major(&self, major: u64) -> Self {
272 Version {
273 major,
274 minor: self.minor,
275 patch: self.patch,
276 pre: self.pre.clone(),
277 build: self.build.clone(),
278 }
279 }
280
281 /// Set the minor version to this value
282 fn set_minor(&self, minor: u64) -> Self {
283 Version {
284 major: self.major,
285 minor,
286 patch: self.patch,
287 pre: self.pre.clone(),
288 build: self.build.clone(),
289 }
290 }
291
292 /// Set the patch version to this value
293 fn set_patch(&self, patch: u64) -> Self {
294 Version {
295 major: self.major,
296 minor: self.minor,
297 patch,
298 pre: self.pre.clone(),
299 build: self.build.clone(),
300 }
301 }
302
303 /// Set the prerelease version to this value
304 fn set_pre(&self, pre: Prerelease) -> Self {
305 Version {
306 major: self.major,
307 minor: self.minor,
308 patch: self.patch,
309 pre,
310 build: self.build.clone(),
311 }
312 }
313
314 /// Set the build version to this value
315 fn set_build(&self, build: BuildMetadata) -> Self {
316 Version {
317 major: self.major,
318 minor: self.minor,
319 patch: self.patch,
320 pre: self.pre.clone(),
321 build,
322 }
323 }
324}
325
326#[cfg(test)]
327mod tests {
328 use super::*;
329
330 #[test]
331 fn test_increment_major() {
332 let mut version = Version::parse("1.2.3").unwrap();
333 version.mut_increment_major();
334 assert_eq!(version.to_string(), "2.0.0");
335 }
336
337 #[test]
338 fn test_increment_minor() {
339 let mut version = Version::parse("1.2.3").unwrap();
340 version.mut_increment_minor();
341 assert_eq!(version.to_string(), "1.3.0");
342 }
343
344 #[test]
345 fn test_increment_patch() {
346 let mut version = Version::parse("1.2.3").unwrap();
347 version.mut_increment_patch();
348 assert_eq!(version.to_string(), "1.2.4");
349 }
350
351 #[test]
352 fn test_set_major() {
353 let mut version = Version::parse("1.2.3").unwrap();
354 version.mut_set_major(4);
355 assert_eq!(version.to_string(), "4.2.3");
356 }
357
358 #[test]
359 fn test_set_minor() {
360 let mut version = Version::parse("1.2.3").unwrap();
361 version.mut_set_minor(4);
362 assert_eq!(version.to_string(), "1.4.3");
363 }
364
365 #[test]
366 fn test_set_patch() {
367 let mut version = Version::parse("1.2.3").unwrap();
368 version.mut_set_patch(4);
369 assert_eq!(version.to_string(), "1.2.4");
370 }
371
372 #[test]
373 fn test_set_pre() {
374 let mut version = Version::parse("1.2.3").unwrap();
375 version.mut_set_pre(Prerelease::new("alpha.1").unwrap());
376 assert_eq!(version.to_string(), "1.2.3-alpha.1");
377 }
378
379 #[test]
380 fn test_set_build() {
381 let mut version = Version::parse("1.2.3").unwrap();
382 version.mut_set_build(BuildMetadata::new("build.1").unwrap());
383 assert_eq!(version.to_string(), "1.2.3+build.1");
384 }
385
386 #[test]
387 fn test_increment_major_immutable() {
388 let version = Version::parse("1.2.3").unwrap();
389 assert_eq!(version.increment_major().to_string(), "2.0.0");
390 }
391
392 #[test]
393 fn test_increment_minor_immutable() {
394 let version = Version::parse("1.2.3").unwrap();
395 assert_eq!(version.increment_minor().to_string(), "1.3.0");
396 }
397
398 #[test]
399 fn test_increment_patch_immutable() {
400 let version = Version::parse("1.2.3").unwrap();
401 assert_eq!(version.increment_patch().to_string(), "1.2.4");
402 }
403
404 #[test]
405 fn test_set_major_immutable() {
406 let version = Version::parse("1.2.3").unwrap();
407 assert_eq!(version.set_major(4).to_string(), "4.2.3");
408 }
409
410 #[test]
411 fn test_set_minor_immutable() {
412 let version = Version::parse("1.2.3").unwrap();
413 assert_eq!(version.set_minor(4).to_string(), "1.4.3");
414 }
415
416 #[test]
417 fn test_set_patch_immutable() {
418 let version = Version::parse("1.2.3").unwrap();
419 assert_eq!(version.set_patch(4).to_string(), "1.2.4");
420 }
421
422 #[test]
423 fn test_set_pre_immutable() {
424 let version = Version::parse("1.2.3").unwrap();
425 assert_eq!(
426 version
427 .set_pre(Prerelease::new("alpha.1").unwrap())
428 .to_string(),
429 "1.2.3-alpha.1"
430 );
431 }
432
433 #[test]
434 fn test_set_build_immutable() {
435 let version = Version::parse("1.2.3").unwrap();
436 assert_eq!(
437 version
438 .set_build(BuildMetadata::new("build.1").unwrap())
439 .to_string(),
440 "1.2.3+build.1"
441 );
442 }
443}