feat: Stupid version tests

Introduce a mechanism to gather, cache, and test the git executable version
when running subordinate git commands. This used to determine whether the
--3way option to `git apply` may be used in conjunction with `--cached`.

Getting the git version is relatively inexpensive compared to other git
commands, but does involve the overhead of running a subordinate process.
This overhead is mitigated by caching the git executable version in the
StupidContext. The runtime performance impact from this approach appears
minimal.

Fixes: #225

Author: jpgrayson

src/stupid/mod.rs

@@ -20,8 +20,10 @@ mod command;
 pub(crate) mod diff;
 mod oid;
 pub(crate) mod status;
+mod version;
 
 use std::{
+    cell::RefCell,
     ffi::{OsStr, OsString},
     io::Write,
     path::Path,
@@ -36,6 +38,7 @@ use self::{
     diff::DiffFiles,
     oid::parse_oid,
     status::{StatusOptions, Statuses},
+    version::StupidVersion,
 };
 use crate::signature::TimeExtended;
 
@@ -50,6 +53,7 @@ impl<'repo, 'index> Stupid<'repo, 'index> for git2::Repository {
             git_dir: Some(self.path()),
             work_dir: self.workdir(),
             index_path: None,
+            git_version: RefCell::new(None::<StupidVersion>),
         }
     }
 }
@@ -60,6 +64,7 @@ pub(crate) struct StupidContext<'repo, 'index> {
     pub git_dir: Option<&'repo Path>,
     pub index_path: Option<&'index Path>,
     pub work_dir: Option<&'repo Path>,
+    git_version: RefCell<Option<StupidVersion>>,
 }
 
 impl<'repo, 'index> StupidContext<'repo, 'index> {
@@ -85,6 +90,7 @@ impl<'repo, 'index> StupidContext<'repo, 'index> {
             git_dir: self.git_dir,
             index_path: Some(index_tempfile.path()),
             work_dir: self.work_dir,
+            git_version: RefCell::new(None),
         };
 
         f(&stupid_temp)
@@ -107,6 +113,18 @@ impl<'repo, 'index> StupidContext<'repo, 'index> {
         command
     }
 
+    fn at_least_version(&self, version: &StupidVersion) -> Result<bool> {
+        let mut git_version = self.git_version.borrow_mut();
+        if let Some(git_version) = git_version.as_ref() {
+            Ok(git_version >= version)
+        } else {
+            let interrogated_version = self.version()?.parse::<StupidVersion>()?;
+            let is_at_least = &interrogated_version >= version;
+            git_version.replace(interrogated_version);
+            Ok(is_at_least)
+        }
+    }
+
     /// Apply a patch (diff) to the specified index using `git apply --cached`.
     pub(crate) fn apply_to_index(&self, diff: &[u8]) -> Result<()> {
         self.git_in_work_root()
@@ -151,7 +169,7 @@ impl<'repo, 'index> StupidContext<'repo, 'index> {
         &self,
         tree1: git2::Oid,
         tree2: git2::Oid,
-        do_3way: bool,
+        want_3way: bool,
     ) -> Result<bool> {
         if tree1 == tree2 {
             return Ok(true);
@@ -168,7 +186,7 @@ impl<'repo, 'index> StupidContext<'repo, 'index> {
 
         let mut apply_cmd = self.git_in_work_root();
         apply_cmd.args(["apply", "--cached"]);
-        if do_3way {
+        if want_3way && self.at_least_version(&StupidVersion::new(2, 32, 0))? {
             apply_cmd.arg("--3way");
         }
         let apply_output = apply_cmd
@@ -186,7 +204,7 @@ impl<'repo, 'index> StupidContext<'repo, 'index> {
         &self,
         tree1: git2::Oid,
         tree2: git2::Oid,
-        do_3way: bool,
+        want_3way: bool,
         pathspecs: SpecIter,
     ) -> Result<bool>
     where
@@ -217,7 +235,7 @@ impl<'repo, 'index> StupidContext<'repo, 'index> {
 
         let mut apply_cmd = self.git_in_work_root();
         apply_cmd.args(["apply", "--cached"]);
-        if do_3way {
+        if want_3way && self.at_least_version(&StupidVersion::new(2, 32, 0))? {
             apply_cmd.arg("--3way");
         }
         let apply_output = apply_cmd

src/stupid/version.rs

@@ -0,0 +1,126 @@
+use std::str::FromStr;
+
+use anyhow::{anyhow, Context};
+
+#[derive(Clone, Debug, PartialEq, PartialOrd)]
+pub(crate) struct StupidVersion {
+    major: u16,
+    minor: u16,
+    micro: u16,
+    extra: Option<String>,
+}
+
+impl StupidVersion {
+    pub(crate) fn new(major: u16, minor: u16, micro: u16) -> StupidVersion {
+        StupidVersion {
+            major,
+            minor,
+            micro,
+            extra: None,
+        }
+    }
+}
+
+impl FromStr for StupidVersion {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let ver_str = s
+            .strip_prefix("git version ")
+            .ok_or_else(|| anyhow!("failed to parse git version"))?;
+
+        let (dotted, extra) = if let Some((dotted, extra)) = ver_str.split_once('-') {
+            (dotted, Some(extra.to_string()))
+        } else {
+            (ver_str, None)
+        };
+
+        let mut components = dotted.splitn(4, '.');
+
+        let major = components
+            .next()
+            .ok_or_else(|| anyhow!("no major git version"))
+            .and_then(|major_str| u16::from_str(major_str).context("parsing git major version"))?;
+
+        let minor = components
+            .next()
+            .ok_or_else(|| anyhow!("no minor git version"))
+            .and_then(|minor_str| u16::from_str(minor_str).context("parsing git minor version"))?;
+
+        let micro = components
+            .next()
+            .ok_or_else(|| anyhow!("no micro git version"))
+            .and_then(|micro_str| u16::from_str(micro_str).context("parsing git micro version"))?;
+
+        // Ignore possible nano version component only found in pre-2.0 versions.
+
+        Ok(StupidVersion {
+            major,
+            minor,
+            micro,
+            extra,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::StupidVersion;
+
+    #[test]
+    fn parse_good_versions() {
+        for (version, version_str) in [
+            (StupidVersion::new(2, 38, 1), "2.38.1"),
+            (StupidVersion::new(1, 8, 5), "1.8.5.6"),
+            (
+                StupidVersion {
+                    major: 2,
+                    minor: 17,
+                    micro: 123,
+                    extra: Some("rc0".to_string()),
+                },
+                "2.17.123-rc0",
+            ),
+        ] {
+            let version_str = format!("git version {version_str}");
+            assert_eq!(version, version_str.parse::<StupidVersion>().unwrap());
+        }
+    }
+
+    #[test]
+    fn parse_bad_versions() {
+        assert!("git version something".parse::<StupidVersion>().is_err());
+        assert!("git version 2.3-rc0".parse::<StupidVersion>().is_err());
+    }
+
+    #[test]
+    fn version_comparisons() {
+        let v2_38_1 = StupidVersion::new(2, 38, 1);
+        let v2_38_0 = StupidVersion::new(2, 38, 0);
+        let v2_3_15 = StupidVersion::new(2, 3, 15);
+        let v3_0_0_rc0 = StupidVersion {
+            major: 3,
+            minor: 0,
+            micro: 0,
+            extra: Some("rc0".to_string()),
+        };
+        let v3_0_0_rc1 = StupidVersion {
+            major: 3,
+            minor: 0,
+            micro: 0,
+            extra: Some("rc1".to_string()),
+        };
+        let v3_0_1_rc0 = StupidVersion {
+            major: 3,
+            minor: 0,
+            micro: 1,
+            extra: Some("rc0".to_string()),
+        };
+        assert!(v2_38_1 > v2_38_0);
+        assert_eq!(v2_38_1, v2_38_1);
+        assert!(v2_3_15 < v2_38_0);
+        assert!(v3_0_0_rc0 > v2_38_1);
+        assert!(v3_0_0_rc0 < v3_0_0_rc1);
+        assert!(v3_0_1_rc0 > v3_0_0_rc1);
+    }
+}