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>

src/cli.rs

@@ -58,6 +58,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. Only works in combination with bump
+    #[clap(long, default_value = "")]
+    pub prerelease: String,
     /// 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,20 @@ impl SemVer {
         self.0.pre = Prerelease::EMPTY
     }
 
+    pub fn increment_prerelease(&mut self, prerelease: &str) {
+        if self.0.pre.is_empty() {
+            self.0.pre = Prerelease::new(format!("{prerelease}.1").as_str()).unwrap();
+        } else {
+            self.0.pre = match self.0.pre.as_str().split_once(".") {
+                Some((_, number)) => {
+                    let next = number.parse::<u64>().unwrap_or_default() + 1;
+                    Prerelease::new(format!("{prerelease}.{next}").as_str()).unwrap()
+                }
+                None => Prerelease::new(format!("{prerelease}.1").as_str()).unwrap(),
+            };
+        }
+    }
+
     pub fn build_clear(&mut self) {
         self.0.build = BuildMetadata::EMPTY
     }