v0.6.0

This replaces one dependency with a more specialized crate without any
transitive dependencies.

.github/dependabot.yml

@@ -0,0 +1,16 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"

.github/workflows/build_deb.yml

@@ -0,0 +1,19 @@
+on: workflow_dispatch
+
+name: Build packages
+
+jobs:
+  build_deb:
+    name: Build .deb package
+    runs-on: ubuntu-latest
+    env:
+      RUSTFLAGS: "-C strip=debuginfo"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo install cargo-deb
+      - run: cargo build --release
+      - run: cargo deb
+      - uses: actions/upload-artifact@v4
+        with:
+          path: target/debian/*.deb

.github/workflows/ci.yml

@@ -0,0 +1,53 @@
+on:
+  - push
+  - workflow_dispatch
+
+name: CI
+
+jobs:
+  lint_and_test:
+    name: lint and test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy, rustfmt
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo clippy --all-features -- -D warnings
+      - run: cargo check --workspace --all-features
+      - run: cargo test --all-targets
+      - run: cargo fmt --all -- --check
+
+  build_package:
+    needs: lint_and_test
+    if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/build-') }}
+    name: Build package
+    env:
+      RUSTFLAGS: "-C strip=debuginfo"
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+          # - windows-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo build --release
+      - name: prepare release artifact
+        shell: bash
+        run: |
+          mkdir -p target/{bin,man}
+          cp target/release/*.1 target/man
+          cp target/release/git-{mob,solo,{add,edit,delete}-coauthor} target/bin
+      - uses: actions/upload-artifact@v4
+        with:
+          name: git-mob-${{ matrix.os }}
+          path: |
+            target/bin
+            target/man

.travis.yml

@@ -1,8 +0,0 @@
-language: rust
-rust:
-  - stable
-  - beta
-  - nightly
-matrix:
-  allow_failures:
-    - rust: nightly

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
-name = "git_mob"
-version = "0.2.0"
-authors = ["Martin Frost <martin@frost.ws>"]
+name = "git-mob"
+version = "0.6.0"
+authors = [ "Martin Frost <martin@frost.ws>" ]
 edition = "2018"
 description = "A CLI tool for social coding."
 license = "MIT"
@@ -9,11 +9,36 @@ homepage = "https://github.com/Frost/git-mob"
 repository = "https://github.com/Frost/git-mob"
 readme = "README.md"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
-dirs = "2.0"
-git2 = "0.13"
+git2 = { version = "0.19", default-features = false }
 serde = { version =  "1.0", features = ["derive"] }
 serde_json = "1.0"
-structopt = "0.3"
+clap = { version = "~4.5", features = ["derive"] }
+clap_mangen = "~0.2"
+env_home = "0.1.0"
+
+[build-dependencies]
+clap_mangen = "~0.2"
+clap = { version = "~4.5", features = ["derive"]}
+clap_complete = "~4.5"
+
+[package.metadata.deb]
+name = "git-mob"
+revision = "1"
+section = "vcs"
+priority = "optional"
+extended-description = """\
+A set of git subcommands for including co-authors to your git commits."""
+assets = [
+    ["target/release/git-mob", "usr/bin/", "755"],
+    ["target/release/git-solo", "usr/bin/", "755"],
+    ["target/release/git-add-coauthor", "usr/bin/", "755"],
+    ["target/release/git-edit-coauthor", "usr/bin/", "755"],
+    ["target/release/git-delete-coauthor", "usr/bin/", "755"],
+    ["target/release/git-mob.1", "usr/share/man/man1/", "644"],
+    ["target/release/git-solo.1", "usr/share/man/man1/", "644"],
+    ["target/release/git-add-coauthor.1", "usr/share/man/man1/", "644"],
+    ["target/release/git-edit-coauthor.1", "usr/share/man/man1/", "644"],
+    ["target/release/git-delete-coauthor.1", "usr/share/man/man1/", "644"],
+    ["README.md", "usr/share/doc/git-mob/README", "644"],
+]

README.md

@@ -8,13 +8,43 @@ This is a CLI tool for including your co-authors in your commits.
 
 It is essentially a Rust clone of the [git-mob NPM package](https://www.npmjs.com/package/git-mob).
 
+## Install
+
+### MacOS
+
+If you have [Homebrew](https://brew.sh) installed, you can install `git-mob` using my tap:
+
+    brew install frost/tap/git-mob
+
+Otherwise, see the section on binary packages
+
+### Binary packages for MacOS, Ubuntu, and Windows
+
+Download the [latest release](https://github.com/Frost/git-mob/releases/latest) and extract it somewhere so that the binaries end up in your `$PATH`.
+
+### From source
+
+Just run `cargo install git_mob` and you should be all set.
+
+## A note on commit template and git-mob
+
+`git-mob` _will_ currently override any existing `commit.template` setting
+in any project where it is run. It does this in order to ensure that `git
+commit` will pick up your current mob.
+
+The future plan is to do something a bit smarter, like first detecting if the
+repo already has a `commit.template` setting, and in that case, modify the
+existing template by adding `Co-authored-by:` trailers to it, or something
+similar.
+
 
 ## Examples
 
-* Add Alice and Bob as a possible co-authors:
+* Add Alice, Bob, and yourself as a possible co-authors:
 
       git add-coauthor a "Alice" alice@example.com
       git add-coauthor b "bob" Bob@example.com
+      git add-coauthor me "me" myself.i@example.com
 
 * Set Alice as co-author, making your mob consist of you and Alice:
 
@@ -24,6 +54,11 @@ It is essentially a Rust clone of the [git-mob NPM package](https://www.npmjs.co
 
       git mob a b
 
+* Set Alice as the main author for any commits you make, since she is the one
+  doing most of the thinking anyway, and add yourself as a mob member:
+
+      git mob -o a b me
+
 * Edit Bob's name, since you accidentally capitalized his email instead of his name:
 
       git edit-coauthor b --name "Bob" --email bob@example.com
@@ -45,6 +80,7 @@ It is essentially a Rust clone of the [git-mob NPM package](https://www.npmjs.co
 
 * `git mob <co-author-initials>`
 * `git add-coauthor <initials> "Co-author Name" <co-author-email-address>`
+* `git -o <initials>` for overwriting the main author
 * `git edit-coauthor [--name "Co-author Name"] [--email <co-author-email-address>]`
 * `git delete-coauthor <initials>`
 * `git mob -l`
@@ -61,7 +97,6 @@ be implemented, and then there is also a severe lack of tests and documentation.
 
 * `git mob-print`
 * `git suggest-coauthors`
-* `-o` for overwriting the main author
 * `--installTemplate` and `--uninstallTemplate` for prepare-commit-msg
 
 

build.rs

@@ -0,0 +1,31 @@
+use clap::CommandFactory;
+use clap_mangen::Man;
+use std::env;
+use std::path::Path;
+
+#[path = "src/cli.rs"]
+mod cli;
+
+macro_rules! generate_manpage {
+    ($struct:ident) => {
+        let target_dir = env::var("CARGO_TARGET_DIR").unwrap_or("target".to_string());
+        let output_dir = Path::new(&target_dir).join(env::var("PROFILE").unwrap());
+
+        let cmd = cli::$struct::command();
+        let cmd_name = format!("{}.1", cmd.get_name());
+        let man = Man::new(cmd);
+        let mut buffer: Vec<u8> = Default::default();
+        man.render(&mut buffer)?;
+        std::fs::write(output_dir.join(cmd_name), buffer)?;
+    };
+}
+
+fn main() -> std::io::Result<()> {
+    generate_manpage!(GitMob);
+    generate_manpage!(GitSolo);
+    generate_manpage!(GitAddCoauthor);
+    generate_manpage!(GitEditCoauthor);
+    generate_manpage!(GitDeleteCoauthor);
+
+    Ok(())
+}

flake.lock

@@ -0,0 +1,75 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "locked": {
+        "lastModified": 1678901627,
+        "narHash": "sha256-U02riOqrKKzwjsxc/400XnElV+UtPUQWpANPlyazjH0=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "93a2b84fc4b70d9e089d029deacc3583435c2ed6",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "naersk": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1671096816,
+        "narHash": "sha256-ezQCsNgmpUHdZANDCILm3RvtO1xH8uujk/+EqNvzIOg=",
+        "owner": "nix-community",
+        "repo": "naersk",
+        "rev": "d998160d6a076cfe8f9741e56aeec7e267e3e114",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "naersk",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1670507980,
+        "narHash": "sha256-riNZa0xzM1it3pzxciwALeMs+0CsBMWIW2FqulzK8vM=",
+        "path": "/nix/store/2i8zqmz2cqa0grjagw94z7g47199db9k-source",
+        "rev": "2787fc7d1e51404678614bf0fe92fc296746eec0",
+        "type": "path"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "type": "indirect"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1678875422,
+        "narHash": "sha256-T3o6NcQPwXjxJMn2shz86Chch4ljXgZn746c2caGxd8=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "126f49a01de5b7e35a43fd43f891ecf6d3a51459",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "naersk": "naersk",
+        "nixpkgs": "nixpkgs_2"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,24 @@
+{
+  inputs = {
+    flake-utils.url = "github:numtide/flake-utils";
+    naersk.url = "github:nix-community/naersk";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+  };
+
+  outputs = { self, flake-utils, naersk, nixpkgs }:
+    {
+      overlays.default = (final: prev:
+        let naersk' = final.callPackage naersk { };
+        in { git-mob = naersk'.buildPackage { src = ./.; }; });
+    } // flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = (import nixpkgs) {
+          inherit system;
+          overlays = [ self.overlays.default ];
+        };
+      in rec {
+        defaultPackage = pkgs.git-mob;
+        devShell =
+          pkgs.mkShell { nativeBuildInputs = with pkgs; [ rustc cargo ]; };
+      });
+}

src/bin/git-add-coauthor.rs

@@ -1,23 +1,14 @@
-use git_mob::{Author, get_available_coauthors, write_coauthors_file} ;
-use structopt::StructOpt;
-
-#[derive(StructOpt,Debug)]
-struct Opt {
-    /// Co-author initials
-    initials: String,
-    /// The name of the co-author, in quotes, e.g. "Foo Bar"
-    name: String,
-    /// The email of the co-author
-    email: String,
-}
+use clap::Parser;
+use git_mob::{cli, parse_coauthors_file, write_coauthors_file, Author};
 
 fn main() {
-    let opt = Opt::from_args();
-    let mut authors = get_available_coauthors();
+    let opt = cli::GitAddCoauthor::parse();
+    let mut authors = parse_coauthors_file().unwrap_or_default();
     let new_author = Author {
         name: opt.name,
         email: opt.email,
     };
+
     authors.insert(opt.initials, new_author);
 
     write_coauthors_file(authors);

src/bin/git-delete-coauthor.rs

@@ -1,14 +1,8 @@
-use git_mob::{get_available_coauthors, write_coauthors_file} ;
-use structopt::StructOpt;
-
-#[derive(StructOpt,Debug)]
-struct Opt {
-    /// Initials of the co-author to delete
-    initials: String,
-}
+use clap::Parser;
+use git_mob::{cli, get_available_coauthors, write_coauthors_file};
 
 fn main() {
-    let opt = Opt::from_args();
+    let opt = cli::GitDeleteCoauthor::parse();
     let mut authors = get_available_coauthors();
     authors.remove(&opt.initials);
     write_coauthors_file(authors);

src/bin/git-edit-coauthor.rs

@@ -1,41 +1,22 @@
-use git_mob::{Author, get_available_coauthors, write_coauthors_file} ;
-use structopt::StructOpt;
+use clap::Parser;
+use git_mob::{cli, get_available_coauthors, write_coauthors_file, Author};
 use std::process;
 
-#[derive(StructOpt,Debug)]
-struct Opt {
-    /// Co-author initials
-    initials: String,
-    /// The name of the co-author, in quotes, e.g. "Foo Bar"
-    #[structopt(long, required_unless("email"))]
-    name: Option<String>,
-    /// The email of the co-author
-    #[structopt(long, required_unless("name"))]
-    email: Option<String>,
-}
-
 fn main() {
-    let opt = Opt::from_args();
+    let opt = cli::GitDeleteCoauthor::parse();
 
     let mut authors = get_available_coauthors();
-    let mut updated_author : Author;
 
     if let Some(author) = authors.get(&opt.initials) {
-        updated_author = author.clone();
+        let mut updated_author: Author = author.clone();
+        updated_author.name = opt.name;
+        updated_author.email = opt.email;
+
+        authors.insert(opt.initials, updated_author);
+
+        write_coauthors_file(authors);
     } else {
         eprintln!("No author found with initials {}", &opt.initials);
         process::exit(1);
-    }
-
-    if let Some(name) = opt.name {
-        updated_author.name = name;
-    }
-
-    if let Some(email) = opt.email {
-        updated_author.email = email;
-    }
-
-    authors.insert(opt.initials, updated_author);
-
-    write_coauthors_file(authors);
+    };
 }

src/bin/git-mob.rs

@@ -1,69 +1,75 @@
-use git_mob::{Author, get_main_author, get_available_coauthors, gitmessage_template_file_path, with_repo_or_exit};
-use git2::Repository;
-use structopt::StructOpt;
-use std::process;
+use clap::Parser;
+use git_mob::{
+    cli, ensure_commit_template_is_set, get_available_coauthors, get_main_author, set_main_author,
+    with_gitmessage_template_path_or_exit, Author,
+};
+use std::fmt::Write;
 use std::fs;
-
-#[derive(StructOpt,Debug)]
-struct Opt {
-    /// Prints list of available co-authors
-    #[structopt(short,long)]
-    list: bool,
-    /// A list of co-author initials
-    coauthors: Vec<String>,
-}
+use std::process;
 
 fn main() {
-    let opt = Opt::from_args();
+    let args = cli::GitMob::parse();
 
-    if opt.list {
+    if args.list {
         list_coauthors();
         process::exit(0);
     }
 
-    write_coauthors_to_gitmessage_file(&opt.coauthors);
+    if let Some(initials) = args.overwrite {
+        override_main_author(&initials);
+    }
+
+    write_coauthors_to_gitmessage_file(&args.coauthors);
+    ensure_commit_template_is_set();
 }
 
 fn list_coauthors() {
     for (abbrev, author) in &get_available_coauthors() {
-        println!("{}\t{}", abbrev, author);
+        println!("{abbrev}\t{author}");
+    }
+}
+
+fn override_main_author(initials: &str) {
+    let all_authors = get_available_coauthors();
+    match all_authors.get(initials) {
+        Some(new_main_author) => set_main_author(new_main_author),
+        None => {
+            eprintln!("Error: author with initials {initials} not found");
+            process::exit(1);
+        }
     }
 }
 
 fn write_coauthors_to_gitmessage_file(coauthor_initials: &[String]) {
-    let coauthors = select_coauthors(&coauthor_initials);
+    let coauthors = select_coauthors(coauthor_initials);
     let mut content = String::from("\n\n");
     for author in &coauthors {
-        content.push_str(&format!("Co-authored-by: {}\n", &author.to_string()));
+        _ = writeln!(content, "Co-authored-by: {}", &author.to_string());
     }
 
-    with_repo_or_exit(|repo: Repository| {
-        let path = gitmessage_template_file_path(repo);
-
-        match fs::write(path, content) {
-            Ok(_) => {
-                println!("{}", get_main_author());
-                for author in &coauthors {
-                    println!("{}", author);
-                }
-            },
-            Err(e) => {
-                eprintln!("Error writing to .gitmessage template: {}", e);
-                process::exit(1);
-            },
+    with_gitmessage_template_path_or_exit(|path| match fs::write(path, content) {
+        Ok(_) => {
+            println!("{}", get_main_author());
+            for author in &coauthors {
+                println!("{author}");
+            }
+        }
+        Err(e) => {
+            eprintln!("Error writing to .gitmessage template: {e}");
+            process::exit(1);
         }
     });
 }
 
-fn select_coauthors(coauthor_initials : &[String]) -> Vec<Author> {
+fn select_coauthors(coauthor_initials: &[String]) -> Vec<Author> {
     let all_coauthors = get_available_coauthors();
-    let mut coauthors : Vec<Author> = Vec::new();
+    let mut coauthors: Vec<Author> = Vec::new();
 
     for initial in coauthor_initials {
         match all_coauthors.get(initial) {
             Some(coauthor) => coauthors.push(coauthor.clone()),
             None => {
-                eprintln!("Error: atuhor with initials {} not found", initial);
+                eprintln!("Error: author with initials {initial} not found");
                 process::exit(1);
             }
         }

src/bin/git-solo.rs

@@ -1,13 +1,16 @@
-use git2::Repository;
+use clap::Parser;
+use git_mob::{
+    cli, ensure_commit_template_is_set, get_main_author, with_gitmessage_template_path_or_exit,
+};
 use std::fs::File;
-use git_mob::{get_main_author, gitmessage_template_file_path, with_repo_or_exit};
 
 fn main() {
+    let _opt = cli::GitSolo::parse();
     let main_author = get_main_author();
-    println!("{}", main_author);
+    println!("{main_author}");
 
-    with_repo_or_exit(|repo: Repository| {
-        let path = gitmessage_template_file_path(repo);
+    with_gitmessage_template_path_or_exit(|path| {
         let _template = File::create(path);
-    })
+    });
+    ensure_commit_template_is_set();
 }

src/cli.rs

@@ -0,0 +1,56 @@
+use clap::Parser;
+
+#[derive(Parser, Debug)]
+#[clap(version, name = "git-mob")]
+/// Assemble a group of co-authors to help you on your coding quest
+pub struct GitMob {
+    /// Prints list of available co-authors
+    #[clap(short, long)]
+    pub list: bool,
+    /// Overwrite the main author
+    #[clap(short, long)]
+    pub overwrite: Option<String>,
+    /// A list of co-author initials
+    pub coauthors: Vec<String>,
+}
+
+#[derive(Parser, Debug)]
+#[clap(name = "git-add-coauthor", version)]
+/// Add a co-author to your list of available co-authors
+pub struct GitAddCoauthor {
+    /// Co-author initials
+    pub initials: String,
+    /// The name of the co-author, in quotes, e.g. "Foo Bar"
+    pub name: String,
+    /// The email of the co-author
+    pub email: String,
+}
+
+#[derive(Parser, Debug)]
+#[clap(name = "git-edit-coauthor", version)]
+/// Edit a co-author in your list of available co-authors
+pub struct GitEditCoauthor {
+    /// Co-author initials
+    pub initials: String,
+    /// The name of the co-author, in quotes, e.g. "Foo Bar"
+    pub name: String,
+    /// The email of the co-author
+    pub email: String,
+}
+
+#[derive(Parser, Debug)]
+#[clap(name = "git-delete-coauthor", version)]
+/// Delete a co-author from your list of available co-authors
+pub struct GitDeleteCoauthor {
+    /// Co-author initials
+    pub initials: String,
+    /// The name of the co-author, in quotes, e.g. "Foo Bar"
+    pub name: String,
+    /// The email of the co-author
+    pub email: String,
+}
+
+#[derive(Parser, Debug)]
+#[clap(name = "git-solo", version)]
+/// Disband the mob and continue working solo.
+pub struct GitSolo {}

src/lib.rs

@@ -1,15 +1,17 @@
-use serde::{Deserialize, Serialize};
-use std::fs;
+use env_home::env_home_dir as home_dir;
 use git2::{Config, Repository};
-use std::fmt;
+use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
-use dirs::home_dir;
+use std::fmt;
+use std::fs;
 
-use std::io::BufReader;
-use std::fs::File;
 use std::error::Error;
-use std::string::String;
+use std::fs::File;
+use std::io::BufReader;
 use std::process;
+use std::string::String;
+
+pub mod cli;
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct Author {
@@ -24,7 +26,11 @@ impl fmt::Display for Author {
 }
 
 pub fn get_main_author() -> Author {
-    let cfg = Config::open_default().unwrap();
+    let cfg = match Repository::open_from_env() {
+        Ok(repo) => repo.config().unwrap(),
+        Err(_e) => Config::open_default().unwrap(),
+    };
+
     let name = cfg.get_entry("user.name").unwrap();
     let email = cfg.get_entry("user.email").unwrap();
 
@@ -34,36 +40,52 @@ pub fn get_main_author() -> Author {
     }
 }
 
+pub fn set_main_author(author: &Author) {
+    with_git_repo_or_exit(|repo| {
+        let mut config = repo.config().unwrap();
+        config.set_str("user.name", &author.name).unwrap();
+        config.set_str("user.email", &author.email).unwrap();
+    });
+}
+
+pub fn ensure_commit_template_is_set() {
+    with_git_repo_or_exit(|repo| {
+        let mut config = repo.config().unwrap();
+        let template_path = repo.path().join(".gitmessage");
+        if let Some(template_path) = template_path.to_str() {
+            config.set_str("commit.template", template_path).unwrap();
+        }
+    })
+}
+
 pub fn get_available_coauthors() -> BTreeMap<String, Author> {
     match parse_coauthors_file() {
         Ok(coauthors) => coauthors,
         Err(e) => {
-            eprintln!("{}", e);
+            eprintln!("{e:?}");
             BTreeMap::new()
         }
     }
 }
 
-fn parse_coauthors_file() -> Result<BTreeMap<String, Author>, Box<dyn Error>> {
+pub fn parse_coauthors_file() -> Result<BTreeMap<String, Author>, Box<dyn Error>> {
     let coauthors_path = coauthors_file_path();
     let coauthors_file = File::open(coauthors_path)?;
     let reader = BufReader::new(coauthors_file);
 
-    let json_data : serde_json::Value = serde_json::from_reader(reader)?;
+    let json_data: serde_json::Value = serde_json::from_reader(reader)?;
 
     match json_data.get("coauthors") {
         Some(coauthors) => Ok(serde_json::from_value(coauthors.clone()).unwrap()),
-        None => Ok(BTreeMap::new())
+        None => Ok(BTreeMap::new()),
     }
 }
 
-pub fn gitmessage_template_file_path(repo: Repository) -> std::path::PathBuf {
-    repo.path().join(".gitmessage")
-}
-
-pub fn with_repo_or_exit<F: FnOnce(Repository)>(f: F) {
+fn with_git_repo_or_exit<F: FnOnce(Repository)>(f: F) {
     match Repository::open_from_env() {
-        Ok(repo) => f(repo),
+        Ok(repo) => {
+            f(repo);
+        }
         Err(_e) => {
             eprintln!("Not in a git repository");
             process::exit(1);
@@ -71,14 +93,21 @@ pub fn with_repo_or_exit<F: FnOnce(Repository)>(f: F) {
     }
 }
 
+pub fn with_gitmessage_template_path_or_exit<F: FnOnce(std::path::PathBuf)>(f: F) {
+    with_git_repo_or_exit(|repo| {
+        let path = repo.path().join(".gitmessage");
+        f(path);
+    })
+}
+
 pub fn write_coauthors_file(authors: BTreeMap<String, Author>) {
     let mut wrapper_tree = BTreeMap::new();
     wrapper_tree.insert("coauthors", authors);
     let json_data = serde_json::to_string_pretty(&wrapper_tree).unwrap();
     match fs::write(coauthors_file_path(), json_data) {
-        Ok(_) => {},
+        Ok(_) => {}
         Err(e) => {
-            eprintln!("Error writing git-coauthors file: {:?}", e);
+            eprintln!("Error writing git-coauthors file: {e:?}");
             process::exit(1);
         }
     }