We can also create patches by pushing to the `rad/patches` remote. It's a bit

simpler:

$ git push rad/patches

Note that we can't fetch from `rad/patches`:

``` (stderr) (fail)

$ git fetch rad/patches

fatal: couldn't find remote ref refs/patches

```

```

$ rad patch open --message "Define power requirements" --message "See details."

master <- z6MknSL…StBU8Vi/flux-capacitor-power (3e674d1)

1 commit(s) ahead, 0 commit(s) behind

3e674d1 Define power requirements

✓ Patch 077e4bbe9a6e5546f400ef5951768c37a76f13a4 created

To publish your patch to the network, run:

    git push rad

* flux-capacitor-power 3e674d1 [rad/flux-capacitor-power] Define power requirements

bob         z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk (fetch)

rad         (canonical upstream)                             (fetch)

rad         z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi (push)

rad/patches (patches upstream)                               (push)

```

$ rad patch open --message "Define power requirements" --message "See details."

master <- z6Mkt67…v4N1tRk/flux-capacitor-power (3e674d1)

1 commit(s) ahead, 0 commit(s) behind

3e674d1 Define power requirements

✓ Patch 50e29a111972f3b7d2123c5057de5bdf09bc7b1c created

To publish your patch to the network, run:

    git push rad

$ git ls-remote rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk refs/heads/flux-capacitor-power

3e674d1a1df90807e934f9ae5da2591dd6848a33	refs/heads/flux-capacitor-power

$ rad patch update --message "Add README, just for the fun" 50e29a111972f3b7d2123c5057de5bdf09bc7b1c

Updating 3e674d1 -> 27857ec

1 commit(s) ahead, 0 commit(s) behind

✓ Patch updated to revision 3530243d46a2e7a8e4eac7afcbb17cc7c56b3d29

 * [new branch]      flux-capacitor-power -> bob/flux-capacitor-power

 * [new branch]      master               -> bob/master

  bob/flux-capacitor-power

$ git checkout flux-capacitor-power

branch 'flux-capacitor-power' set up to track 'bob/flux-capacitor-power'.

[flux-capacitor-power f6484e0] fixup! Define power requirements

$ git merge flux-capacitor-power

│ Branches  flux-capacitor-power, master                                       │

    // Setup tracking for project delegates.

#[path = "patch/create.rs"]

mod create;

    rad patch open [--draft] [<option>...]

Open/Update options

        --draft                Open patch in draft mode

    Open,

    Open {

        message: Message,

        draft: bool,

        quiet: bool,

    },

        let mut draft = false;

                // Open/update options.

                Long("draft") if op == Some(OperationName::Open) => {

                    draft = true;

                }

                Long("quiet") | Short('q')

                    if op == Some(OperationName::Open) || op == Some(OperationName::Update) =>

                {

                    "o" | "open" => op = Some(OperationName::Open),

            OperationName::Open => Operation::Open {

                message,

                draft,

                quiet,

            },

        Operation::Open {

            ref message,

            draft,

            quiet,

        } => {

            create::run(

                message.clone(),

                draft,

                quiet,

                options,

                &profile,

                &repository,

                &workdir,

            )?;

        }

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

pub fn patch_commits<'a>(

    repo: &'a git::raw::Repository,

    base: &Oid,

    head: &Oid,

) -> anyhow::Result<Vec<git::raw::Commit<'a>>> {

    let mut commits = Vec::new();

    let mut revwalk = repo.revwalk()?;

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

    for rev in revwalk {

        let commit = repo.find_commit(rev?)?;

        commits.push(commit);

    }

    Ok(commits)

}

use radicle::cob::patch;

use radicle::git;

use radicle::node::Handle;

use radicle::prelude::*;

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

use radicle::Node;

use crate::terminal as term;

use super::common::*;

use super::Options;

fn show_patch_commit_info(

    storage: &Repository,

    node_id: &NodeId,

    head_branch: &git::raw::Branch,

    target_ref: &git::RefStr,

    target_oid: git::Oid,

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

    let head_oid = branch_oid(head_branch)?;

    // The merge base is basically the commit at which the histories diverge.

    let base_oid = storage.backend.merge_base(*target_oid, *head_oid)?;

    let commits = patch_commits(&storage.backend, &base_oid, &head_oid)?;

    term::info!(

        "{} <- {}/{} ({})",

        term::format::highlight(target_ref),

        term::format::dim(term::format::node(node_id)),

        term::format::highlight(branch_name(head_branch)?),

        term::format::secondary(term::format::oid(head_oid)),

    );

    // TODO: Test case where the target branch has been re-written passed the merge-base, since the fork was created

    // This can also happen *after* the patch is created.

    term::patch::print_commits_ahead_behind(&storage.backend, *head_oid, *target_oid)?;

    // List commits in patch that aren't in the target branch.

    term::blank();

    term::patch::list_commits(&commits)?;

    Ok(())

}

/// Run patch creation.

pub fn run(

    message: term::patch::Message,

    draft: bool,

    quiet: bool,

    options: Options,

    profile: &Profile,

    storage: &Repository,

    workdir: &git::raw::Repository,

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

    let mut patches = patch::Patches::open(storage)?;

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

    let head_branch_name = push_to_storage(workdir, storage, &head_branch, &options)?;

    let (target_ref, target_oid) = get_merge_target(storage, &head_branch)?;

    if head_branch.upstream().is_err() {

        radicle::git::set_upstream(

            workdir,

            &*radicle::rad::REMOTE_NAME,

            branch_name(&head_branch)?,

            head_branch_name,

        )?;

    }

    // TODO: Handle case where `rad/master` isn't up to date with the target.

    // In that case we should warn the user that their master branch is not up

    // to date, and error out, unless the user specifies manually the merge

    // base.

    if !quiet {

        show_patch_commit_info(storage, profile.id(), &head_branch, &target_ref, target_oid)?;

        term::blank();

    }

    // TODO: List matching working copy refs for all targets.

    let head_oid = branch_oid(&head_branch)?;

    let base_oid = storage.backend.merge_base(*target_oid, *head_oid)?;

    let (title, description) =

        term::patch::get_create_message(message, &storage.backend, &base_oid.into(), &head_oid)?;

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

    let patch = if draft {

        patches.draft(

            title,

            &description,

            patch::MergeTarget::default(),

            base_oid,

            head_oid,

            &[],

            &signer,

        )

    } else {

        patches.create(

            title,

            &description,

            patch::MergeTarget::default(),

            base_oid,

            head_oid,

            &[],

            &signer,

        )

    }?;

    if !quiet {

        term::success!("Patch {} created", term::format::highlight(patch.id));

        term::blank();

    }

    if options.announce {

        let mut node = Node::new(profile.socket());

        match node.announce_refs(storage.id()) {

            Ok(()) => {}

            Err(e) if e.is_connection_err() => {

                term::warning("Could not announce patch refs: node is not running");

            }

            Err(e) => {

                return Err(e.into());

            }

        }

    } else if !quiet {

        term::info!("To publish your patch to the network, run:");

        term::indented(term::format::secondary("git push rad"));

    }

    if quiet {

        term::print(patch.id);

    }

    Ok(())

}

use radicle::rad;

            let description = if r.name == rad::PATCHES_REMOTE_NAME.as_str() {

                if dir == "fetch" {

                    // Fetching from the patches remote is not allowed.

                    continue;

                }

                term::format::dim("(patches upstream)".to_string()).italic()

            } else {

                url.namespace.map_or(

                    term::format::dim("(canonical upstream)".to_string()).italic(),

                    |namespace| term::format::tertiary(namespace.to_string()),

                )

            };

/// Configure a repository's patches remote.

///

/// The entry for this remote will be:

/// ```text

/// [remote.<name>]

///   url = <url>

///   pushurl = <url>

///   push HEAD:refs/patches

/// ```

pub fn configure_patches_remote<'r>(

    repo: &'r git2::Repository,

    name: &str,

    refspec: &Refspec<RefString, RefString>,

    push: &Url,

) -> Result<git2::Remote<'r>, git2::Error> {

    let push = push.to_string();

    let remote = repo.remote(name, &push)?;

    // This fetchspec basically prevents fetching from this remote,

    // as it shouldn't be used for fetching.

    repo.remote_add_fetch(name, "refs/patches:refs/patches")?;

    repo.remote_set_pushurl(name, Some(&push))?;

    repo.remote_add_push(name, refspec.to_string().as_str())?;

    Ok(remote)

}

/// Name of the radicle patches remote.

pub static PATCHES_REMOTE_NAME: Lazy<git::RefString> = Lazy::new(|| git::refname!("rad/patches"));

    git::configure_patches_remote(

        repo,

        &PATCHES_REMOTE_NAME,

        &git::Refspec {

            src: git::refname!("HEAD"),

            dst: PATCHES_REFNAME.clone(),

            force: false,

        },

        &url.with_namespace(*pk),

    )?;