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 build in, no push, and no lock to queue behind, so no fetch, 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 preserved(&self, scope: Scope) -> Result<Vec<Recoverable>>

The same rows Vcs::recoverable answers with.

This provider is handed its preserved work, and what it is handed is work nobody published: there is no base here whose history could record a landing and no tree to compare content against, so it withholds nothing and the wider question has the same answer as the narrower one.

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 clone of an execution checkout and an isolated worktree cut from it — a warm pool slot where the host keeps one, else cut for this run — 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.

fn publish_with_cancellation( &self, token: &SessionToken, request: &PublishRequest, hosting: &dyn Hosting, cancellation: &dyn PublicationCancellation, ) -> Result<Publication, Error>

publish, asking cancellation while it waits and ending as FailureKind::Cancelled once it says so.

fn recoverable_matching( &self, scope: Scope, selection: &Selection, ) -> Result<Vec<Recoverable>, Error>

recoverable, narrowed to the sessions a Selection names.

fn preserved_matching( &self, scope: Scope, selection: &Selection, ) -> Result<Vec<Recoverable>, Error>

preserved, narrowed the same way and for the same reason. Selection::detail changes presentation cost only: both detail modes keep the same rows, tip, landing evidence, holds, retirement and recovery command.