Struct Repository 

pub struct Repository<T> { /* private fields */ }

The repository side of a run, over whichever store holds its state.

The two flavours below are this one behaviour with a different store under it, so neither can learn something the other does not know.

Implementations

impl Repository<MemoryStore<VcsState>>

pub fn new() -> Self

A repository provider knowing nothing.

pub fn seeded(state: VcsState) -> Self

A repository provider that starts from a scenario.

pub fn state(&self) -> VcsState

Everything it knows.

impl Repository<FileStore<VcsState>>

pub fn create(path: impl Into<PathBuf>) -> Result<Self>

A repository provider keeping its state at path: whatever is already there, or nothing.

Attaching rather than replacing, so a second provider over the same path picks up what the first one left — which is what a journey driving several invocations reaches for this flavour to get.

pub fn seeded(path: impl Into<PathBuf>, state: VcsState) -> Result<Self>

A repository provider that starts from a scenario, keeping its state at path and replacing whatever was there.

pub fn state(&self) -> Result<VcsState>

Everything it knows, read back out of its document.

Trait Implementations

impl<T: Debug> Debug for Repository<T>

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

Formats the value using the given formatter.

impl<T: Store<VcsState>> Vcs for Repository<T>

fn publish( &self, token: &SessionToken, request: &PublishRequest, hosting: &dyn Hosting, ) -> Result<Publication>

Publish a session’s branch, as far as a provider honestly can.

The host side is performed rather than described: a change request is really opened against the Hosting this was handed, really adopted when one is already open, and really merged under the policy — so the six host methods are exercised and what the host recorded is what a journey reads back.

The repository side is not, and none of it is claimed. There is no origin to fetch from, no tree to run a gate in, no push, and no lock to queue behind, so no fetch, gate-started, gate-verdict, push, lock-wait, lock-acquired, or merge-queued event is emitted. What is emitted is what was decided: the change that was opened, and the merge that landed.

fn resolve_identity(&self, origin_or_path: &str) -> Result<Identity>

Resolve an origin URL or a checkout path to the repository identity it belongs to.

fn open_session(&self, req: SessionRequest) -> Result<Session>

Open a session: a per-run clone of an execution checkout and an isolated worktree cut from it, held under an occupancy lease.

fn adopt_session(&self, token: SessionToken) -> Result<Session>

Re-attach to a session that already exists, claiming its free occupancy lease.

fn preserve( &self, s: &Session, provenance: Provenance, ) -> Result<PreservedBranch>

Commit the session’s work onto a branch that outlives it, recording why.

fn session(&self, token: &SessionToken) -> Result<SessionRecord>

What this implementation recorded about a session it opened.

fn close_session(&self, token: &SessionToken) -> Result<Session>

Release a session’s worktree and its lease, keeping its branch.

fn recoverable(&self, scope: Scope) -> Result<Vec<Recoverable>>

Every preserved-but-unpublished branch in scope, and what would land each.