Struct UncommittedWorktree 

pub struct UncommittedWorktree {

    pub path: String,
    pub branch: Option<String>,
    pub label: String,
    pub work: DirtyState,
    pub paths: usize,
    pub oldest_change: Option<String>,
    pub age_seconds: Option<u64>,
    pub age: Option<String>,
    pub task: Option<String>,
    pub episodes: Vec<OpenEpisode>,
    pub process_inside: Option<bool>,
    pub held_by: Vec<String>,
    pub standing: WorkStanding,
    pub remedy: String,
}

One linked work tree holding uncommitted work: how much, how old, what holds it, the verdict, and the command that would preserve it. A listing is in canonical order — abandoned first, then recent, then held, the oldest first inside each.

use majordomus_cli::worktree::{DirtyState, UncommittedWorktree, WorkStanding};
let entry = |path: &str, standing: WorkStanding, age: u64| UncommittedWorktree {
    path: path.into(),
    branch: None,
    label: path.into(),
    work: DirtyState { staged: 1, ..DirtyState::default() },
    paths: 1,
    oldest_change: None,
    age_seconds: Some(age),
    age: None,
    task: None,
    episodes: Vec::new(),
    process_inside: None,
    held_by: Vec::new(),
    standing,
    remedy: String::new(),
};
let mut listing = vec![
    entry("/wt/held-old", WorkStanding::Held, 900_000),
    entry("/wt/young", WorkStanding::Abandoned, 50_000),
    entry("/wt/older", WorkStanding::Abandoned, 90_000),
];
majordomus_cli::order::canonical(&mut listing);
let paths: Vec<&str> = listing.iter().map(|w| w.path.as_str()).collect();
assert_eq!(paths, ["/wt/older", "/wt/young", "/wt/held-old"]);

Fields

path: String

Absolute, as git holds it.

branch: Option<String>

The branch checked out there. Absent when detached.

label: String

The branch, or detached/<short commit>.

work: DirtyState

The counts, as worktree status gives them.

paths: usize

Every changed path: staged, unstaged, untracked and conflicted together.

oldest_change: Option<String>

When the oldest change was made: the earliest modification time among the changed paths, the index file’s standing in for a path that no longer exists. RFC 3339.

age_seconds: Option<u64>

Seconds since then.

age: Option<String>

The same, for a person (3d, 5h, 40m).

task: Option<String>

The active task recorded there.

episodes: Vec<OpenEpisode>

The episodes open there.

process_inside: Option<bool>

A process has its working directory inside it. Absent when that could not be read.

held_by: Vec<String>

What holds it, in words; empty when nothing does.

standing: WorkStanding

The verdict.

remedy: String

The command that would put this work on a remote ref. Suggested, never run.

Trait Implementations

impl Clone for UncommittedWorktree

fn clone(&self) -> UncommittedWorktree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UncommittedWorktree

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for UncommittedWorktree

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for UncommittedWorktree

impl JsonSchema for UncommittedWorktree

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 Ordered for UncommittedWorktree

Abandoned work first, then recent, then held; inside each, the oldest first; the path breaks a tie, so two readings of one disk list it in one order.

fn order_key(&self) -> OrderKey<'_>

The four parts this item is ordered by. Borrowed from the item: building a key allocates nothing, so sorting a large collection costs the comparisons and no more.

impl PartialEq for UncommittedWorktree

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

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 UncommittedWorktree