Once the code is ready, we open (or create) a patch with our changes for the project.

```

✓ Pushing HEAD to storage...

✓ Analyzing remotes...

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

3e674d1 Define power requirements

```

It will now be listed as one of the project's open patches.

❲YOU PROPOSED❳

└─ * opened by did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi (you) [..]

❲OTHERS PROPOSED❳

Nothing to show.

commit 3e674d1a1df90807e934f9ae5da2591dd6848a33

Author: radicle <radicle@localhost>

[flux-capacitor-power 27857ec] Add README, just for the fun

 1 file changed, 0 insertions(+), 0 deletions(-)

 create mode 100644 README.md

🌱 Updating patch for heartwood

✓ Pushing HEAD to storage...

✓ Analyzing remotes...

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

```

And lets leave a quick comment for our team:

```

84ef44764de73695cf30e6b284585d2c50d6d0e5

2fa3ac18d82ebdafe73484a15fa9823355c4664b

```

Now, let's checkout the patch that we just created:

```

✓ Performing patch checkout...

```

Create/Update options

        --[no-]push            Push patch head to storage (default: true)

    -m, --message [<string>]   Provide a comment message to the patch or revision (default: prompt)

        --no-message           Leave the patch or revision comment message blank

#[derive(Debug)]

pub struct Options {

    pub op: Operation,

    pub fetch: bool,

    pub announce: bool,

    pub push: bool,

        use lexopt::prelude::*;

        let mut parser = lexopt::Parser::from_args(args);

        let mut op: Option<OperationName> = None;

        let mut verbose = false;

        let mut fetch = false;

        let mut patch_id = None;

        let mut message = Message::default();

        let mut push = true;

        while let Some(arg) = parser.next()? {

            match arg {

                // Options.

                Long("message") | Short('m') => {

                    if message != Message::Blank {

                        // We skip this code when `no-message` is specified.

                Value(val) if op == Some(OperationName::Checkout) && patch_id.is_none() => {

                    patch_id = Some(term::cob::parse_patch_id(val)?);

                }

                _ => return Err(anyhow::anyhow!(arg.unexpected())),

            }

        }

        Ok((

            Options {

                op,

                fetch,

                push,

                verbose,

use std::path::Path;

use anyhow::anyhow;

    Ok(oid.into())

}

/// List of merge targets.

#[derive(Debug, Default)]

pub struct MergeTargets {

        anyhow::bail!("a title must be given");

    }

    Ok((title.to_string(), description.to_owned()))

}

    term::blank();

    term::info!(

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

        term::format::highlight(project.default_branch().to_string()),

        term::format::secondary(term::format::oid(*target_oid)),

        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.

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

    term::blank();

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

    Ok(())

}

        storage.id

    ))?;

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

    push_to_storage(storage, &head_branch, &options)?;

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

        target_oid,

    )?;

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

    let (title, description) = handle_patch_message(message, workdir, &head_branch)?;

    let head_oid = branch_oid(&head_branch)?;

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

    let patch = patches.create(

        title,

        &description,

        base_oid,

        head_oid,

        &[],

    )?;

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

    if options.announce {

        // TODO

    }

    Ok(())

use super::common::*;

use super::*;

    let base_oid = workdir.merge_base(target_head, **patch.head())?;

    let diff = format!("{}..{}", base_oid, patch.head());

    Ok(())

}

    };

    term::blank();

    term::blank();

    show_patch_diff(&patch, storage, workdir)?;

    term::blank();

        anyhow::bail!("Patch `{patch_id}` not found");

    };

    // TODO(cloudhead): Handle error.

    let (_, current_revision) = patch.latest().unwrap();

    if *current_revision.oid == *branch_oid(&head_branch)? {

    show_update_commit_info(workdir, &patch_id, &patch, current_revision, &head_branch)?;

    let head_oid = branch_oid(&head_branch)?;

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

    let message = message.get(REVISION_MSG);

use radicle::git;

use crate::terminal as term;

/// The user supplied `Patch` description.

#[derive(Clone, Debug, PartialEq, Eq)]

    );

    Ok(())

}

    let demo = terminal::io::select(

        "Choose something to try out:",

        &[

            "spinner",

            "spinner-drop",

            "spinner-error",

    )?;

    match demo {

        Some(&"editor") => {

            let output = terminal::editor::Editor::new()

                .extension("rs")