Struct libojo::Repo

pub struct Repo {
    pub root_dir: PathBuf,
    pub repo_dir: PathBuf,
    pub db_path: PathBuf,
    pub current_branch: String,
    // some fields omitted
}

This is the main interface to a ojo repository.

Be aware that any modifications made to a repository will not be saved unless Repo::write is called.

Fields

root_dir: PathBuf

The path to the root directory of the repository.

repo_dir: PathBuf

The path to the directory where all of ojo's data is stored.

db_path: PathBuf

The path to the database containing all the history, and so on.

current_branch: String

The path to the directory where patches are stored. The name of the current branch.

Methods

impl Repo

pub fn open<P: AsRef<Path>>(dir: P) -> Result<Repo, Error>

Opens the existing repository with the given root directory.

pub fn init<P: AsRef<Path>>(path: P) -> Result<Repo, Error>

Creates a repo at the given path (which should point to a directory).

pub fn init_tmp() -> Repo

Creates a temporary in-memory repo that cannot be stored.

pub fn clear(&mut self, branch: &str) -> Result<(), Error>

Clears a branch, removing all of its patches.

pub fn write(&self) -> Result<(), Error>

Persists the repository to disk.

Any modifications that were previously made become permanent.

pub fn graggle<'a>(&'a self, branch: &str) -> Result<Graggle<'a>, Error>

Returns a read-only view to the data associated with a branch.

pub fn file(&self, branch: &str) -> Result<File, Error>

Retrieves the data associated with a branch, assuming that it represents a totally ordered file.

pub fn contents(&self, id: &NodeId) -> &[u8]

Retrieves the contents associated with a node.

pub fn open_patch(&self, id: &PatchId) -> Result<Patch, Error>

Opens a patch.

The patch must already be known to the repository, either because it was created locally (i.e. with Repo::create_patch) or because it was (possibly created elsewhere but) registered locally with Repo::register_patch.

pub fn open_patch_data(&self, id: &PatchId) -> Result<&[u8], Error>

Returns the data associated with a patch.

Currently, this data consists of the patch's contents serialized as YAML, but that isn't guaranteed. What is guaranteed is that the return value of this function is of the same format as the argument to Repo::register_patch.

pub fn register_patch(&mut self, patch_data: &[u8]) -> Result<PatchId, Error>

Introduces a patch to the repository.

After registering a patch, its data will be stored in the repository and you will be able to access it by its ID.

pub fn apply_patch(
    &mut self,
    branch: &str,
    patch_id: &PatchId
) -> Result<Vec<PatchId>, Error>

Applies a patch (and all its dependencies) to a branch.

Returns a list of all the patches that were applied.

pub fn unapply_patch(
    &mut self,
    branch: &str,
    patch_id: &PatchId
) -> Result<Vec<PatchId>, Error>

Unapplies a patch (and everything that depends on it) to a branch.

Returns a list of all the patches that were unapplied.

pub fn all_patches(&self) -> impl Iterator<Item = &PatchId>

Returns an iterator over all known patches, applied or otherwise.

pub fn patches(&self, branch: &str) -> impl Iterator<Item = &PatchId>

Returns an iterator over all of the patches being used in a branch.

pub fn patch_deps(&self, patch: &PatchId) -> impl Iterator<Item = &PatchId>

Returns an iterator over all direct dependencies of the given patch.

pub fn patch_rev_deps(&self, patch: &PatchId) -> impl Iterator<Item = &PatchId>

Returns an iterator over all direct dependents of the given patch.

pub fn create_patch(
    &mut self,
    author: &str,
    msg: &str,
    changes: Changes
) -> Result<PatchId, Error>

Creates a new patch with the given changes and metadata and returns its ID.

The newly created patch will be automatically registered in the current repository, so there is no need to call Repo::register_patch on it.

pub fn branches(&self) -> impl Iterator<Item = &str>

Returns an iterator over the names of all branches.

pub fn create_branch(&mut self, branch: &str) -> Result<(), Error>

Creates a new, empty branch.

pub fn clone_branch(&mut self, from: &str, to: &str) -> Result<(), Error>

Copies data to a new branch (which must not already exist).

pub fn delete_branch(&mut self, branch: &str) -> Result<(), Error>

Deletes the branch named branch.

pub fn switch_branch(&mut self, branch: &str) -> Result<(), Error>

Changes the current branch to the one named branch (which must already exist).

pub fn diff(&self, branch: &str, file: &[u8]) -> Result<Diff, Error>

If the given branch represents a totally ordered file (i.e. if Repo::file returns something), returns the result of diffing the given branch against file.

Trait Implementations

impl Debug for Repo

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

Formats the value using the given formatter.