Struct PlanFingerprint 

pub struct PlanFingerprint {
    pub repository: String,
    pub worktree: String,
    pub head: String,
    pub changes: String,
}

What a plan was derived from.

Compared, never trusted: a plan whose fingerprint differs from the tree in front of it describes a tree that no longer exists.

use majordomus_cli::commit::{PlanFingerprint, WorkingTreeState};
let f = PlanFingerprint::of("/repo/.git", "/repo", &WorkingTreeState::default());
assert_eq!(f.head, "unborn", "a repository with no commits says so");

Fields

repository: String

The repository: git’s common directory, which every worktree of one repository shares and no two repositories do.

worktree: String

The worktree: this checkout’s own path. Two worktrees of one repository have the same repository and different worktrees, which is what keeps their plans apart.

head: String

HEAD when the plan was derived, or unborn.

changes: String

SHA-256 over every change, its stage and its status, in order. Restaging one file changes it; touching a file the plan does not contain does not.

Implementations

impl PlanFingerprint

pub fn of( repository: &str, worktree: &str, tree: &WorkingTreeState, ) -> PlanFingerprint

The fingerprint of a tree as it stands.

use majordomus_cli::commit::{PlanFingerprint, WorkingTreeState};
let a = PlanFingerprint::of("/r/.git", "/r", &WorkingTreeState::default());
let b = PlanFingerprint::of("/r/.git", "/r", &WorkingTreeState::default());
assert_eq!(a, b, "deterministic over one tree");

pub fn differs_from(&self, now: &PlanFingerprint) -> Option<String>

Why this fingerprint does not describe now, or None when it does.

A sentence rather than a boolean, because “the plan is stale” is not an answer anybody can act on and “HEAD moved from a1b2c3d to e4f5a6b” is.

use majordomus_cli::commit::{PlanFingerprint, WorkingTreeState};
let mut then = WorkingTreeState::default();
then.head = Some("a1b2c3d4e5f6".into());
let mut now = then.clone();
now.head = Some("ffffffffffff".into());
let why = PlanFingerprint::of("/r/.git", "/r", &then)
    .differs_from(&PlanFingerprint::of("/r/.git", "/r", &now))
    .expect("HEAD moved");
// a sentence, because "the plan is stale" is not something anybody can act on
assert!(why.contains("HEAD moved"), "{why}");

Trait Implementations

impl Clone for PlanFingerprint

fn clone(&self) -> PlanFingerprint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PlanFingerprint

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PlanFingerprint

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for PlanFingerprint

impl JsonSchema for PlanFingerprint

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 PlanFingerprint

fn eq(&self, other: &PlanFingerprint) -> 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 PlanFingerprint

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 PlanFingerprint