From e1d3132ace342716c20f32737a514abaa0132550 Mon Sep 17 00:00:00 2001
From: Lars Wirzenius <liw@liw.fi>
Date: Sun, 4 Apr 2021 15:05:00 +0300
Subject: feat: commit changes made by Bumper

The git tag then points at that commit.
---
 src/bin/bumper.rs |  4 +++-
 src/errors.rs     | 15 ++++-----------
 src/git.rs        | 39 ++++++++++++++++++++++++---------------
 3 files changed, 31 insertions(+), 27 deletions(-)

(limited to 'src')

diff --git a/src/bin/bumper.rs b/src/bin/bumper.rs
index 08242ed..b2e9f68 100644
--- a/src/bin/bumper.rs
+++ b/src/bin/bumper.rs
@@ -21,7 +21,9 @@ fn bumper() -> Result<(), BumperError> {
         kind.set_version(&opt.version)?;
     }
 
-    git::tag(&opt.version)?;
+    let msg = format!("Set version to {}", opt.version);
+    git::commit(".", &msg)?;
+    git::tag(".", &opt.version)?;
     info!("Bumper ends OK");
     Ok(())
 }
diff --git a/src/errors.rs b/src/errors.rs
index 3eb8605..6ea498d 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -32,11 +32,11 @@ pub enum BumperError {
     #[error("Couldn't turn {0} into an absolute path: {1}")]
     AbsPath(PathBuf, #[source] std::io::Error),
 
-    #[error("Failed to run git: {0}")]
-    GitInvoke(#[source] std::io::Error),
+    #[error("Failed to run git {1:?} in {0}: {2}")]
+    GitInvoke(PathBuf, Vec<String>, #[source] std::io::Error),
 
-    #[error("Command 'git tag' failed: {0}")]
-    GitTag(String),
+    #[error("git {1:?} failed in {0}: {2}")]
+    Git(PathBuf, Vec<String>, String),
 
     #[error("Failed to run dch in {0}: {1}")]
     DchInvoke(PathBuf, #[source] std::io::Error),
@@ -44,10 +44,3 @@ pub enum BumperError {
     #[error("dch failed in {0}: {1}")]
     Dch(PathBuf, String),
 }
-
-impl BumperError {
-    pub fn git_tag(stderr: &[u8]) -> Self {
-        let stderr = String::from_utf8_lossy(stderr).into_owned();
-        Self::GitTag(stderr)
-    }
-}
diff --git a/src/git.rs b/src/git.rs
index 38e99d9..563afa1 100644
--- a/src/git.rs
+++ b/src/git.rs
@@ -1,26 +1,35 @@
 use crate::errors::BumperError;
 use log::{debug, info};
+use std::path::Path;
 use std::process::Command;
 
-pub fn tag(version: &str) -> Result<(), BumperError> {
-    debug!("git tag in {}", std::env::current_dir().unwrap().display());
+pub fn tag<P: AsRef<Path>>(dirname: P, version: &str) -> Result<(), BumperError> {
+    let msg = format!("release version {}", version);
     let tag_name = format!("v{}", version);
-    info!("Create git tag {}", tag_name);
+    git(dirname.as_ref(), &["tag", "-am", &msg, &tag_name])?;
+    Ok(())
+}
+
+pub fn commit<P: AsRef<Path>>(dirname: P, msg: &str) -> Result<(), BumperError> {
+    git(dirname.as_ref(), &["commit", "-am", msg])?;
+    Ok(())
+}
+
+fn git(dirname: &Path, args: &[&str]) -> Result<(), BumperError> {
+    info!("git {:?} in {}", args, dirname.display());
     let output = Command::new("git")
-        .arg("tag")
-        .arg("-am")
-        .arg(format!("release version {}", version))
-        .arg(format!("v{}", version))
-        .output();
-    let output = match output {
-        Ok(output) => output,
-        Err(err) => {
-            return Err(BumperError::GitInvoke(err));
-        }
-    };
+        .args(args)
+        .current_dir(dirname)
+        .output()
+        .map_err(|err| {
+            let args = args.iter().map(|s| s.to_string()).collect();
+            BumperError::GitInvoke(dirname.to_path_buf(), args, err)
+        })?;
     debug!("git exit code was {:?}", output.status.code());
     if !output.status.success() {
-        return Err(BumperError::git_tag(&output.stderr));
+        let args = args.iter().map(|s| s.to_string()).collect();
+        let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
+        return Err(BumperError::Git(dirname.to_path_buf(), args, stderr));
     }
     Ok(())
 }
-- 
cgit v1.2.1