Enum Presented 

pub enum Presented {
    WorkingTree,
    #[non_exhaustive]
    Commit {
        commit: String,
        tree: TreeState,
    },
}

The revision a verdict is about.

Every verdict is a verdict at something, and saying which is half of the answer. The working tree is what a person at a terminal is looking at; the checked-out commit judged as committed is the reading a site built from that commit needs.

use majordomus_cli::evidence::freshness::Presented;

// the default of every existing reader: the checkout, with whatever it carries
let here = Presented::WorkingTree;
assert_eq!(here.commit(), None);

Variants

WorkingTree

The reader’s checkout: HEAD plus every tracked, staged and untracked change in it.

#[non_exhaustive]

Commit

The checked-out commit, judged as committed: its own ledger, its own tree. Only presented_commit builds one, because only it checks that the commit is the one checked out and measures the tree.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

commit: String

The full commit id.

tree: TreeState

Whether the checkout was that commit, ignoring the evidence ledger’s working copy, weakened by anything the caller knew.

Implementations

impl Presented

pub fn commit(&self) -> Option<&str>

The presented commit, when a commit rather than the working tree is presented.

use majordomus_cli::evidence::freshness::{presented_commit, Presented};
use std::process::Command;

let dir = tempfile::tempdir().unwrap();
let git = |args: &[&str]| {
    let out = Command::new("git").arg("-C").arg(dir.path()).args(args).output().unwrap();
    String::from_utf8_lossy(&out.stdout).trim().to_string()
};
git(&["init", "-q"]);
git(&["config", "user.email", "t@example.com"]);
git(&["config", "user.name", "t"]);
git(&["commit", "-q", "--allow-empty", "-m", "one"]);

let p = presented_commit(dir.path(), "HEAD", None).unwrap();
assert_eq!(p.commit(), Some(git(&["rev-parse", "HEAD"]).as_str()));
assert_eq!(Presented::WorkingTree.commit(), None);

pub fn tree(&self) -> TreeState

The presented tree as the truth table reads it: TreeState::Clean for the working tree, whose changes are already in the diff, and the measured tree for a commit.

use majordomus_cli::evidence::freshness::{Presented, TreeState};
assert_eq!(Presented::WorkingTree.tree(), TreeState::Clean);

Trait Implementations

impl Clone for Presented

fn clone(&self) -> Presented

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Presented

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

Formats the value using the given formatter.

impl Eq for Presented

impl PartialEq for Presented

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