Struct GitContext

pub struct GitContext<'a> {
    repo: &'a Repository,
    tree: Tree<'a>,
    commit: Commit<'a>,
    remote: Remote<'a>,
    remote_str: &'a str,
    root: Root,
    push_tasks: RefCell<JoinSet<Result<Vec<u8>, Error>>>,
    transport: Box<dyn Transport + Send>,
    progress: &'a Span,
}

Holds the shared context needed for publishing Atoms.

Fields

repo: &'a Repository

Reference to the repository we are publishing from.

tree: Tree<'a>

The repository tree object for the given commit.

commit: Commit<'a>

The commit to publish from.

remote: Remote<'a>

The configured remote repository.

remote_str: &'a str

The name of the remote, for convenient use.

root: Root

The reported root commit according to the remote.

push_tasks: RefCell<JoinSet<Result<Vec<u8>, Error>>>

A JoinSet of asynchronous push tasks to avoid blocking.

transport: Box<dyn Transport + Send>

A reusable Git server transport to avoid connection overhead.

progress: &'a Span

A span representing the overall progress bar for easy incrementing.

Implementations

impl<'a> GitContext<'a>

pub(super) fn find_and_verify_atom( &self, path: &Path, ) -> GitResult<(FoundAtom, AtomPaths<PathBuf>)>

Finds an Atom within the Git tree and verifies its manifest and structure.

This function ensures that the given path corresponds to a valid Atom by checking for the existence of the manifest and content tree, and validating the manifest’s contents.

pub fn transport(&mut self) -> &mut Box<dyn Transport + Send>

Provides mutable access to the underlying Git transport.

pub fn tree_search(&self, path: &Path) -> GitResult<Option<Entry<'a>>>

Searches for a tree entry at a given path starting from the context’s root tree.

Errors

Returns an error if the underlying gix::object::tree::Tree::lookup_entry call fails.

pub(super) fn verify_manifest( &self, obj: &Object<'_>, path: &Path, ) -> GitResult<Atom>

Reads an Atom manifest from a Git object and verifies its contents.

fn write_object(&self, obj: impl WriteTo) -> GitResult<ObjectId>

Writes a Git object to the repository’s object database.

impl<'a> GitContext<'a>

pub async fn await_pushes(&self, errors: &mut Vec<Error>)

Asynchronously awaits the results of concurrently running Git pushes.

Any errors that occurred during the push operations will be collected into the provided errors vector.

pub fn remote(&self) -> Remote<'a>

Returns a reference to the Git remote.

pub fn tree(&self) -> Tree<'a>

Returns a reference to the Git tree object of the commit the Atom originates from.

fn set( repo: &'a Repository, remote: Remote<'a>, remote_str: &'a str, refspec: &str, root: Root, transport: Box<dyn Transport + Send>, progress: &'a Span, ) -> GitResult<Self>

Trait Implementations

impl<'a> Publish<Root> for GitContext<'a>

fn publish<C>( &self, paths: C, remotes: HashMap<Label, (Version, ObjectId)>, ) -> Vec<GitResult<GitOutcome>>

where C: IntoIterator<Item = PathBuf>,

Publishes a collection of Atoms to the Git store.

This function processes a collection of paths, each representing an Atom to be published. The publishing process includes path normalization, existence checks, and the actual publishing attempt.

Path Normalization

• First attempts to interpret each path as relative to the caller’s current location inside the repository.
• If normalization fails (e.g., in a bare repository), it falls back to treating the path as already relative to the repository root.
• The normalized path is used to search the Git history, not the local file system.

Publishing Process

For each path:

1. Normalizes the path as described above.
2. Checks if the Atom already exists in the repository and on the remote.
   • If it exists and is identical, the Atom is skipped.
3. Attempts to publish the Atom.
   • On success, the Atom’s content and references are pushed to the remote.
   • On failure, the Atom is skipped, and an error is logged.

Error Handling

• The function processes all provided paths, even if some fail.
• Errors and skipped Atoms are collected as results but do not halt the overall process.

Return Value

Returns a vector of GitResult<GitOutcome>, where each item represents the result of a single Atom’s publishing attempt.

type Error = Error

The error type returned by the publisher.

type Id = ObjectId

The type representing the machine-readable identity for a specific version of an atom.

fn publish_atom<P: AsRef<Path>>( &self, path: P, remotes: &HashMap<Label, (Version, ObjectId)>, ) -> GitResult<GitOutcome>

Publishes a single atom.

impl<'a> Sealed for GitContext<'a>