vergen_git2/git2/

mod.rs

// Copyright (c) 2022 pud developers
//
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. All files in the project carrying such notice may not be copied,
// modified, or distributed except according to those terms.

use self::git2_builder::Empty;
#[cfg(test)]
use anyhow::anyhow;
use anyhow::{Error, Result};
use bon::Builder;
use git2_rs::{
    BranchType, Commit, DescribeFormatOptions, DescribeOptions, Reference, Repository,
    StatusOptions,
};
use std::{
    env,
    path::{Path, PathBuf},
};
use time::{
    OffsetDateTime, UtcOffset,
    format_description::{self, well_known::Iso8601},
};
use vergen_lib::{
    AddEntries, CargoRerunIfChanged, CargoRustcEnvMap, CargoWarning, DefaultConfig, Describe,
    Dirty, Sha, VergenKey, add_default_map_entry, add_map_entry,
    constants::{
        GIT_BRANCH_NAME, GIT_COMMIT_AUTHOR_EMAIL, GIT_COMMIT_AUTHOR_NAME, GIT_COMMIT_COUNT,
        GIT_COMMIT_DATE_NAME, GIT_COMMIT_MESSAGE, GIT_COMMIT_TIMESTAMP_NAME,
        GIT_COMMIT_TIMESTAMP_UNIX_NAME, GIT_DESCRIBE_NAME, GIT_DIRTY_NAME, GIT_SHA_NAME,
    },
};
#[cfg(feature = "allow_remote")]
use {
    git2_rs::{FetchOptions, build::RepoBuilder},
    std::env::temp_dir,
};

/// The `VERGEN_GIT_*` configuration features
///
/// | Variable | Sample |
/// | -------  | ------ |
/// | `VERGEN_GIT_BRANCH` | feature/fun |
/// | `VERGEN_GIT_COMMIT_AUTHOR_EMAIL` | janedoe@email.com |
/// | `VERGEN_GIT_COMMIT_AUTHOR_NAME` | Jane Doe |
/// | `VERGEN_GIT_COMMIT_COUNT` | 330 |
/// | `VERGEN_GIT_COMMIT_DATE` | 2021-02-24 |
/// | `VERGEN_GIT_COMMIT_MESSAGE` | feat: add commit messages |
/// | `VERGEN_GIT_COMMIT_TIMESTAMP` | 2021-02-24T20:55:21+00:00 |
/// | `VERGEN_GIT_DESCRIBE` | 5.0.0-2-gf49246c |
/// | `VERGEN_GIT_SHA` | f49246ce334567bff9f950bfd0f3078184a2738a |
/// | `VERGEN_GIT_DIRTY` | true |
///
/// # Example
///
/// ```
/// # use anyhow::Result;
/// # use vergen_git2::{Emitter, Git2};
/// #
/// # fn main() -> Result<()> {
/// let git2 = Git2::all_git();
/// Emitter::default().add_instructions(&git2)?.emit()?;
/// #   Ok(())
/// # }
/// ```
///
/// Override output with your own value
///
/// ```
/// # use anyhow::Result;
/// # use vergen_git2::{Emitter, Git2};
/// #
/// # fn main() -> Result<()> {
/// temp_env::with_var("VERGEN_GIT_BRANCH", Some("this is the branch I want output"), || {
///     let result = || -> Result<()> {
///         let git2 = Git2::all_git();
///         Emitter::default().add_instructions(&git2)?.emit()?;
///         Ok(())
///     }();
///     assert!(result.is_ok());
/// });
/// #   Ok(())
/// # }
/// ```
///
#[derive(Builder, Clone, Debug, PartialEq)]
#[allow(clippy::struct_excessive_bools)]
pub struct Git2 {
    /// Configures the default values.
    /// If set to `true` all defaults are in "enabled" state.
    /// If set to `false` all defaults are in "disabled" state.
    #[builder(field)]
    all: bool,
    /// An optional path to a local repository.
    #[builder(into)]
    local_repo_path: Option<PathBuf>,
    /// Force the use of a local repository, ignoring any remote configuration
    #[builder(default = false)]
    force_local: bool,
    /// Force the use of a remote repository (testing only)
    #[cfg(test)]
    #[builder(default = false)]
    force_remote: bool,
    /// An optional remote URL to use in lieu of a local repository
    #[builder(into)]
    remote_url: Option<String>,
    /// An optional path to place the git repository if grabbed remotely
    /// defaults to the temp directory on the system
    #[builder(into)]
    remote_repo_path: Option<PathBuf>,
    /// An optional tag to clone from the remote
    #[builder(into)]
    remote_tag: Option<String>,
    /// The depth to use when fetching the repository
    #[builder(default = 100)]
    fetch_depth: usize,
    /// Fall back to `.cargo_vcs_info.json` for the git SHA and dirty flag when no
    /// repository is available (e.g. building from a published crate or via
    /// `cargo install`).  Requires the `vcs_info` feature.
    #[cfg(feature = "vcs_info")]
    #[builder(default = false)]
    vcs_info_fallback: bool,
    /// Emit the current git branch
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_BRANCH=<BRANCH_NAME>
    /// ```
    ///
    #[builder(default = all)]
    branch: bool,
    /// Emit the author email of the most recent commit
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_COMMIT_AUTHOR_EMAIL=<AUTHOR_EMAIL>
    /// ```
    ///
    #[builder(default = all)]
    commit_author_name: bool,
    /// Emit the author name of the most recent commit
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_COMMIT_AUTHOR_NAME=<AUTHOR_NAME>
    /// ```
    ///
    #[builder(default = all)]
    commit_author_email: bool,
    /// Emit the total commit count to HEAD
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_COMMIT_COUNT=<COUNT>
    /// ```
    #[builder(default = all)]
    commit_count: bool,
    /// Emit the commit message of the latest commit
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_COMMIT_MESSAGE=<MESSAGE>
    /// ```
    ///
    #[builder(default = all)]
    commit_message: bool,
    /// Emit the commit date of the latest commit
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_COMMIT_DATE=<YYYY-MM-DD>
    /// ```
    ///
    #[builder(default = all)]
    commit_date: bool,
    /// Emit the commit timestamp of the latest commit
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_COMMIT_TIMESTAMP=<YYYY-MM-DDThh:mm:ssZ>
    /// ```
    ///
    #[builder(default = all)]
    commit_timestamp: bool,
    /// Emit the commit timestamp of the latest commit as Unix seconds
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_COMMIT_TIMESTAMP_UNIX=<SECONDS>
    /// ```
    ///
    /// This is opt-in and is not enabled by [`Git2::all_git`].
    #[builder(default = false)]
    commit_timestamp_unix: bool,
    /// Emit the describe output
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_DESCRIBE=<DESCRIBE>
    /// ```
    ///
    /// Optionally, add the `dirty` or `tags` flag to describe.
    /// See [`git describe`](https://git-scm.com/docs/git-describe#_options) for more details
    ///
    /// ## `tags`
    /// Instead of using only the annotated tags, use any tag found in refs/tags namespace.
    ///
    /// ## `dirty`
    /// If the working tree has local modification "-dirty" is appended to it.
    ///
    /// ## `match_pattern`
    /// Only consider tags matching the given glob pattern, excluding the "refs/tags/" prefix.
    #[builder(
        required,
        default = all.then(|| Describe::builder().build()),
        with = |tags: bool, dirty: bool, match_pattern: Option<&'static str>| {
            Some(Describe::builder().tags(tags).dirty(dirty).maybe_match_pattern(match_pattern).build())
        }
    )]
    describe: Option<Describe>,
    /// Emit the SHA of the latest commit
    ///
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_SHA=<SHA>
    /// ```
    ///
    /// Optionally, add the `short` flag to rev-parse.
    /// See [`git rev-parse`](https://git-scm.com/docs/git-rev-parse#_options_for_output) for more details.
    ///
    /// ## `short`
    /// Shortens the object name to a unique prefix
    #[builder(
        required,
        default = all.then(|| Sha::builder().build()),
        with = |short: bool| Some(Sha::builder().short(short).build())
    )]
    sha: Option<Sha>,
    /// Emit the dirty state of the git repository
    /// ```text
    /// cargo:rustc-env=VERGEN_GIT_DIRTY=(true|false)
    /// ```
    ///
    /// Optionally, include untracked files when determining the dirty status of the repository.
    ///
    /// # `include_tracked`
    /// Should we include/ignore untracked files in deciding whether the repository is dirty.
    #[builder(
        required,
        default = all.then(|| Dirty::builder().build()),
        with = |include_untracked: bool| Some(Dirty::builder().include_untracked(include_untracked).build())
    )]
    dirty: Option<Dirty>,
    /// Enable local offset date/timestamp output
    #[builder(default = false)]
    use_local: bool,
    #[cfg(test)]
    /// Fail
    #[builder(default = false)]
    fail: bool,
}

impl<S: git2_builder::State> Git2Builder<S> {
    /// Convenience method that switches the defaults of [`Git2Builder`]
    /// to enable all of the `VERGEN_GIT_*` instructions. It can only be
    /// called at the start of the building process, i.e. when no config
    /// has been set yet to avoid overwrites.
    fn all(mut self) -> Self {
        self.all = true;
        self
    }
}

impl Git2 {
    /// Emit all of the `VERGEN_GIT_*` instructions
    #[must_use]
    pub fn all_git() -> Git2 {
        Self::builder().all().build()
    }

    /// Convenience method to setup the [`Git2`] builder with all of the `VERGEN_GIT_*` instructions on
    pub fn all() -> Git2Builder<Empty> {
        Self::builder().all()
    }

    fn any(&self) -> bool {
        self.branch
            || self.commit_author_email
            || self.commit_author_name
            || self.commit_count
            || self.commit_date
            || self.commit_message
            || self.commit_timestamp
            || self.commit_timestamp_unix
            || self.describe.is_some()
            || self.sha.is_some()
            || self.dirty.is_some()
    }

    /// Use the repository location at the given path to determine the git instruction output.
    pub fn at_path(&mut self, path: PathBuf) -> &mut Self {
        self.local_repo_path = Some(path);
        self
    }

    #[cfg(test)]
    pub(crate) fn fail(&mut self) -> &mut Self {
        self.fail = true;
        self
    }

    #[cfg(not(test))]
    fn add_entries(
        &self,
        idempotent: bool,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_rerun_if_changed: &mut CargoRerunIfChanged,
        cargo_warning: &mut CargoWarning,
    ) -> Result<()> {
        self.inner_add_entries(
            idempotent,
            cargo_rustc_env,
            cargo_rerun_if_changed,
            cargo_warning,
        )
    }

    #[cfg(test)]
    fn add_entries(
        &self,
        idempotent: bool,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_rerun_if_changed: &mut CargoRerunIfChanged,
        cargo_warning: &mut CargoWarning,
    ) -> Result<()> {
        if self.fail {
            return Err(anyhow!("failed to create entries"));
        }
        self.inner_add_entries(
            idempotent,
            cargo_rustc_env,
            cargo_rerun_if_changed,
            cargo_warning,
        )
    }

    #[cfg(all(not(test), feature = "allow_remote"))]
    #[allow(clippy::unused_self)]
    fn try_local(&self) -> bool {
        true
    }

    #[cfg(all(test, feature = "allow_remote"))]
    fn try_local(&self) -> bool {
        self.force_local || !self.force_remote
    }

    #[cfg(all(not(test), feature = "allow_remote"))]
    fn try_remote(&self) -> bool {
        !self.force_local
    }

    #[cfg(all(test, feature = "allow_remote"))]
    fn try_remote(&self) -> bool {
        self.force_remote || !self.force_local
    }

    #[cfg(not(feature = "allow_remote"))]
    #[allow(clippy::unused_self)]
    fn get_repository(
        &self,
        repo_dir: &PathBuf,
        _warnings: &mut CargoWarning,
    ) -> Result<Repository> {
        Repository::discover(repo_dir).map_err(Into::into)
    }

    #[cfg(feature = "allow_remote")]
    fn get_repository(
        &self,
        repo_dir: &PathBuf,
        warnings: &mut CargoWarning,
    ) -> Result<Repository> {
        if self.try_local()
            && let Ok(repo) = Repository::discover(repo_dir)
        {
            Ok(repo)
        } else if self.try_remote()
            && let Some(remote_url) = &self.remote_url
        {
            use git2_rs::build::CheckoutBuilder;

            let repo_path = if let Some(path) = &self.remote_repo_path {
                path.clone()
            } else {
                temp_dir().join("vergen-git2")
            };
            std::fs::create_dir_all(&repo_path)?;
            let mut fetch_opts = FetchOptions::new();
            let _ = fetch_opts.download_tags(git2_rs::AutotagOption::All);
            let _ = fetch_opts.depth(self.fetch_depth.try_into()?);
            let mut repo_builder = RepoBuilder::new();
            let _ = repo_builder.fetch_options(fetch_opts);
            let repo = repo_builder.clone(remote_url, &repo_path)?;

            if let Some(remote_tag) = self.remote_tag.as_deref() {
                let spec = format!("refs/tags/{remote_tag}");
                let (obj, reference) = repo.revparse_ext(&spec)?;
                repo.checkout_tree(&obj, Some(CheckoutBuilder::new().force()))?;
                if let Some(gref) = reference {
                    repo.set_head(gref.name().unwrap())?;
                } else {
                    // detached head
                    repo.set_head_detached(obj.id())?;
                }
            }
            warnings.push(format!(
                "Using remote repository from '{remote_url}' at '{}'",
                repo.path().display()
            ));
            Ok(repo)
        } else {
            Err(anyhow::anyhow!(
                "Could not find a git repository at '{}'",
                repo_dir.display()
            ))
        }
    }

    #[cfg(not(feature = "allow_remote"))]
    #[allow(clippy::unused_self)]
    fn cleanup(&self) {}

    #[cfg(feature = "allow_remote")]
    fn cleanup(&self) {
        if let Some(_remote_url) = self.remote_url.as_ref() {
            let temp_dir = temp_dir().join("vergen-git2");
            // If we used a remote URL, we should clean up the repo we cloned
            if let Some(path) = &self.remote_repo_path {
                if path.exists() {
                    let _ = std::fs::remove_dir_all(path).ok();
                }
            } else if temp_dir.exists() {
                let _ = std::fs::remove_dir_all(temp_dir).ok();
            }
        }
    }

    #[allow(clippy::too_many_lines)]
    fn inner_add_entries(
        &self,
        idempotent: bool,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_rerun_if_changed: &mut CargoRerunIfChanged,
        cargo_warning: &mut CargoWarning,
    ) -> Result<()> {
        let repo_dir = if let Some(path) = &self.local_repo_path {
            path.clone()
        } else {
            env::current_dir()?
        };
        let repo = self.get_repository(&repo_dir, cargo_warning)?;
        let ref_head = repo.find_reference("HEAD")?;
        let git_path = repo.path().to_path_buf();
        let commit = ref_head.peel_to_commit()?;

        if !idempotent && self.any() {
            Self::add_rerun_if_changed(&ref_head, &git_path, cargo_rerun_if_changed);
        }

        if self.branch {
            if let Ok(_value) = env::var(GIT_BRANCH_NAME) {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitBranch,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                Self::add_branch_name(idempotent, false, &repo, cargo_rustc_env, cargo_warning)?;
            }
        }

        if self.commit_author_email {
            if let Ok(_value) = env::var(GIT_COMMIT_AUTHOR_EMAIL) {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitCommitAuthorEmail,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                Self::add_opt_value(
                    idempotent,
                    commit.author().email().ok(),
                    VergenKey::GitCommitAuthorEmail,
                    cargo_rustc_env,
                    cargo_warning,
                );
            }
        }

        if self.commit_author_name {
            if let Ok(_value) = env::var(GIT_COMMIT_AUTHOR_NAME) {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitCommitAuthorName,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                Self::add_opt_value(
                    idempotent,
                    commit.author().name().ok(),
                    VergenKey::GitCommitAuthorName,
                    cargo_rustc_env,
                    cargo_warning,
                );
            }
        }

        if self.commit_count {
            if let Ok(_value) = env::var(GIT_COMMIT_COUNT) {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitCommitCount,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                Self::add_commit_count(idempotent, false, &repo, cargo_rustc_env, cargo_warning);
            }
        }

        self.add_git_timestamp_entries(&commit, idempotent, cargo_rustc_env, cargo_warning)?;

        if self.commit_message {
            if let Ok(_value) = env::var(GIT_COMMIT_MESSAGE) {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitCommitMessage,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                Self::add_opt_value(
                    idempotent,
                    commit.message().ok(),
                    VergenKey::GitCommitMessage,
                    cargo_rustc_env,
                    cargo_warning,
                );
            }
        }

        if let Some(sha) = self.sha {
            if let Ok(_value) = env::var(GIT_SHA_NAME) {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitSha,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else if sha.short() {
                let obj = repo.revparse_single("HEAD")?;
                Self::add_opt_value(
                    idempotent,
                    obj.short_id()?.as_str().ok(),
                    VergenKey::GitSha,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                add_map_entry(VergenKey::GitSha, commit.id().to_string(), cargo_rustc_env);
            }
        }

        if let Some(dirty) = self.dirty {
            if let Ok(_value) = env::var(GIT_DIRTY_NAME) {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitDirty,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                let mut status_options = StatusOptions::new();

                _ = status_options.include_untracked(dirty.include_untracked());
                let statuses = repo.statuses(Some(&mut status_options))?;

                let n_dirty = statuses
                    .iter()
                    .filter(|each_status| !each_status.status().is_ignored())
                    .count();

                add_map_entry(
                    VergenKey::GitDirty,
                    format!("{}", n_dirty > 0),
                    cargo_rustc_env,
                );
            }
        }

        if let Some(describe) = self.describe {
            if let Ok(_value) = env::var(GIT_DESCRIBE_NAME) {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitDescribe,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                let mut describe_opts = DescribeOptions::new();
                let mut format_opts = DescribeFormatOptions::new();

                _ = describe_opts.show_commit_oid_as_fallback(true);

                if describe.dirty() {
                    _ = format_opts.dirty_suffix("-dirty");
                }

                if describe.tags() {
                    _ = describe_opts.describe_tags();
                }

                if let Some(pattern) = *describe.match_pattern() {
                    _ = describe_opts.pattern(pattern);
                }

                let describe = repo
                    .describe(&describe_opts)
                    .map(|x| x.format(Some(&format_opts)).map_err(Error::from))??;
                add_map_entry(VergenKey::GitDescribe, describe, cargo_rustc_env);
            }
        }

        self.cleanup();

        Ok(())
    }

    fn add_rerun_if_changed(
        ref_head: &Reference<'_>,
        git_path: &Path,
        cargo_rerun_if_changed: &mut CargoRerunIfChanged,
    ) {
        // Setup the head path
        let mut head_path = git_path.to_path_buf();
        head_path.push("HEAD");

        // Check whether the path exists in the filesystem before emitting it
        if head_path.exists() {
            cargo_rerun_if_changed.push(format!("{}", head_path.display()));
        }

        if let Ok(resolved) = ref_head.resolve()
            && let Ok(name) = resolved.name()
        {
            let ref_path = git_path.to_path_buf();
            let path = ref_path.join(name);
            // Check whether the path exists in the filesystem before emitting it
            if path.exists() {
                cargo_rerun_if_changed.push(format!("{}", path.display()));
            }
        }
    }

    fn add_branch_name(
        idempotent: bool,
        add_default: bool,
        repo: &Repository,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_warning: &mut CargoWarning,
    ) -> Result<()> {
        if repo.head_detached()? {
            if add_default {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitBranch,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                add_map_entry(VergenKey::GitBranch, "HEAD", cargo_rustc_env);
            }
        } else {
            let locals = repo.branches(Some(BranchType::Local))?;
            let mut found_head = false;
            for (local, _bt) in locals.filter_map(std::result::Result::ok) {
                if local.is_head()
                    && let Some(name) = local.name()?
                {
                    add_map_entry(VergenKey::GitBranch, name, cargo_rustc_env);
                    found_head = !add_default;
                    break;
                }
            }
            if !found_head {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitBranch,
                    cargo_rustc_env,
                    cargo_warning,
                );
            }
        }
        Ok(())
    }

    fn add_opt_value(
        idempotent: bool,
        value: Option<&str>,
        key: VergenKey,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_warning: &mut CargoWarning,
    ) {
        if let Some(val) = value {
            add_map_entry(key, val, cargo_rustc_env);
        } else {
            add_default_map_entry(idempotent, key, cargo_rustc_env, cargo_warning);
        }
    }

    fn add_commit_count(
        idempotent: bool,
        add_default: bool,
        repo: &Repository,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_warning: &mut CargoWarning,
    ) {
        let key = VergenKey::GitCommitCount;
        if !add_default
            && let Ok(mut revwalk) = repo.revwalk()
            && revwalk.push_head().is_ok()
        {
            add_map_entry(key, revwalk.count().to_string(), cargo_rustc_env);
            return;
        }
        add_default_map_entry(idempotent, key, cargo_rustc_env, cargo_warning);
    }

    fn add_git_timestamp_entries(
        &self,
        commit: &Commit<'_>,
        idempotent: bool,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_warning: &mut CargoWarning,
    ) -> Result<()> {
        // NOTE: SOURCE_DATE_EPOCH intentionally does NOT influence the git
        // commit date/timestamp. Those derive from the commit itself and are
        // already reproducible; SOURCE_DATE_EPOCH only affects the build
        // timestamp (see issue #452).
        let ts = self.compute_local_offset(commit)?;

        if let Ok(_value) = env::var(GIT_COMMIT_DATE_NAME) {
            add_default_map_entry(
                idempotent,
                VergenKey::GitCommitDate,
                cargo_rustc_env,
                cargo_warning,
            );
        } else {
            self.add_git_date_entry(idempotent, &ts, cargo_rustc_env, cargo_warning)?;
        }
        if let Ok(_value) = env::var(GIT_COMMIT_TIMESTAMP_NAME) {
            add_default_map_entry(
                idempotent,
                VergenKey::GitCommitTimestamp,
                cargo_rustc_env,
                cargo_warning,
            );
        } else {
            self.add_git_timestamp_entry(idempotent, &ts, cargo_rustc_env, cargo_warning)?;
        }
        if let Ok(_value) = env::var(GIT_COMMIT_TIMESTAMP_UNIX_NAME) {
            add_default_map_entry(
                idempotent,
                VergenKey::GitCommitTimestampUnix,
                cargo_rustc_env,
                cargo_warning,
            );
        } else {
            self.add_git_timestamp_unix_entry(idempotent, &ts, cargo_rustc_env, cargo_warning);
        }
        Ok(())
    }

    fn add_git_timestamp_unix_entry(
        &self,
        idempotent: bool,
        ts: &OffsetDateTime,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_warning: &mut CargoWarning,
    ) {
        if self.commit_timestamp_unix {
            if idempotent {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitCommitTimestampUnix,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                add_map_entry(
                    VergenKey::GitCommitTimestampUnix,
                    ts.unix_timestamp().to_string(),
                    cargo_rustc_env,
                );
            }
        }
    }

    #[cfg_attr(coverage_nightly, coverage(off))]
    // this in not included in coverage, because on *nix the local offset is always unsafe
    fn compute_local_offset(&self, commit: &Commit<'_>) -> Result<OffsetDateTime> {
        let no_offset = OffsetDateTime::from_unix_timestamp(commit.time().seconds())?;
        if self.use_local {
            let local = UtcOffset::local_offset_at(no_offset)?;
            let local_offset = no_offset.checked_to_offset(local).unwrap_or(no_offset);
            Ok(local_offset)
        } else {
            Ok(no_offset)
        }
    }

    fn add_git_date_entry(
        &self,
        idempotent: bool,
        ts: &OffsetDateTime,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_warning: &mut CargoWarning,
    ) -> Result<()> {
        if self.commit_date {
            if idempotent {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitCommitDate,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                let format = format_description::parse_borrowed::<1>("[year]-[month]-[day]")?;
                add_map_entry(
                    VergenKey::GitCommitDate,
                    ts.format(&format)?,
                    cargo_rustc_env,
                );
            }
        }
        Ok(())
    }

    fn add_git_timestamp_entry(
        &self,
        idempotent: bool,
        ts: &OffsetDateTime,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_warning: &mut CargoWarning,
    ) -> Result<()> {
        if self.commit_timestamp {
            if idempotent {
                add_default_map_entry(
                    idempotent,
                    VergenKey::GitCommitTimestamp,
                    cargo_rustc_env,
                    cargo_warning,
                );
            } else {
                add_map_entry(
                    VergenKey::GitCommitTimestamp,
                    ts.format(&Iso8601::DEFAULT)?,
                    cargo_rustc_env,
                );
            }
        }
        Ok(())
    }

    /// The git SHA and dirty flag recovered from `.cargo_vcs_info.json`, if the
    /// `vcs_info` fallback is enabled and the file is present. #448
    #[cfg(feature = "vcs_info")]
    fn vcs_fallback(&self) -> Option<(String, bool)> {
        if self.vcs_info_fallback {
            vergen_lib::vcs_info()
        } else {
            None
        }
    }

    #[cfg(not(feature = "vcs_info"))]
    #[allow(clippy::unused_self)]
    fn vcs_fallback(&self) -> Option<(String, bool)> {
        None
    }
}

impl AddEntries for Git2 {
    fn add_map_entries(
        &self,
        idempotent: bool,
        cargo_rustc_env: &mut CargoRustcEnvMap,
        cargo_rerun_if_changed: &mut CargoRerunIfChanged,
        cargo_warning: &mut CargoWarning,
    ) -> Result<()> {
        if self.any() {
            self.add_entries(
                idempotent,
                cargo_rustc_env,
                cargo_rerun_if_changed,
                cargo_warning,
            )?;
        }
        Ok(())
    }

    #[allow(clippy::too_many_lines)]
    fn add_default_entries(
        &self,
        config: &DefaultConfig,
        cargo_rustc_env_map: &mut CargoRustcEnvMap,
        cargo_rerun_if_changed: &mut CargoRerunIfChanged,
        cargo_warning: &mut CargoWarning,
    ) -> Result<()> {
        if *config.fail_on_error() {
            let error = Error::msg(format!("{}", config.error()));
            Err(error)
        } else {
            // Clear any previous warnings.  This should be it.
            cargo_warning.clear();
            cargo_rerun_if_changed.clear();

            cargo_warning.push(format!("{}", config.error()));

            // With no repository available, optionally recover the SHA and dirty
            // flag from .cargo_vcs_info.json (e.g. a published crate). #448
            let vcs = self.vcs_fallback();

            if self.branch {
                add_default_map_entry(
                    *config.idempotent(),
                    VergenKey::GitBranch,
                    cargo_rustc_env_map,
                    cargo_warning,
                );
            }
            if self.commit_author_email {
                add_default_map_entry(
                    *config.idempotent(),
                    VergenKey::GitCommitAuthorEmail,
                    cargo_rustc_env_map,
                    cargo_warning,
                );
            }
            if self.commit_author_name {
                add_default_map_entry(
                    *config.idempotent(),
                    VergenKey::GitCommitAuthorName,
                    cargo_rustc_env_map,
                    cargo_warning,
                );
            }
            if self.commit_count {
                add_default_map_entry(
                    *config.idempotent(),
                    VergenKey::GitCommitCount,
                    cargo_rustc_env_map,
                    cargo_warning,
                );
            }
            if self.commit_date {
                add_default_map_entry(
                    *config.idempotent(),
                    VergenKey::GitCommitDate,
                    cargo_rustc_env_map,
                    cargo_warning,
                );
            }
            if self.commit_message {
                add_default_map_entry(
                    *config.idempotent(),
                    VergenKey::GitCommitMessage,
                    cargo_rustc_env_map,
                    cargo_warning,
                );
            }
            if self.commit_timestamp {
                add_default_map_entry(
                    *config.idempotent(),
                    VergenKey::GitCommitTimestamp,
                    cargo_rustc_env_map,
                    cargo_warning,
                );
            }
            if self.commit_timestamp_unix {
                add_default_map_entry(
                    *config.idempotent(),
                    VergenKey::GitCommitTimestampUnix,
                    cargo_rustc_env_map,
                    cargo_warning,
                );
            }
            if self.describe.is_some() {
                add_default_map_entry(
                    *config.idempotent(),
                    VergenKey::GitDescribe,
                    cargo_rustc_env_map,
                    cargo_warning,
                );
            }
            if self.sha.is_some() {
                if let Some((sha, _)) = &vcs {
                    add_map_entry(VergenKey::GitSha, sha.clone(), cargo_rustc_env_map);
                } else {
                    add_default_map_entry(
                        *config.idempotent(),
                        VergenKey::GitSha,
                        cargo_rustc_env_map,
                        cargo_warning,
                    );
                }
            }
            if self.dirty.is_some() {
                if let Some((_, dirty)) = &vcs {
                    add_map_entry(VergenKey::GitDirty, dirty.to_string(), cargo_rustc_env_map);
                } else {
                    add_default_map_entry(
                        *config.idempotent(),
                        VergenKey::GitDirty,
                        cargo_rustc_env_map,
                        cargo_warning,
                    );
                }
            }
            Ok(())
        }
    }
}

#[cfg(test)]
mod test {
    use super::Git2;
    use anyhow::Result;
    use git2_rs::Repository;
    use serial_test::serial;
    #[cfg(unix)]
    use std::io::stdout;
    use std::{collections::BTreeMap, env::current_dir, io::Write};
    #[cfg(unix)]
    use test_util::TEST_MTIME;
    use test_util::TestRepos;
    use vergen::Emitter;
    use vergen_lib::{VergenKey, count_idempotent};

    #[test]
    #[serial]
    #[allow(clippy::clone_on_copy, clippy::redundant_clone)]
    fn git2_clone_works() {
        let git2 = Git2::all_git();
        let another = git2.clone();
        assert_eq!(another, git2);
    }

    #[test]
    #[serial]
    fn git2_debug_works() -> Result<()> {
        let git2 = Git2::all_git();
        let mut buf = vec![];
        write!(buf, "{git2:?}")?;
        assert!(!buf.is_empty());
        Ok(())
    }

    #[test]
    #[serial]
    fn git2_default() -> Result<()> {
        let git2 = Git2::builder().build();
        let emitter = Emitter::default().add_instructions(&git2)?.test_emit();
        assert_eq!(0, emitter.cargo_rustc_env_map().len());
        assert_eq!(0, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(0, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    fn empty_email_is_warning() -> Result<()> {
        let mut cargo_rustc_env = BTreeMap::new();
        let mut cargo_warning = vec![];
        Git2::add_opt_value(
            false,
            None,
            VergenKey::GitCommitAuthorEmail,
            &mut cargo_rustc_env,
            &mut cargo_warning,
        );
        assert_eq!(0, cargo_rustc_env.len());
        assert_eq!(1, cargo_warning.len());
        Ok(())
    }

    #[test]
    #[serial]
    fn empty_email_idempotent() -> Result<()> {
        let mut cargo_rustc_env = BTreeMap::new();
        let mut cargo_warning = vec![];
        Git2::add_opt_value(
            true,
            None,
            VergenKey::GitCommitAuthorEmail,
            &mut cargo_rustc_env,
            &mut cargo_warning,
        );
        assert_eq!(1, cargo_rustc_env.len());
        assert_eq!(1, cargo_warning.len());
        Ok(())
    }

    #[test]
    #[serial]
    fn bad_revwalk_is_warning() -> Result<()> {
        let mut cargo_rustc_env = BTreeMap::new();
        let mut cargo_warning = vec![];
        let repo = Repository::discover(current_dir()?)?;
        Git2::add_commit_count(false, true, &repo, &mut cargo_rustc_env, &mut cargo_warning);
        assert_eq!(0, cargo_rustc_env.len());
        assert_eq!(1, cargo_warning.len());
        Ok(())
    }

    #[test]
    #[serial]
    fn bad_revwalk_idempotent() -> Result<()> {
        let mut cargo_rustc_env = BTreeMap::new();
        let mut cargo_warning = vec![];
        let repo = Repository::discover(current_dir()?)?;
        Git2::add_commit_count(true, true, &repo, &mut cargo_rustc_env, &mut cargo_warning);
        assert_eq!(1, cargo_rustc_env.len());
        assert_eq!(1, cargo_warning.len());
        Ok(())
    }

    #[test]
    #[serial]
    fn head_not_found_is_default() -> Result<()> {
        let test_repo = TestRepos::new(false, false, false)?;
        let mut map = BTreeMap::new();
        let mut cargo_warning = vec![];
        let repo = Repository::discover(current_dir()?)?;
        // CI checks out a detached HEAD. With a detached HEAD and a
        // non-idempotent default, add_branch_name emits only a warning and no
        // map entry; on a normal branch checkout the branch name is added.
        let detached = repo.head_detached()?;
        Git2::add_branch_name(false, true, &repo, &mut map, &mut cargo_warning)?;
        assert_eq!(usize::from(!detached), map.len());
        assert_eq!(1, cargo_warning.len());
        let mut map = BTreeMap::new();
        let mut cargo_warning = vec![];
        let repo = Repository::discover(test_repo.path())?;
        Git2::add_branch_name(false, true, &repo, &mut map, &mut cargo_warning)?;
        assert_eq!(1, map.len());
        assert_eq!(1, cargo_warning.len());
        Ok(())
    }

    #[test]
    #[serial]
    fn git_all_idempotent() -> Result<()> {
        let git2 = Git2::all_git();
        let emitter = Emitter::default()
            .idempotent()
            .add_instructions(&git2)?
            .test_emit();
        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(2, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(2, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    fn git_all_shallow_clone() -> Result<()> {
        let repo = TestRepos::new(false, false, true)?;
        let mut git2 = Git2::all_git();
        let _ = git2.at_path(repo.path());
        let emitter = Emitter::default().add_instructions(&git2)?.test_emit();
        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(0, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(0, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    fn git_all_idempotent_no_warn() -> Result<()> {
        let git2 = Git2::all_git();
        let emitter = Emitter::default()
            .idempotent()
            .quiet()
            .add_instructions(&git2)?
            .test_emit();

        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(2, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(2, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    fn git_all() -> Result<()> {
        let git2 = Git2::all_git();
        let emitter = Emitter::default().add_instructions(&git2)?.test_emit();
        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(0, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(0, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    fn git_error_fails() -> Result<()> {
        let mut git2 = Git2::all_git();
        let _ = git2.fail();
        assert!(
            Emitter::default()
                .fail_on_error()
                .add_instructions(&git2)
                .is_err()
        );
        Ok(())
    }

    #[test]
    #[serial]
    fn git_error_warnings() -> Result<()> {
        let mut git2 = Git2::all_git();
        let _ = git2.fail();
        let emitter = Emitter::default().add_instructions(&git2)?.test_emit();
        assert_eq!(0, emitter.cargo_rustc_env_map().len());
        assert_eq!(0, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(11, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    fn git_error_idempotent() -> Result<()> {
        let mut git2 = Git2::all_git();
        let _ = git2.fail();
        let emitter = Emitter::default()
            .idempotent()
            .add_instructions(&git2)?
            .test_emit();
        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(10, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(11, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    fn source_date_epoch_does_not_affect_git() {
        // SOURCE_DATE_EPOCH must not influence the git commit date/timestamp;
        // those derive from the commit and are already reproducible (#452). The
        // git output must therefore be identical whether or not it is set.
        fn emit() -> Result<String> {
            let mut stdout_buf = vec![];
            let git2 = Git2::builder()
                .commit_date(true)
                .commit_timestamp(true)
                .build();
            _ = Emitter::new()
                .add_instructions(&git2)?
                .emit_to(&mut stdout_buf)?;
            Ok(String::from_utf8_lossy(&stdout_buf).into_owned())
        }
        let without = temp_env::with_var("SOURCE_DATE_EPOCH", None::<&str>, emit);
        let with = temp_env::with_var("SOURCE_DATE_EPOCH", Some("1671809360"), emit);
        assert_eq!(without.unwrap(), with.unwrap());
    }

    #[test]
    #[serial]
    #[cfg(unix)]
    fn bad_source_date_epoch_ignored_by_git() {
        use std::ffi::OsStr;
        use std::os::unix::prelude::OsStrExt;

        // A malformed SOURCE_DATE_EPOCH no longer affects git output (#452), so
        // emission succeeds even with fail_on_error.
        let source = [0x66, 0x6f, 0x80, 0x6f];
        let os_str = OsStr::from_bytes(&source[..]);
        temp_env::with_var("SOURCE_DATE_EPOCH", Some(os_str), || {
            let result = || -> Result<bool> {
                let mut stdout_buf = vec![];
                let gix = Git2::builder().commit_date(true).build();
                Emitter::new()
                    .idempotent()
                    .fail_on_error()
                    .add_instructions(&gix)?
                    .emit_to(&mut stdout_buf)
            }();
            assert!(result.is_ok());
        });
    }

    #[test]
    #[serial]
    #[cfg(unix)]
    fn bad_source_date_epoch_defaults() {
        use std::ffi::OsStr;
        use std::os::unix::prelude::OsStrExt;

        let source = [0x66, 0x6f, 0x80, 0x6f];
        let os_str = OsStr::from_bytes(&source[..]);
        temp_env::with_var("SOURCE_DATE_EPOCH", Some(os_str), || {
            let result = || -> Result<bool> {
                let mut stdout_buf = vec![];
                let gix = Git2::builder().commit_date(true).build();
                Emitter::new()
                    .idempotent()
                    .add_instructions(&gix)?
                    .emit_to(&mut stdout_buf)
            }();
            assert!(result.is_ok());
        });
    }

    #[test]
    #[serial]
    #[cfg(windows)]
    fn bad_source_date_epoch_ignored_by_git() {
        use std::ffi::OsString;
        use std::os::windows::prelude::OsStringExt;

        // A malformed SOURCE_DATE_EPOCH no longer affects git output (#452), so
        // emission succeeds even with fail_on_error.
        let source = [0x0066, 0x006f, 0xD800, 0x006f];
        let os_string = OsString::from_wide(&source[..]);
        let os_str = os_string.as_os_str();
        temp_env::with_var("SOURCE_DATE_EPOCH", Some(os_str), || {
            let result = || -> Result<bool> {
                let mut stdout_buf = vec![];
                let gix = Git2::builder().commit_date(true).build();
                Emitter::new()
                    .fail_on_error()
                    .idempotent()
                    .add_instructions(&gix)?
                    .emit_to(&mut stdout_buf)
            }();
            assert!(result.is_ok());
        });
    }

    #[test]
    #[serial]
    #[cfg(windows)]
    fn bad_source_date_epoch_defaults() {
        use std::ffi::OsString;
        use std::os::windows::prelude::OsStringExt;

        let source = [0x0066, 0x006f, 0xD800, 0x006f];
        let os_string = OsString::from_wide(&source[..]);
        let os_str = os_string.as_os_str();
        temp_env::with_var("SOURCE_DATE_EPOCH", Some(os_str), || {
            let result = || -> Result<bool> {
                let mut stdout_buf = vec![];
                let gix = Git2::builder().commit_date(true).build();
                Emitter::new()
                    .idempotent()
                    .add_instructions(&gix)?
                    .emit_to(&mut stdout_buf)
            }();
            assert!(result.is_ok());
        });
    }

    #[test]
    #[serial]
    #[cfg(unix)]
    fn git_no_index_update() -> Result<()> {
        let repo = TestRepos::new(true, true, false)?;
        repo.set_index_magic_mtime()?;

        let mut git2 = Git2::builder().all().describe(true, true, None).build();
        let _ = git2.at_path(repo.path());
        let failed = Emitter::default()
            .add_instructions(&git2)?
            .emit_to(&mut stdout())?;
        assert!(!failed);

        assert_eq!(*TEST_MTIME, repo.get_index_magic_mtime()?);
        Ok(())
    }

    #[test]
    #[serial]
    #[cfg(feature = "allow_remote")]
    fn remote_clone_works() -> Result<()> {
        let git2 = Git2::all()
            // For testing only
            .force_remote(true)
            .remote_url("https://github.com/rustyhorde/vergen-cl.git")
            .describe(true, true, None)
            .build();
        let emitter = Emitter::default().add_instructions(&git2)?.test_emit();
        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(0, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(1, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    #[cfg(feature = "allow_remote")]
    fn remote_clone_with_path_works() -> Result<()> {
        let remote_path = std::env::temp_dir().join("blah");
        let git2 = Git2::all()
            // For testing only
            .force_remote(true)
            .remote_repo_path(&remote_path)
            .remote_url("https://github.com/rustyhorde/vergen-cl.git")
            .describe(true, true, None)
            .build();
        let emitter = Emitter::default().add_instructions(&git2)?.test_emit();
        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(0, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(1, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    #[cfg(feature = "allow_remote")]
    fn remote_clone_with_force_local_works() -> Result<()> {
        let git2 = Git2::all()
            .force_local(true)
            // For testing only
            .force_remote(true)
            .remote_url("https://github.com/rustyhorde/vergen-cl.git")
            .describe(true, true, None)
            .build();
        let emitter = Emitter::default().add_instructions(&git2)?.test_emit();
        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(0, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(0, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    #[cfg(feature = "allow_remote")]
    fn remote_clone_with_tag_works() -> Result<()> {
        let git2 = Git2::all()
            // For testing only
            .force_remote(true)
            .remote_tag("0.3.9")
            .remote_url("https://github.com/rustyhorde/vergen-cl.git")
            .describe(true, true, None)
            .build();
        let emitter = Emitter::default().add_instructions(&git2)?.test_emit();
        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(0, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(1, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    #[cfg(feature = "allow_remote")]
    fn remote_clone_with_depth_works() -> Result<()> {
        let git2 = Git2::all()
            // For testing only
            .force_remote(true)
            .fetch_depth(200)
            .remote_tag("0.3.9")
            .remote_url("https://github.com/rustyhorde/vergen-cl.git")
            .describe(true, true, None)
            .build();
        let emitter = Emitter::default().add_instructions(&git2)?.test_emit();
        assert_eq!(10, emitter.cargo_rustc_env_map().len());
        assert_eq!(0, count_idempotent(emitter.cargo_rustc_env_map()));
        assert_eq!(1, emitter.cargo_warning().len());
        Ok(())
    }

    #[test]
    #[serial]
    #[cfg(feature = "vcs_info")]
    fn vcs_info_fallback_populates_sha_and_dirty() -> Result<()> {
        use std::io::Write as _;

        let tmp = std::env::temp_dir().join(format!("vergen_vcs_info_{}", std::process::id()));
        std::fs::create_dir_all(&tmp)?;
        let mut file = std::fs::File::create(tmp.join(".cargo_vcs_info.json"))?;
        write!(
            file,
            r#"{{"git":{{"sha1":"deadbeef","dirty":true}},"path_in_vcs":""}}"#
        )?;

        let git2 = Git2::builder()
            .sha(false)
            .dirty(false)
            .vcs_info_fallback(true)
            // Point at a non-repository so the git lookup fails and the
            // .cargo_vcs_info.json fallback is exercised.
            .local_repo_path(tmp.join("not-a-repo"))
            .build();

        let mut stdout_buf = vec![];
        temp_env::with_var(
            "CARGO_MANIFEST_DIR",
            Some(tmp.as_os_str()),
            || -> Result<()> {
                let mut emitter = Emitter::default();
                _ = emitter.add_instructions(&git2)?.emit_to(&mut stdout_buf)?;
                Ok(())
            },
        )?;

        let output = String::from_utf8_lossy(&stdout_buf);
        let _ = std::fs::remove_dir_all(&tmp).ok();
        assert!(
            output.contains("cargo:rustc-env=VERGEN_GIT_SHA=deadbeef"),
            "{output}"
        );
        assert!(
            output.contains("cargo:rustc-env=VERGEN_GIT_DIRTY=true"),
            "{output}"
        );
        Ok(())
    }

    #[test]
    #[serial]
    fn commit_timestamp_unix_works() -> Result<()> {
        let git2 = Git2::builder().commit_timestamp_unix(true).build();
        let mut stdout_buf = vec![];
        _ = Emitter::default()
            .add_instructions(&git2)?
            .emit_to(&mut stdout_buf)?;
        let output = String::from_utf8_lossy(&stdout_buf);
        let line = output
            .lines()
            .find(|l| l.starts_with("cargo:rustc-env=VERGEN_GIT_COMMIT_TIMESTAMP_UNIX="))
            .expect("unix commit timestamp emitted");
        let value = line.trim_start_matches("cargo:rustc-env=VERGEN_GIT_COMMIT_TIMESTAMP_UNIX=");
        assert!(value.parse::<i64>().is_ok(), "value: {value}");
        Ok(())
    }

    #[test]
    #[serial]
    fn commit_timestamp_unix_idempotent() -> Result<()> {
        let git2 = Git2::builder().commit_timestamp_unix(true).build();
        let emitter = Emitter::default()
            .idempotent()
            .add_instructions(&git2)?
            .test_emit();
        assert_eq!(1, emitter.cargo_rustc_env_map().len());
        assert_eq!(1, count_idempotent(emitter.cargo_rustc_env_map()));
        Ok(())
    }

    #[test]
    #[serial]
    fn commit_timestamp_unix_override_works() {
        temp_env::with_var("VERGEN_GIT_COMMIT_TIMESTAMP_UNIX", Some("12345"), || {
            let result = || -> Result<()> {
                let git2 = Git2::builder().commit_timestamp_unix(true).build();
                let mut stdout_buf = vec![];
                _ = Emitter::default()
                    .add_instructions(&git2)?
                    .emit_to(&mut stdout_buf)?;
                let output = String::from_utf8_lossy(&stdout_buf);
                assert!(
                    output.contains("cargo:rustc-env=VERGEN_GIT_COMMIT_TIMESTAMP_UNIX=12345"),
                    "{output}"
                );
                Ok(())
            }();
            assert!(result.is_ok());
        });
    }
}