Struct RepoIdent 

pub struct RepoIdent {
    pub workdir: Option<PathBuf>,
    pub commondir: Option<PathBuf>,
    pub remote: Option<String>,
}

Git’s own answer to “what repo is this”, discovered once per invocation.

commondir is git’s shared git-dir: for a linked worktree this is the main checkout’s .git/, so every worktree of one clone reads the same remote and hashes to the same slug — worktrees share history, so they share a store. For a submodule it is the submodule’s own private dir under .git/modules/, carrying the submodule’s own remote and therefore its own, different slug — a submodule is a different repo with a disjoint path namespace, so its file:* keys must never land in the parent’s store.

workdir is None for a bare repository (no working tree to resolve record paths against) or when no repo is discoverable at all.

Fields

workdir: Option<PathBuf>

commondir: Option<PathBuf>

remote: Option<String>

Implementations

impl RepoIdent

pub fn discover(path: &Path) -> Self

Discover the identity of the repo containing (or rooted at) path. One git2::Repository::discover call.

A caller that needs more than one derived value (Self::slug, Self::slug_root, a worktree tag, …) for the same invocation should discover once and reuse the result rather than calling this again — see cli::hook_decide::entry::run_inner.

pub fn discover_with_repo(path: &Path) -> (Self, Option<Repository>)

Self::discover, plus the live git2::Repository handle for a caller that also needs actual git operations (blob/commit lookups), not just identity facts — e.g. crate::health::staleness::StalenessAnalyzer. Still exactly one discover call.

pub fn slug(&self, fallback_path: &Path) -> String

The slug this identity hashes to: the first 8 hex characters of SHA-256(remote URL); falling back to SHA-256(workdir) when the repo has no remote; falling back further to SHA-256(canonicalized fallback_path) when git found no working tree to key on at all — no repo, or a bare one.

The no-remote fallback hashes workdir itself, never a git-internal path like commondir: a .git that is itself a symlink must not leak its target’s location into the project’s identity, and hashing the same field Self::slug_root returns makes the two agree by construction rather than by two independent computations that merely happen to match.

pub fn slug_root(&self, fallback_path: &Path) -> PathBuf

The root record paths resolve against: Self::workdir, or the canonicalized fallback_path when there is none (no repo, or a bare one — a bare repo has no working tree to offer).

A bare repo’s fallback_path is its own location, never an ancestor’s: discover recognizes a bare repository in its own right and does not walk past it looking for an enclosing one, so a bare clone nested under an unrelated working repo can never inherit that repo’s root (or its store).

Trait Implementations

impl Clone for RepoIdent

fn clone(&self) -> RepoIdent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RepoIdent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RepoIdent

fn default() -> RepoIdent

Returns the “default value” for a type.

impl Eq for RepoIdent

impl PartialEq for RepoIdent

fn eq(&self, other: &RepoIdent) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RepoIdent