Struct GitIdentity 

pub struct GitIdentity {
    pub common_dir: PathBuf,
    pub id: String,
    pub linked: bool,
}

The git repository a checkout belongs to, as distinct from the checkout itself.

identity names a checkout: one server, one lease, one index per checkout root. Every linked worktree of one git repository is a checkout of its own by that measure, and nothing in it said that they belong together. This does: the git directory every work tree shares (git rev-parse --git-common-dir) is the repository’s identity, its digest is one value for every checkout of that repository, and linked says whether this checkout is the primary one or a work tree hanging off it. None where git cannot be asked: a repository of the layer does not have to be version controlled.

use majordomus_cli::repository::{git_identity, identity, GitIdentity};
use std::process::Command;
let dir = tempfile::tempdir().unwrap();
let root = dir.path().join("repo");
std::fs::create_dir_all(&root).unwrap();
let git = |args: &[&str]| assert!(Command::new("git").arg("-C").arg(&root).args(args).status().unwrap().success());
git(&["init", "-q", "."]);
git(&["-c", "user.email=t@example.com", "-c", "user.name=t", "commit", "-q", "--allow-empty", "-m", "init"]);
let wt = dir.path().join("repo-wt");
git(&["worktree", "add", "-q", "-b", "feature/x", wt.to_str().unwrap()]);

let primary: GitIdentity = git_identity(&root).expect("a work tree");
let linked: GitIdentity = git_identity(&wt).expect("a linked work tree");
assert_eq!(primary.id, linked.id, "one repository");
assert_ne!(identity(&root), identity(&wt), "two checkouts");
assert!(!primary.linked && linked.linked);
assert!(!primary.id.contains('/'), "a digest, never a path");

Fields

common_dir: PathBuf

The git directory every work tree of the repository shares, canonical.

id: String

Its digest: the same for every checkout of one repository, different across repositories, and never a path.

linked: bool

Whether this checkout is a linked work tree rather than the primary one.

Trait Implementations

impl Clone for GitIdentity

fn clone(&self) -> GitIdentity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GitIdentity

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GitIdentity

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for GitIdentity

impl JsonSchema for GitIdentity

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for GitIdentity

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for GitIdentity

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for GitIdentity