feat(version): allows bumping a prerelease version

When prerelease is given as a parameter with the value 'beta', the
version would look like: x.y.z-beta.1

Fixes: convco#90

Signed-off-by: Jan van den Berg <koozz@linux.com>

Cargo.toml

@@ -37,6 +37,7 @@ walkdir = "2.3.2"
 [build-dependencies]
 clap = { version = "4.0.26", features = ["derive"] }
 clap_complete = "4.0.5"
+semver = "1.0.14"
 
 [package.metadata.deb]
 depends = ""

src/cli.rs

@@ -1,6 +1,7 @@
 use std::{path::PathBuf, str::FromStr};
 
 use clap::Parser;
+use semver::Prerelease;
 
 #[derive(Debug, Parser)]
 #[clap(name = "convco", about = "Conventional commit tools", version)]
@@ -58,6 +59,9 @@ pub struct VersionCommand {
     /// Bump to a patch release version, regardless of the conventional commits
     #[clap(long)]
     pub patch: bool,
+    /// Suffix with a prerelease version. Requires --bump.
+    #[clap(long, requires = "bump", default_value_t = Prerelease::new("").unwrap())]
+    pub prerelease: Prerelease,
     /// Only commits that update those <paths> will be taken into account. It is useful to support monorepos.
     #[clap(short = 'P', long)]
     pub paths: Vec<PathBuf>,

src/cmd/version.rs

@@ -12,14 +12,16 @@ use crate::{
 };
 
 enum Label {
-    /// Bump minor version (0.1.0 -> 1.0.0)
+    /// Bump major version (0.1.0 -> 1.0.0)
     Major,
     /// Bump minor version (0.1.0 -> 0.2.0)
     Minor,
-    /// Bump the patch field (0.1.0 -> 0.1.1)
+    /// Bump patch version (0.1.0 -> 0.1.1)
     Patch,
     /// Remove the pre-release extension; if any (0.1.0-dev.1 -> 0.1.0, 0.1.0 -> 0.1.0)
     Release,
+    /// Output a pre-release version
+    Prerelease,
 }
 
 impl fmt::Display for Label {
@@ -29,6 +31,7 @@ impl fmt::Display for Label {
             Self::Minor => write!(f, "minor"),
             Self::Patch => write!(f, "patch"),
             Self::Release => write!(f, "release"),
+            Self::Prerelease => write!(f, "prerelease"),
         }
     }
 }
@@ -105,6 +108,9 @@ impl VersionCommand {
             // TODO what should be the behaviour? always increment patch? or stay on same version?
             _ => Label::Release,
         };
+        if !self.prerelease.is_empty() {
+            last_version.increment_prerelease(&self.prerelease);
+        }
         Ok((last_version.0, label))
     }
 
@@ -121,9 +127,14 @@ impl VersionCommand {
                 (version.0, Label::Patch)
             } else if self.bump {
                 if version.is_prerelease() {
-                    version.pre_clear();
-                    version.build_clear();
-                    (version.0, Label::Release)
+                    if self.prerelease.is_empty() {
+                        version.pre_clear();
+                        version.build_clear();
+                        (version.0, Label::Release)
+                    } else {
+                        version.increment_prerelease(&self.prerelease);
+                        (version.0, Label::Prerelease)
+                    }
                 } else {
                     let parser = CommitParser::builder().scope_regex(scope_regex).build();
                     self.find_bump_version(tag.as_str(), version, &parser)?

src/semver.rs

@@ -49,6 +49,21 @@ impl SemVer {
         self.0.pre = Prerelease::EMPTY
     }
 
+    pub fn increment_prerelease(&mut self, prerelease: &Prerelease) {
+        if self.0.pre.is_empty() {
+            self.0.pre = Prerelease::new(format!("{prerelease}.1").as_str()).unwrap();
+        } else {
+            let next = self
+                .0
+                .pre
+                .split_once('.')
+                .and_then(|(_, number)| number.parse::<u64>().ok())
+                .unwrap_or_default()
+                + 1;
+            self.0.pre = Prerelease::new(format!("{prerelease}.{next}").as_str()).unwrap();
+        }
+    }
+
     pub fn build_clear(&mut self) {
         self.0.build = BuildMetadata::EMPTY
     }