feat(version): display commit-sha of the version

Print out the commit sha of the version when running `convco version --commit-sha`

Refs: #156

src/cli.rs

@@ -65,6 +65,9 @@ pub struct VersionCommand {
     /// Only commits that update those <paths> will be taken into account. It is useful to support monorepos.
     #[clap(short = 'P', long, env = "CONVCO_PATHS")]
     pub paths: Vec<PathBuf>,
+    /// Print the commit-sha of the version instead of the semantic version
+    #[clap(long)]
+    pub commit_sha: bool,
 }
 
 #[derive(Debug, Parser)]

src/cmd/version.rs

@@ -59,7 +59,7 @@ impl VersionCommand {
         last_v_tag: &str,
         mut last_version: SemVer,
         parser: &CommitParser,
-    ) -> Result<(Version, Label), Error> {
+    ) -> Result<(Version, Label, String), Error> {
         let prefix = self.prefix.as_str();
         let git = GitHelper::new(prefix)?;
         let mut revwalk = git.revwalk()?;
@@ -68,15 +68,24 @@ impl VersionCommand {
             .flatten()
             .filter_map(|oid| git.find_commit(oid).ok())
             .filter(|commit| git.commit_updates_any_path(commit, &self.paths))
-            .filter_map(|commit| commit.message().and_then(|msg| parser.parse(msg).ok()));
+            .filter_map(|commit| {
+                let commit_sha = commit.id().to_string();
+
+                commit
+                    .message()
+                    .and_then(|msg| parser.parse(msg).map(|c| (commit_sha, c)).ok())
+            });
 
         let mut major = false;
         let mut minor = false;
         let mut patch = false;
 
         let major_version_zero = last_version.major() == 0;
-
-        for commit in i {
+        let mut commit_sha = None;
+        for (sha, commit) in i {
+            if commit_sha.is_none() {
+                commit_sha = Some(sha);
+            }
             if commit.is_breaking() {
                 if major_version_zero {
                     minor = true;
@@ -111,33 +120,38 @@ impl VersionCommand {
         if !self.prerelease.is_empty() {
             last_version.increment_prerelease(&self.prerelease);
         }
-        Ok((last_version.0, label))
+        Ok((last_version.0, label, commit_sha.unwrap_or_default()))
     }
 
     fn get_version(
         &self,
         scope_regex: String,
         strip_regex: String,
-    ) -> Result<(Version, Label), Error> {
-        if let Some(VersionAndTag { tag, mut version }) = self.find_last_version()? {
+    ) -> Result<(Version, Label, String), Error> {
+        if let Some(VersionAndTag {
+            tag,
+            mut version,
+            commit_sha,
+        }) = self.find_last_version()?
+        {
             let v = if self.major {
                 version.increment_major();
-                (version.0, Label::Major)
+                (version.0, Label::Major, commit_sha)
             } else if self.minor {
                 version.increment_minor();
-                (version.0, Label::Minor)
+                (version.0, Label::Minor, commit_sha)
             } else if self.patch {
                 version.increment_patch();
-                (version.0, Label::Patch)
+                (version.0, Label::Patch, commit_sha)
             } else if self.bump {
                 if version.is_prerelease() {
                     if self.prerelease.is_empty() {
                         version.pre_clear();
                         version.build_clear();
-                        (version.0, Label::Release)
+                        (version.0, Label::Release, commit_sha)
                     } else {
                         version.increment_prerelease(&self.prerelease);
-                        (version.0, Label::Prerelease)
+                        (version.0, Label::Prerelease, commit_sha)
                     }
                 } else {
                     let parser = CommitParser::builder()
@@ -147,26 +161,35 @@ impl VersionCommand {
                     self.find_bump_version(tag.as_str(), version, &parser)?
                 }
             } else {
-                (version.0, Label::Release)
+                (version.0, Label::Release, commit_sha)
             };
             Ok(v)
-        } else if self.bump || self.minor {
-            Ok(("0.1.0".parse()?, Label::Minor))
-        } else if self.major {
-            Ok(("1.0.0".parse()?, Label::Major))
-        } else if self.patch {
-            Ok(("0.0.1".parse()?, Label::Patch))
         } else {
-            Ok(("0.0.0".parse()?, Label::Patch))
+            let prefix = self.prefix.as_str();
+            let git = GitHelper::new(prefix)?;
+            let commit_sha = git.ref_to_commit(&self.rev)?;
+            let commit_sha = commit_sha.id().to_string();
+            if self.bump || self.minor {
+                Ok(("0.1.0".parse()?, Label::Minor, commit_sha))
+            } else if self.major {
+                Ok(("1.0.0".parse()?, Label::Major, commit_sha))
+            } else if self.patch {
+                Ok(("0.0.1".parse()?, Label::Patch, commit_sha))
+            } else {
+                Ok(("0.0.0".parse()?, Label::Patch, commit_sha))
+            }
         }
     }
 }
 
 impl Command for VersionCommand {
     fn exec(&self, config: Config) -> anyhow::Result<()> {
-        let (version, label) = self.get_version(config.scope_regex, config.strip_regex)?;
+        let (version, label, commit_sha) =
+            self.get_version(config.scope_regex, config.strip_regex)?;
         if self.label {
             println!("{label}");
+        } else if self.commit_sha {
+            println!("{commit_sha}");
         } else {
             println!("{version}");
         }

src/git.rs

@@ -15,6 +15,7 @@ pub(crate) struct GitHelper {
 pub(crate) struct VersionAndTag {
     pub(crate) tag: String,
     pub(crate) version: SemVer,
+    pub(crate) commit_sha: String,
 }
 
 impl Eq for VersionAndTag {}
@@ -143,6 +144,7 @@ fn make_oid_version_map(repo: &Repository, prefix: &str) -> HashMap<Oid, Version
                     VersionAndTag {
                         tag: tag.to_owned(),
                         version: SemVer(version),
+                        commit_sha: oid.to_string(),
                     },
                 );
             }