Struct Threshold 

pub struct Threshold {
    pub declared: Option<String>,
    pub seconds: Option<u64>,
    pub source: String,
}

The age past which uncommitted work nothing holds is abandoned, and where it came from.

It is reported with every reading, so a reader can see what the verdicts were judged against; a threshold nothing declares is carried as absent, not filled in.

use majordomus_cli::worktree::Threshold;
let declared = Threshold::resolve(Some("12h"), None).unwrap();
let wire = serde_json::to_value(&declared).unwrap();
assert_eq!(wire["declared"], "12h");
assert_eq!(wire["seconds"], 43_200);
let absent: Threshold =
    serde_json::from_value(serde_json::json!({"source": "absent"})).unwrap();
assert_eq!((absent.declared, absent.seconds), (None, None), "absent is not a default");

Fields

declared: Option<String>

The value as written (12h). Absent when nothing declares one.

seconds: Option<u64>

The same value, in seconds.

source: String

THRESHOLD_KEY, older_than when the caller named one, or absent.

Implementations

impl Threshold

pub fn resolve( declared: Option<&str>, older_than: Option<&str>, ) -> Result<Threshold, String>

The threshold from the caller’s own value when it gave one, else from the policy’s. A value that is not a duration is refused rather than read as none: a reading that judged against nothing would call no work abandoned and say so with confidence.

use majordomus_cli::worktree::Threshold;
let t = Threshold::resolve(Some("12h"), None).unwrap();
assert_eq!((t.seconds, t.source.as_str()), (Some(43_200), "session.stranded_after"));
let o = Threshold::resolve(Some("12h"), Some("30m")).unwrap();
assert_eq!((o.seconds, o.source.as_str()), (Some(1_800), "older_than"));
let none = Threshold::resolve(None, None).unwrap();
assert_eq!((none.seconds, none.source.as_str()), (None, "absent"));
assert!(Threshold::resolve(Some("soon"), None).is_err());

pub fn declared_at( root: &Path, older_than: Option<&str>, ) -> Result<Self, String>

The threshold a repository declares, or the caller’s own: the policy of the checkout at root is read for THRESHOLD_KEY, and a policy that cannot be read declares nothing.

use majordomus_cli::worktree::Threshold;
// a directory with no layer declares nothing, and the caller's own value still counts
let plain = tempfile::tempdir().unwrap();
let none = Threshold::declared_at(plain.path(), None).unwrap();
assert_eq!((none.seconds, none.source.as_str()), (None, "absent"));
let own = Threshold::declared_at(plain.path(), Some("2h")).unwrap();
assert_eq!((own.seconds, own.source.as_str()), (Some(7_200), "older_than"));
assert!(Threshold::declared_at(plain.path(), Some("later")).is_err());

Trait Implementations

impl Clone for Threshold

fn clone(&self) -> Threshold

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Threshold

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Threshold

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Threshold

impl JsonSchema for Threshold

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 Threshold

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

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 Threshold