[[package]]

name = "base64"

version = "0.21.7"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"

[[package]]

name = "git-ref-format"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "git-ref-format-core",

 "git-ref-format-macro",

[[package]]

name = "git-ref-format-core"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "bstr",

 "serde",

[[package]]

name = "git-ref-format-macro"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "git-ref-format-core",

 "quote",

 "syn 2.0.89",

]

[[package]]

name = "nonempty"

version = "0.9.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "995defdca0a589acfdd1bd2e8e3b896b4d4f7675a31fd14c32611440c7f608e6"

]

[[package]]

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "proc-macro2",

 "quote",

]

[[package]]

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "proc-macro2",

 "quote",

]

[[package]]

 "localtime",

 "log",

 "multibase",

 "pretty_assertions",

 "qcheck",

 "qcheck-macros",

 "radicle-cob",

 "radicle-crypto",

 "radicle-ssh",

 "schemars",

 "serde",

 "chrono",

 "clap",

 "dunce",

 "human-panic",

 "itertools",

 "lexopt",

 "localtime",

 "log",

 "pretty_assertions",

 "radicle",

 "radicle-cli-test",

 "radicle-cob",

 "radicle-crypto",

 "radicle-node",

 "radicle-surf",

 "radicle-term",

 "fastrand",

 "git2",

 "log",

 "qcheck",

 "qcheck-macros",

 "radicle-crypto",

 "multibase",

 "qcheck",

 "qcheck-macros",

 "radicle-ssh",

 "serde",

 "signature 2.2.0",

 "gix-protocol",

 "gix-transport",

 "log",

 "radicle",

 "thiserror 1.0.69",

]

[[package]]

name = "radicle-git-ext"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "git-ref-format",

 "git2",

 "localtime",

 "log",

 "netservices",

 "qcheck",

 "qcheck-macros",

 "radicle",

 "radicle-crypto",

 "radicle-fetch",

 "radicle-protocol",

 "radicle-signals",

 "radicle-systemd",

 "fastrand",

 "localtime",

 "log",

 "paste",

 "qcheck",

 "qcheck-macros",

 "radicle",

 "radicle-crypto",

 "radicle-fetch",

 "scrypt",

 "serde",

 "serde_json",

 "radicle",

 "radicle-cli",

 "radicle-crypto",

 "thiserror 1.0.69",

]

[[package]]

name = "radicle-std-ext"

source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]

name = "radicle-surf"

source = "registry+https://github.com/rust-lang/crates.io-index"

dependencies = [

 "anyhow",

 "flate2",

 "git2",

 "log",

 "radicle-git-ext",

 "radicle-std-ext",

 "tar",

cyphernet = "0.5.2"

dunce = "1.0.5"

fastrand = { version = "2.0.0", default-features = false }

git2 = { version = "0.19.0", default-features = false }

human-panic = "2"

itertools = "0.14"

radicle-crypto = { version = "0.13", path = "crates/radicle-crypto" }

radicle-dag = { version = "0.10", path = "crates/radicle-dag" }

radicle-fetch = { version = "0.15", path = "crates/radicle-fetch" }

radicle-git-ref-format = { version = "0.1.0", path = "crates/radicle-git-ref-format", default-features = false }

radicle-git2-metadata = { version = "0.1.0", path = "crates/radicle-git2-metadata", default-features = false }

radicle-node = { version = "0.15", path = "crates/radicle-node" }

winpipe = "0.1.1"

zeroize = "1.5.7"

[workspace.lints]

clippy.type_complexity = "allow"

clippy.enum_variant_names = "allow"

chrono = { workspace = true, features = ["clock", "std"] }

clap = { version = "4.5.44", features = ["derive"] }

dunce = { workspace = true }

human-panic.workspace = true

itertools.workspace = true

lexopt = { workspace = true }

localtime = { workspace = true }

log = { workspace = true, features = ["std"] }

nonempty = { workspace = true }

radicle-cob = { workspace = true }

radicle-crypto = { workspace = true }

radicle-term = { workspace = true }

schemars = { workspace = true }

serde = { workspace = true }

pub fn setup_remote(

    setup: &project::SetupRemote,

    remote_id: &NodeId,

    aliases: &impl AliasStore,

    let remote_name = if let Some(name) = remote_name {

        name

    } else {

        } else {

            remote_id.to_human()

        };

            .map_err(|_| anyhow!("invalid remote name: '{name}'"))?

    };

    let (remote, branch) = setup.run(&remote_name, *remote_id)?;

use radicle::patch::cache::Patches as _;

use thiserror::Error;

use radicle::identity::doc;

use radicle::identity::doc::RepoId;

use radicle::node;

}

struct Success {

    repository: storage::git::Repository,

    doc: Doc,

    project: Project,

use anyhow::anyhow;

use radicle::rad;

use radicle_surf as surf;

        })

        .collect::<Result<Vec<_>, _>>()?;

    opts.patience(true)

        .minimal(true)

        .context_lines(options.unified as u32);

    find_opts.exact_match_only(true);

    find_opts.all(true);

    let current = serde_json::to_string_pretty(&current.doc)?;

    let tmp = tempfile::tempdir()?;

        tmp.path(),

            .external_template(false)

            .bare(true),

    )?;

        None

    };

    let current = radicle::git::write_tree(&doc::PATH, current.as_bytes(), &repo)?;

    opts.context_lines(u32::MAX);

    let diff = repo.diff_tree_to_tree(previous.as_ref(), Some(&current), Some(&mut opts))?;

use anyhow::anyhow;

use localtime::LocalTime;

use radicle::cob::TypedId;

use radicle::identity::Identity;

use radicle::issue::cache::Issues as _;

use radicle::node::notifications;

use radicle::crypto::ssh;

use radicle::explorer::ExplorerUrl;

use radicle::identity::project::ProjectName;

use radicle::identity::{Doc, RepoId, Visibility};

use radicle::node::events::UploadPack;

    let path = options.path.as_deref().unwrap_or(cwd.as_path());

    let repo = match git::Repository::open(path) {

        Ok(r) => r,

            anyhow::bail!("a Git repository was not found at the given path")

        }

        Err(e) => return Err(e.into()),

    #[error("in detached HEAD state")]

    Head,

    #[error("could not determine default branch in repository: {0}")]

}

    match find_init_default_branch(repo).ok().flatten() {

        Some(refname) => Ok(refname),

        None => Ok(find_repository_head(repo)?),

    }

}

    let config = repo.config().and_then(|mut c| c.snapshot())?;

    let default_branch = config.get_str("init.defaultbranch")?;

    Ok(branch.into_reference().shorthand().map(ToOwned::to_owned))

}

    match repo.head() {

        Err(e) => Err(DefaultBranchError::Git(e)),

        Ok(head) => head

            .shorthand()

use radicle::cob::patch::PatchId;

use radicle::cob::{patch, Label, Reaction};

use radicle::patch::cache::Patches as _;

use radicle::storage::git::transport;

use radicle::{prelude::*, Node};

use anyhow::anyhow;

use radicle::cob::patch;

use radicle::cob::patch::RevisionId;

use radicle::patch::cache::Patches as _;

use radicle::patch::PatchId;

use radicle::storage::git::Repository;

            Some(refname) => Ok(Qualified::from_refstr(refname)

                .map_or_else(|| refname.clone(), |q| q.to_ref_string())),

            // SAFETY: Patch IDs are valid refstrings.

                .join(RefString::try_from(term::format::cob(id).item).unwrap())),

        }

    }

    patch_id: &PatchId,

    revision_id: Option<RevisionId>,

    stored: &Repository,

    profile: &Profile,

    opts: Options,

) -> anyhow::Result<()> {

    let mut spinner = term::spinner("Performing checkout...");

    let patch_branch = opts.branch(patch_id)?;

            }

    if opts.force {

        builder.force();

        working.checkout_tree(commit.as_object(), Some(&mut builder))?;

    } else {

fn find_patch_commit<'a>(

    revision: &patch::Revision,

    stored: &Repository,

    match working.find_commit(head) {

        Ok(commit) => Ok(commit),

            let output = git::process::fetch_pack(

                Some(working.path()),

                stored,

use radicle::cob::patch::{PatchId, RevisionId, Verdict};

use radicle::git;

use radicle::prelude::*;

use radicle::storage::git::Repository;

            hunk,

        } if by_hunk => {

            crate::warning::obsolete("rad patch review --patch");

            opts.patience(true)

                .minimal(true)

                .context_lines(unified as u32);

use radicle::cob::{CodeLocation, CodeRange};

use radicle::crypto;

use radicle::git;

use radicle::node::device::Device;

use radicle::prelude::*;

use radicle::storage::git::{cob::DraftStore, Repository};

use radicle_surf::diff::*;

use radicle_term::{Element, VStack};

    fn paths(&self) -> (Option<(&Path, Oid)>, Option<(&Path, Oid)>) {

        match self {

            Self::FileMoved { moved } => (

            ),

            Self::FileCopied { copied } => (

            ),

            Self::FileModified { path, old, new, .. } => {

            }

            Self::FileEofChanged { path, old, new, .. } => {

            }

            Self::FileModeChanged { path, old, new, .. } => {

            }

        }

    }

        }

    }

        let mut buf = Vec::new();

        let mut writer = unified_diff::Writer::new(&mut buf);

        writer.encode(&self.header)?;

        }

        drop(writer);

    }

}

/// of changes introduced by a patch.

pub struct Brain<'a> {

    /// Where the review draft is being stored.

    /// The commit pointed to by the ref.

    /// The tree of accepted changes pointed to by the head commit.

}

impl<'a> Brain<'a> {

    fn new(

        patch: PatchId,

        remote: &NodeId,

        let refname = Self::refname(&patch, remote);

        let author = repo.signature()?;

        let oid = repo.commit(

    fn load(

        patch: PatchId,

        remote: &NodeId,

        // TODO: Validate this leads to correct UX for potentially abandoned drafts on

        // past revisions.

        let refname = Self::refname(&patch, remote);

    }

    /// Accept changes to the brain.

        let mut index = repo.apply_to_tree(&self.accepted, &diff, None)?;

        let accepted = index.write_tree_to(repo)?;

        self.accepted = repo.find_tree(accepted)?;

    }

    /// Get the brain's refname given the patch and remote.

        git::refs::storage::draft::review(remote, patch)

    }

}

    pub fn run<G>(

        self,

        revision: &Revision,

        signer: &Device<G>,

    ) -> anyhow::Result<()>

    where

    fn diff(

        &self,

    ) -> Result<Diff, Error> {

        find_opts.exact_match_only(true);

        find_opts.all(true);

        find_opts.copies(false); // We don't support finding copies at the moment.

    #[error(transparent)]

    Format(#[from] std::fmt::Error),

    #[error(transparent)]

}

#[derive(Debug)]

use std::process;

use radicle::cob::patch;

use radicle::storage::git::Repository;

use crate::terminal as term;

    verbose: bool,

    profile: &Profile,

    stored: &Repository,

) -> anyhow::Result<()> {

    let patches = term::cob::patches(profile, stored)?;

    let Some(patch) = patches.get(patch_id).map_err(|e| Error::WithHint {

use radicle::cob::patch;

use radicle::prelude::*;

use radicle::storage::git::Repository;

use crate::terminal as term;

use crate::terminal::patch::*;

/// Run patch update.

pub fn run(

    patch_id: patch::PatchId,

    message: term::patch::Message,

    profile: &Profile,

    repository: &Repository,

) -> anyhow::Result<()> {

    // `HEAD`; This is what we are proposing as a patch.

    let head_branch = try_branch(workdir.head()?)?;

    let head_oid = branch_oid(&head_branch)?;

    let base_oid = match base_id {

        Some(oid) => oid,

    };

    // N.b. we don't update if both the head and base are the same as

    // any previous revision

    if patch

        .revisions()

    {

        return Ok(());

    }

    let (_, revision) = patch.latest();

    let message = term::patch::get_update_message(message, workdir, revision, &head_oid)?;

    let signer = term::signer(profile)?;

    term::print(revision);

use anyhow::anyhow;

use radicle::prelude::NodeId;

use radicle::storage::ReadStorage;

use std::str::FromStr;

use radicle::prelude::*;

use radicle::Profile;

use radicle_crypto::PublicKey;

    name: Option<RefString>,

    tracking: Option<BranchName>,

    profile: &Profile,

    fetch: bool,

    sync: bool,

) -> anyhow::Result<()> {

            let remote = remote?;

            let sigrefs = repo.reference_oid(&remote, &git::refs::storage::SIGREFS_BRANCH)?;

            let mut walk = repo.raw().revwalk()?;

            stats.local.pushes += walk.count();

            stats.local.forks += 1;

use anyhow::{anyhow, Context as _};

use radicle::git;

use radicle::prelude::{NodeId, RepoId};

use radicle::storage::{ReadRepository, ReadStorage};

pub struct Options {

    rid: Option<RepoId>,

    target: Option<git::Oid>,

    nid: Option<NodeId>,

    interval: time::Duration,

        let mut rid = None;

        let mut nid: Option<NodeId> = None;

        let mut target: Option<git::Oid> = None;

        let mut interval: Option<time::Duration> = None;

        let mut timeout: time::Duration = time::Duration::MAX;

            thread::sleep(options.interval);

            let oid = reference(&repo, &nid, &qualified)?;

            if oid != initial {

                break;

            }

            if now.elapsed()? >= options.timeout {

fn reference<R: ReadRepository>(

    repo: &R,

    nid: &NodeId,

    match repo.reference_oid(nid, qual) {

        Ok(oid) => Ok(Some(oid)),

        Err(e) => Err(e),

    }

}

use radicle::crypto::ssh;

use radicle::git;

use radicle::git::{Version, VERSION_REQUIRED};

use radicle::prelude::{NodeId, RepoId};

use radicle::storage::git::transport;

    build::CheckoutBuilder, AnnotatedCommit, Commit, Direction, ErrorCode, MergeAnalysis,

};

pub const CONFIG_COMMIT_GPG_SIGN: &str = "commit.gpgsign";

use std::path::{Path, PathBuf};

use radicle::git;

use radicle_surf::diff;

use radicle_surf::diff::{Added, Copied, Deleted, FileStats, Hunks, Modified, Moved};

use radicle_surf::diff::{Diff, DiffContent, FileDiff, Hunk, Modification};

/// A repository of Git blobs.

pub trait Repo {

    /// Lookup a blob from the repo.

    /// Lookup a file in the workdir.

    fn file(&self, path: &Path) -> Option<Blob>;

}

        if blob.is_binary() {

            Ok(Blob::Binary)

        repo: &R,

    ) -> Self::Output {

        let old = None;

        pretty_modification(header, &self.diff, old, new, repo, hi)

    }

        header: &Self::Context,

        repo: &R,

    ) -> Self::Output {

        let new = None;

        pretty_modification(header, &self.diff, old, new, repo, hi)

        header: &Self::Context,

        repo: &R,

    ) -> Self::Output {

        pretty_modification(header, &self.diff, old, new, repo, hi)

    }

    use term::Element;

    use super::*;

    #[test]

    #[ignore]

use radicle_surf::diff::FileStats;

use thiserror::Error;

use radicle_surf::diff;

use radicle_surf::diff::{Diff, DiffContent, DiffFile, FileDiff, Hunk, Hunks, Line, Modification};

        r.read_to_string(&mut s)?;

            .map_err(|e| Error::syntax(format!("decoding unified diff: {e}")))?;

        let d =

            Diff::try_from(d).map_err(|e| Error::syntax(format!("decoding unified diff: {e}")))?;

use radicle::prelude::*;

use crate::git;

use radicle::node::NodeId;

/// Setup a repository remote and tracking branch.

use radicle::cob::{self, issue, patch};

use radicle::crypto;

use radicle::node::{Address, Alias};

use radicle::prelude::{Did, NodeId, RepoId};

use radicle::cob::patch;

use radicle::cob::Title;

use radicle::git;

use radicle::patch::{Patch, PatchId};

use radicle::prelude::Profile;

use radicle::storage::git::Repository;

    #[error(transparent)]

    Fmt(#[from] fmt::Error),

    #[error("git: {0}")]

    #[error("i/o error: {0}")]

    Io(#[from] io::Error),

    #[error("invalid utf-8 string")]

}

/// Create a helpful default `Patch` message out of one or more commit messages.

    let mut commits = commits.into_iter().rev();

    let count = commits.len();

    let Some(commit) = commits.next() else {

/// Return commits between the merge base and a head.

pub fn patch_commits<'a>(

    base: &git::Oid,

    head: &git::Oid,

    let mut commits = Vec::new();

    let mut revwalk = repo.revwalk()?;

    revwalk.push_range(&format!("{base}..{head}"))?;

/// The message shown in the editor when creating a `Patch`.

fn create_display_message(

    base: &git::Oid,

    head: &git::Oid,

) -> Result<String, Error> {

/// The user can bail out if an empty title is entered.

pub fn get_create_message(

    message: term::patch::Message,

    base: &git::Oid,

    head: &git::Oid,

) -> Result<(Title, String), Error> {

/// The message shown in the editor when updating a `Patch`.

fn update_display_message(

) -> Result<String, Error> {

        return Ok(REVISION_MSG.trim_start().to_string());

    }

/// Get a patch update message.

pub fn get_update_message(

    message: term::patch::Message,

    latest: &patch::Revision,

    head: &git::Oid,

) -> Result<String, Error> {

}

/// List the given commits in a table.

    commits

        .iter()

        .map(|commit| {

/// Print commits ahead and behind.

pub fn print_commits_ahead_behind(

) -> anyhow::Result<()> {

    let (ahead, behind) = repo.graph_ahead_behind(left, right)?;

    id: &PatchId,

    verbose: bool,

    stored: &Repository,

    profile: &Profile,

) -> anyhow::Result<()> {

    let (_, revision) = patch.latest();

    } else {

        vec![]

    };

    let author = patch.author();

    let author = term::format::Author::new(author.id(), profile, verbose);

    let labels = patch.labels().map(|l| l.to_string()).collect::<Vec<_>>();

#[cfg(test)]

mod test {

    use super::*;

    use radicle::test::fixtures;

    use std::path;

    fn commit(

        parent: &git::Oid,

        msg: &str,

    ) -> git::Oid {

            "anonymous",

            "anonymous@radicle.example.com",

        )

        .unwrap();

        let tree =

            git::write_tree(path::Path::new("README"), "Hello World!\n".as_bytes(), repo).unwrap();

    fn test_create_display_message() {

        let tmpdir = tempfile::tempdir().unwrap();

        let (repo, commit_0) = fixtures::repository(&tmpdir);

        let commit_1 = commit(

            &repo,

            &refname!("feature"),

    fn test_update_display_message() {

        let tmpdir = tempfile::tempdir().unwrap();

        let (repo, commit_0) = fixtures::repository(&tmpdir);

        let commit_1 = commit(&repo, &refname!("feature"), &commit_0, "commit 1\n");

        let commit_2 = commit(&repo, &refname!("feature"), &commit_1, "commit 2\n");

use anyhow::anyhow;

use radicle::git;

use radicle::prelude::*;

use radicle::storage::git::Repository;

use crate::terminal as term;

/// Give the oid of the branch or an appropriate error.

#[inline]

    let oid = branch

        .get()

        .target()

}

#[inline]

    let (_, _, head, tail) = git_ref.non_empty_components();

    std::iter::once(head).chain(tail).collect()

}

/// as well as your own (eg. `rad/master`).

pub fn get_merge_target(

    storage: &Repository,

    let (qualified_ref, target_oid) = storage.canonical_head()?;

    let head_oid = branch_oid(head_branch)?;

        anyhow::bail!("commits are already included in the target branch; nothing to do");

    }

}

/// Get the diff stats between two commits.

/// Should match the default output of `git diff <old> <new> --stat` exactly.

pub fn diff_stats(

    old: &Oid,

    new: &Oid,

    let old_tree = old.tree()?;

    let new_tree = new.tree()?;

    let mut diff = repo.diff_tree_to_tree(Some(&old_tree), Some(&new_tree), None)?;

    diff.find_similar(Some(&mut find_opts))?;

    diff.stats()

/// Create a human friendly message about git's sync status.

pub fn ahead_behind(

    revision_oid: Oid,

    head_oid: Oid,

) -> anyhow::Result<term::Line> {

    if a == 0 && b == 0 {

        return Ok(term::Line::new(term::format::dim("up to date")));

    }

}

/// Get the branches that point to a commit.

    let mut branches: Vec<String> = vec![];

    for r in repo.references()?.flatten() {

            continue;

        }

        if let (Some(oid), Some(name)) = (&r.target(), &r.shorthand()) {

                branches.push(name.to_string());

            };

        };

}

#[inline]

    let branch = if reference.is_branch() {

    } else {

        anyhow::bail!("cannot create patch from detached head; aborting")

    };

fastrand = { workspace = true }

qcheck = { workspace = true }

qcheck-macros = { workspace = true }

radicle-oid = { workspace = true, features = ["qcheck"] }

tempfile = { workspace = true }

fastrand = { workspace = true, optional = true }

multibase = { workspace = true }

qcheck = { workspace = true, optional = true }

radicle-ssh = { workspace = true, optional = true }

serde = { workspace = true, features = ["derive"] }

signature = { workspace = true }

        multibase::encode(multibase::Base::Base58Btc, buf)

    }

        refname!("refs/namespaces").join(Component::from(self))

    }

    }

    pub fn from_namespaced(

    ) -> Result<Self, PublicKeyError> {

        let name = refstr.namespace().into_inner();

    }

}

    fn from(id: &PublicKey) -> Self {

        let refstr =

            RefString::try_from(id.to_string()).expect("encoded public keys are valid ref strings");

        Component::from_refstr(refstr).expect("encoded public keys are valid refname components")

log = { workspace = true, features = ["std"] }

nonempty = { workspace = true }

radicle = { workspace = true }

thiserror = { workspace = true }

\ No newline at end of file

    /// Convert from an [`ObjectId`] to an [`Oid`].

    pub fn to_oid(oid: ObjectId) -> Oid {

    }

    /// Convert from an [`Oid`] to an [`ObjectId`].

use std::collections::HashMap;

use radicle::prelude::PublicKey;

use super::refs::{Applied, RefUpdate, Update};

                    let name = name.into_qualified().into_owned();

                    let prev = match self.0.insert(name.clone(), target) {

                        Some(prev) => prev,

                    };

                    ap.updated.push(RefUpdate::Updated {

                        name: name.to_ref_string(),

use std::collections::BTreeMap;

use either::Either;

use radicle::prelude::PublicKey;

pub use radicle::storage::RefUpdate;

pub mod error;

use either::Either;

use radicle::storage::git::Repository;

use super::refs::{Applied, Policy, RefUpdate, Update};

/// - The object does not peel to a commit

/// - Attempting to find the object fails

fn find_and_peel(repo: &Repository, oid: Oid) -> Result<Oid, error::Ancestry> {

        Ok(object) => Ok(object

            .map_err(|err| error::Ancestry::Peel { oid, err })?

            .id()

            .into()),

        Err(err) => Err(error::Ancestry::Object { oid, err }),

    }

}

    let (ahead, behind) = repo

        .backend

        .map_err(|err| error::Ancestry::Check {

            old: old_commit,

            new: new_commit,

where

    N: Into<Qualified<'a>>,

{

    let refname = refname.into();

    match repo.backend.refname_to_id(refname.as_ref()) {

        });

    };

        // If the two objects are identical, their ancestry does not matter,

        // we can always skip the update.

        return Ok(RefUpdate::Skipped {

    }

    let ancestry = {

        const ANY_KIND: Option<ObjectType> = Some(Any);

        let prev = repo.backend.find_object(prev, ANY_KIND).map_err(|err| {

        let target = repo

            .backend

            .map_err(|err| error::Update::Ancestry(error::Ancestry::Object { oid: target, err }))?;

        match (prev.kind(), target.kind()) {

    name: Namespaced<'a>,

    prev: Either<Oid, Qualified<'a>>,

) -> Result<Updated<'a>, error::Update> {

    match find(repo, &name)? {

        Some(mut r) => {

fn find<'a>(

    repo: &'a Repository,

    name: &Namespaced<'_>,

    match repo.backend.find_reference(name.as_ref()) {

        Ok(r) => Ok(Some(r)),

        Err(err) => Err(error::Update::Find {

            name: name.clone().into_owned(),

            err,

use thiserror::Error;

#[derive(Debug, Error)]

#[error("could not open Git ODB")]

#[derive(Debug, Error)]

pub enum Ancestry {

        old: Oid,

        new: Oid,

        #[source]

    },

    #[error("failed to peel object to commit {oid}: {err}")]

    Peel {

        oid: Oid,

        #[source]

    },

    #[error("failed to find object {oid}: {err}")]

    Object {

        oid: Oid,

        #[source]

    },

}

pub struct Resolve {

    pub name: Qualified<'static>,

    #[source]

}

#[derive(Debug, Error)]

#[error("failed to scan for refs matching {pattern}")]

pub struct Scan {

    #[source]

}

#[derive(Debug, Error)]

        name: Namespaced<'static>,

        target: Oid,

        #[source]

    },

    #[error("failed to delete reference {name}")]

    Delete {

        name: Namespaced<'static>,