fn patch_base(

    head: &git::Oid,

    opts: &Options,

    stored: &storage::git::Repository,

) -> Result<git::Oid, Error> {

    Ok(if let Some(base) = opts.base {

        base

    } else {

        // Computation of the canonical head is required only if the user

        // did not specify a base explicitly. This allows the user to

        // continue updating patches even while the canonical head cannot

        // be computed, e.g. while they wait for their fellow delegates

        // to converge and sync.

        let (_, target) = stored.canonical_head()?;

        stored.merge_base(&target, head)?

    })

}

/// Before opening or updating patches, we want to evaluate the merge base of the

/// patch and the default branch. In order to do that, the respective heads must

/// be present in the same Git repository.

///

/// Unfortunately, we don't have an easy way to transfer the objects without

/// creating a reference (be it in storage or working copy).

///

/// We choose to push a temporary reference to storage, which gets deleted on

/// [`Drop::drop`].

struct TempPatchRef<'a> {

    stored: &'a storage::git::Repository,

    reference: git::Namespaced<'a>,

}

impl<'a> TempPatchRef<'a> {

    fn new(stored: &'a storage::git::Repository, head: &git::Oid, nid: &NodeId) -> Self {

        let reference = git::refs::storage::staging::patch(nid, *head);

        Self { stored, reference }

    }

    fn push(&self, src: &git::Oid, verbosity: Verbosity) -> Result<(), Error> {

        push_ref(src, &self.reference, false, self.stored.raw(), verbosity)

    }

}

impl<'a> Drop for TempPatchRef<'a> {

    fn drop(&mut self) {

        if let Err(err) = self

            .stored

            .raw()

            .find_reference(&self.reference)

            .and_then(|mut r| r.delete())

        {

            eprintln!(

                "{} Failed to delete temporary reference {} in storage: {err}",

                term::PREFIX_WARNING,

                term::format::tertiary(&self.reference),

            );

        }

    }

}

    head: &git::Oid,

    let temp = TempPatchRef::new(stored, head, nid);

    temp.push(head, opts.verbosity)?;

    let base = patch_base(head, &opts, stored)?;

    if base == *head {

        term::patch::get_create_message(opts.message, &stored.backend, &base, head)?;

            *head,

            *head,

    }?;

    let action = if patch.is_draft() {

        "drafted"

    } else {

        "opened"

    let patch = patch.id;

    eprintln!(

        "{} Patch {} {action}",

        term::PREFIX_SUCCESS,

        term::format::tertiary(patch),

    );

    // Create long-lived patch head reference, now that we know the Patch ID.

    //

    //  refs/namespaces/<nid>/refs/heads/patches/<patch-id>

    //

    let refname = git::refs::patch(&patch).with_namespace(nid.into());

    let _ = stored.raw().reference(

        refname.as_str(),

        **head,

        true,

        "Create reference for patch head",

    )?;

    if let Some(upstream) = upstream {

        if let Some(local_branch) = opts.branch.to_branch_name(&patch) {

            fn strip_refs_heads(qualified: git::Qualified) -> git::RefString {

                let (_refs, _heads, x, xs) = qualified.non_empty_components();

                std::iter::once(x).chain(xs).collect()

            }

            working.reference(&local_branch, **head, true, "Create local branch for patch")?;

            let remote_branch = git::refs::workdir::patch_upstream(&patch);

            let remote_branch = working.reference(

                &remote_branch,

                **head,

                true,

                "Create remote tracking branch for patch",

            )?;

            debug_assert!(remote_branch.is_remote());

            let local_branch = strip_refs_heads(local_branch);

            let upstream_branch = git::refs::patch(&patch);

            git::set_upstream(working, upstream, &local_branch, &upstream_branch)?;

            eprintln!(

                "{} Branch {} created",

                term::PREFIX_SUCCESS,

                term::format::tertiary(&local_branch),

            );

            hint(format!(

                "to update, run `git push {upstream} {local_branch}`"

            ));

        }

        // Setup current branch so that pushing updates the patch.

        else if let Some(branch) =

            rad::setup_patch_upstream(&patch, *head, working, upstream, false)?

        {

            if let Some(name) = branch.name()? {

                if profile.hints() {

                    // Remove the remote portion of the name, i.e.

                    // rad/patches/deadbeef -> patches/deadbeef

                    let name = name.split_once('/').unwrap_or_default().1;

                        "to update, run `git push` or `git push {upstream} -f HEAD:{name}`"

    }

    Ok(Some(ExplorerResource::Patch { id: patch }))

    head: &git::Oid,

    let temp = TempPatchRef::new(stored, head, nid);

    temp.push(head, opts.verbosity)?;

    let base = patch_base(head, &opts, stored)?;

    if patch.revisions().any(|(_, r)| r.head() == *head) {

    let message = term::patch::get_update_message(opts.message, &stored.backend, &latest, head)?;

    let dst = dst.with_namespace(nid.into());

    push_ref(head, &dst, force, stored.raw(), opts.verbosity)?;

    let revision = patch_mut.update(message, base, *head, signer)?;

    if base == *head && patch_mut.is_open() {

        patch_merge(patch_mut, revision.id(), *head, working, signer)?;