HTTP API: session_domain

Kde epizoda je: vytvořena, otevřena, odpojena od spojení, které ji drželo, nebo uzavřena do neměnného záznamu.

use majordomus_cli::session::EpisodeState;

assert!(EpisodeState::Open.may_move_to(EpisodeState::Closed));
assert!(!EpisodeState::Closed.may_move_to(EpisodeState::Open), "a record is immutable");
assert!(EpisodeState::Open.may_move_to(EpisodeState::Open), "a resume is not a move");
assert!(EpisodeState::Closed.is_final());

Jedna identita tohoto checkoutu tak, jak ji tento program počítá a jak ji zapisuje každé úložiště. To, na co odpovídá session.identity, a přímá projekce tabulky auditu.

use majordomus_cli::session::{identities, IdentityFacet};

let dir = tempfile::tempdir().unwrap();
let facets: Vec<IdentityFacet> = identities(dir.path());
let repository = facets.iter().find(|f| f.subject == "repository").expect("a facet");
assert!(repository.spellings.len() >= 2, "one word, two writers, two values");

Identity tohoto checkoutu: jedna fazeta na subjekt, se stálou poznámkou o tom, co s nimi čtenář nesmí dělat.

use majordomus_cli::capability::builtin::IdentityReport;
use majordomus_cli::session::identities;

let dir = tempfile::tempdir().unwrap();
let report = IdentityReport {
    checkout: dir.path().display().to_string(),
    facets: identities(dir.path()),
    findings: Vec::new(),
};
let subjects: Vec<&str> = report.facets.iter().map(|f| f.subject.as_str()).collect();
assert_eq!(subjects, ["repository", "checkout", "episode", "provider_session"]);

Stroj životního cyklu, s rozhodnutím, které implementuje, aby čtenář, který ho potká v projekci, mohl jít a přečíst si, proč má takový tvar.

use majordomus_cli::capability::builtin::MachineReport;
use majordomus_cli::session::Machine;

// the report is the machine plus one citation; the machine itself is derived from the
// types and carries no second list
let report = MachineReport { machine: Machine::describe(), decision: "adr-0047".into() };
assert!(report.machine.transitions.iter().any(|t| !t.moves_state), "a checkpoint is an event");
assert!(report.decision.contains("0047"));

Zápis jednoho předmětu v jednom úložišti. Která polovina vrstvy ho zapsala, co ho zapsalo a hodnota, kterou by zde měl.

use majordomus_cli::session::{RecordedSpelling, Spelling};

let local = RecordedSpelling {
    spelling: Spelling::Local,
    writer: "mj_git_repo_id (lib/common.sh)".into(),
    value: "/src/repo/.git".into(),
};
// knowing which half a string came from is what stops a path being compared with a URL
assert_eq!(local.spelling.as_str(), "local");
assert!(local.value.starts_with('/'));

Z kterého úložiště byla zaznamenaná identita přečtena, uchováno vedle hodnoty.

Nejde o to volit mezi mj_git_repo_id a mj_repository_id nebo mezi worktree: a worktree_id:. Jde o to přestat předstírat, že jsou jednou hodnotou. Čtenář, který ví, že řetězec je lokální zápis, jej může porovnat s jinými lokálními zápisy a může odmítnout porovnat jej se sdíleným, což je přesně srovnání, které vyrobilo „tyto dva záznamy jsou o různých repozitářích“ u záznamů téhož repozitáře napsaných s odstupem čtyř minut.

use majordomus_cli::session::Spelling;
// the two halves are different answers to one question, and are never compared
assert_ne!(Spelling::Local, Spelling::Shared);
assert_eq!(Spelling::Canonical.as_str(), "canonical");

Jeden stav stroje: jeho slovo, zda z něj epizoda někdy odchází a kam může odtud jít.

use majordomus_cli::session::{EpisodeState, Machine, StateView};

let m = Machine::describe();
let closed: &StateView =
    m.states.iter().find(|s| s.state == EpisodeState::Closed).expect("a state");
assert!(closed.terminal && closed.may_move_to.is_empty());

Co epizodu pohnulo. Slovník, který potřebuje audit ADR 0052: open, resume, checkpoint, detach, close, recover.

Jeden z nich stav nemění a přesto je přechodem. Checkpoint nechává otevřenou epizodu otevřenou — ale je to jedna ze dvou událostí, jejichž absence je to, co audit hledal, a událost modelovanou jako „nic se nestalo“ nelze spočítat. Šest dní ticha bylo šest dní, kdy session.started a session.closed nadále přicházely a dvě události, které vytvářejí záznamy, z nichž pracovník pokračuje, ne. Slovník, ve kterém tyto dvě nejsou události, je slovník, ve kterém je ten výpadek neviditelný.

use majordomus_cli::session::{EpisodeState, Transition};

// a checkpoint is a transition that does not move the state, and says so
let c = Transition::Checkpoint;
assert_eq!(c.from_to(), (EpisodeState::Open, EpisodeState::Open));
assert!(!c.moves_state());

// a resume is canonically the return to a detached episode; a provider's start event
// arriving at one that is already open is the same transition seen from `Open`, which
// the machine allows without a move
assert_eq!(Transition::Resume.from_to(), (EpisodeState::Detached, EpisodeState::Open));
assert!(EpisodeState::Open.may_move_to(EpisodeState::Open));

// and every transition's own move is one the machine allows
for t in Transition::ALL {
    let (from, to) = t.from_to();
    assert!(from.may_move_to(to), "{} is not a legal move", t.as_str());
}

Jeden přechod stroje: jeho slovo, stavy, mezi nimiž běží, a zda vůbec mění stav.

use majordomus_cli::session::{Machine, Transition, TransitionView};

let m = Machine::describe();
let close: &TransitionView = m
    .transitions
    .iter()
    .find(|t| t.transition == Transition::Close)
    .expect("a transition");
assert!(close.moves_state);