4 files changed, 406 insertions, 25 deletions

diff --git a/src/git.rs b/src/git.rs
index 63bce20..d0eaf03 100644
--- a/src/git.rs
+++ b/src/git.rs
@@ -67,6 +67,7 @@ pub trait RepoActions {
         branch_name: &str,
         patch_and_ancestors: Vec<nostr::Event>,
     ) -> Result<Vec<nostr::Event>>;
+    fn parse_starting_commits(&self, starting_commits: &str) -> Result<Vec<Sha1Hash>>;
 }
 
 impl RepoActions for Repo {
@@ -407,6 +408,49 @@ impl RepoActions for Repo {
         }
         Ok(patches_to_apply)
     }
+
+    fn parse_starting_commits(&self, starting_commits: &str) -> Result<Vec<Sha1Hash>> {
+        let revspec = self
+            .git_repo
+            .revparse(starting_commits)
+            .context("specified value not in a valid format")?;
+        if revspec.mode().is_no_single() {
+            let (ahead, _) = self
+                .get_commits_ahead_behind(
+                    &oid_to_sha1(
+                        &revspec
+                            .from()
+                            .context("cannot get starting commit from specified value")?
+                            .id(),
+                    ),
+                    &self
+                        .get_head_commit()
+                        .context("cannot get head commit with gitlib2")?,
+                )
+                .context("specified commit is not an ancestor of current head")?;
+            Ok(ahead)
+        } else if revspec.mode().is_range() {
+            let (ahead, _) = self
+                .get_commits_ahead_behind(
+                    &oid_to_sha1(
+                        &revspec
+                            .from()
+                            .context("cannot get starting commit of range from specified value")?
+                            .id(),
+                    ),
+                    &oid_to_sha1(
+                        &revspec
+                            .to()
+                            .context("cannot get end of range commit from specified value")?
+                            .id(),
+                    ),
+                )
+                .context("specified commit is not an ancestor of current head")?;
+            Ok(ahead)
+        } else {
+            bail!("specified value not in a supported format")
+        }
+    }
 }
 
 fn oid_to_u8_20_bytes(oid: &Oid) -> [u8; 20] {
@@ -1753,4 +1797,99 @@ mod tests {
             }
         }
     }
+    mod parse_starting_commits {
+        use super::*;
+
+        mod head_1_returns_latest_commit {
+            use super::*;
+
+            #[test]
+            fn when_on_main_and_other_commits_are_more_recent_on_feature_branch() -> Result<()> {
+                let test_repo = GitTestRepo::default();
+                let git_repo = Repo::from_path(&test_repo.dir)?;
+                test_repo.populate_with_test_branch()?;
+                test_repo.checkout("main")?;
+
+                assert_eq!(
+                    git_repo.parse_starting_commits("HEAD~1")?,
+                    vec![str_to_sha1("431b84edc0d2fa118d63faa3c2db9c73d630a5ae")?],
+                );
+                Ok(())
+            }
+
+            #[test]
+            fn when_checked_out_branch_ahead_of_main() -> Result<()> {
+                let test_repo = GitTestRepo::default();
+                let git_repo = Repo::from_path(&test_repo.dir)?;
+                test_repo.populate_with_test_branch()?;
+
+                assert_eq!(
+                    git_repo.parse_starting_commits("HEAD~1")?,
+                    vec![str_to_sha1("82ff2bcc9aa94d1bd8faee723d4c8cc190d6061c")?],
+                );
+                Ok(())
+            }
+        }
+        mod head_2_returns_latest_2_commits_youngest_first {
+            use super::*;
+
+            #[test]
+            fn when_on_main_and_other_commits_are_more_recent_on_feature_branch() -> Result<()> {
+                let test_repo = GitTestRepo::default();
+                let git_repo = Repo::from_path(&test_repo.dir)?;
+                test_repo.populate_with_test_branch()?;
+                test_repo.checkout("main")?;
+
+                assert_eq!(
+                    git_repo.parse_starting_commits("HEAD~2")?,
+                    vec![
+                        str_to_sha1("431b84edc0d2fa118d63faa3c2db9c73d630a5ae")?,
+                        str_to_sha1("af474d8d271490e5c635aad337abdc050034b16a")?,
+                    ],
+                );
+                Ok(())
+            }
+        }
+        mod head_3_returns_latest_3_commits_youngest_first {
+            use super::*;
+
+            #[test]
+            fn when_checked_out_branch_ahead_of_main() -> Result<()> {
+                let test_repo = GitTestRepo::default();
+                let git_repo = Repo::from_path(&test_repo.dir)?;
+                test_repo.populate_with_test_branch()?;
+
+                assert_eq!(
+                    git_repo.parse_starting_commits("HEAD~3")?,
+                    vec![
+                        str_to_sha1("82ff2bcc9aa94d1bd8faee723d4c8cc190d6061c")?,
+                        str_to_sha1("a23e6b05aaeb7d1471b4a838b51f337d5644eeb0")?,
+                        str_to_sha1("7ab82116068982671a8111f27dc10599172334b2")?,
+                    ],
+                );
+                Ok(())
+            }
+        }
+        mod range_of_3_commits_not_in_branch_history_returns_3_commits_youngest_first {
+            use super::*;
+
+            #[test]
+            fn when_checked_out_branch_ahead_of_main() -> Result<()> {
+                let test_repo = GitTestRepo::default();
+                let git_repo = Repo::from_path(&test_repo.dir)?;
+                test_repo.populate_with_test_branch()?;
+                test_repo.checkout("main")?;
+
+                assert_eq!(
+                    git_repo.parse_starting_commits("af474d8..a23e6b0")?,
+                    vec![
+                        str_to_sha1("a23e6b05aaeb7d1471b4a838b51f337d5644eeb0")?,
+                        str_to_sha1("7ab82116068982671a8111f27dc10599172334b2")?,
+                        str_to_sha1("431b84edc0d2fa118d63faa3c2db9c73d630a5ae")?,
+                    ],
+                );
+                Ok(())
+            }
+        }
+    }
 }
diff --git a/src/sub_commands/send.rs b/src/sub_commands/send.rs
index 004d263..105f87a 100644
--- a/src/sub_commands/send.rs
+++ b/src/sub_commands/send.rs
@@ -21,8 +21,12 @@ use crate::{
 
 #[derive(Debug, clap::Args)]
 pub struct SubCommandArgs {
-    #[clap(short, long)]
+    #[arg(default_value = "")]
+    /// starting commit (commits since in current branch) or commit range, like
+    /// in `git format-patch`
+    starting_commit: String,
     /// optional cover letter title
+    #[clap(short, long)]
     title: Option<String>,
     #[clap(short, long)]
     /// optional cover letter description
@@ -42,22 +46,24 @@ pub struct SubCommandArgs {
 pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     let git_repo = Repo::discover().context("cannot find a git repository")?;
 
-    let (from_branch, to_branch, mut ahead, behind) =
-        identify_ahead_behind(&git_repo, &args.from_branch, &args.to_branch)?;
+    let mut commits: Vec<Sha1Hash> = {
+        if args.starting_commit.is_empty() {
+            let (from_branch, to_branch, ahead, behind) =
+                identify_ahead_behind(&git_repo, &args.from_branch, &args.to_branch)?;
 
-    if ahead.is_empty() {
-        bail!(format!(
-            "'{from_branch}' is 0 commits ahead of '{to_branch}' so no patches were created"
-        ));
-    }
+            if ahead.is_empty() {
+                bail!(format!(
+                    "'{from_branch}' is 0 commits ahead of '{to_branch}' so no patches were created"
+                ));
+            }
 
-    if behind.is_empty() {
-        println!(
-            "creating patch for {} commits from '{from_branch}' that can be merged into '{to_branch}'",
-            ahead.len(),
-        );
-    } else {
-        if !Interactor::default().confirm(
+            if behind.is_empty() {
+                println!(
+                    "creating patch for {} commits from '{from_branch}' that can be merged into '{to_branch}'",
+                    ahead.len(),
+                );
+            } else {
+                if !Interactor::default().confirm(
             PromptConfirmParms::default()
                 .with_prompt(
                     format!(
@@ -70,14 +76,23 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
         ).context("failed to get confirmation response from interactor confirm")? {
             bail!("aborting so branch can be rebased");
         }
-        println!(
-            "creating patch for {} commit{} from '{from_branch}' that {} {} behind '{to_branch}'",
-            ahead.len(),
-            if ahead.len() > 1 { "s" } else { "" },
-            if ahead.len() > 1 { "are" } else { "is" },
-            behind.len(),
-        );
-    }
+                println!(
+                    "creating patch for {} commit{} from '{from_branch}' that {} {} behind '{to_branch}'",
+                    ahead.len(),
+                    if ahead.len() > 1 { "s" } else { "" },
+                    if ahead.len() > 1 { "are" } else { "is" },
+                    behind.len(),
+                );
+            }
+            ahead
+        } else {
+            let ahead = git_repo
+                .parse_starting_commits(&args.starting_commit)
+                .context("cannot parse specified starting commit or range")?;
+            println!("creating patch for {} commits", ahead.len(),);
+            ahead
+        }
+    };
 
     let title = if args.no_cover_letter {
         None
@@ -138,12 +153,12 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     .await?;
 
     // oldest first
-    ahead.reverse();
+    commits.reverse();
 
     let events = generate_cover_letter_and_patch_events(
         cover_letter_title_description.clone(),
         &git_repo,
-        &ahead,
+        &commits,
         &keys,
         &repo_ref,
     )?;
diff --git a/test_utils/src/git.rs b/test_utils/src/git.rs
index 7f0b4c7..76656df 100644
--- a/test_utils/src/git.rs
+++ b/test_utils/src/git.rs
@@ -56,6 +56,7 @@ impl GitTestRepo {
     pub fn populate_with_test_branch(&self) -> Result<Oid> {
         self.populate()?;
         self.create_branch("add-example-feature")?;
+        self.checkout("add-example-feature")?;
         fs::write(self.dir.join("f1.md"), "some content")?;
         self.stage_and_commit("add f1.md")?;
         fs::write(self.dir.join("f2.md"), "some content")?;
diff --git a/tests/send.rs b/tests/send.rs
index 9c8561a..d8186bd 100644
--- a/tests/send.rs
+++ b/tests/send.rs
@@ -1130,4 +1130,230 @@ mod sends_2_patches_without_cover_letter {
         }
         Ok(())
     }
+    mod specify_starting_commits {
+        use super::*;
+        fn cli_tester_create_proposal(git_repo: &GitTestRepo) -> CliTester {
+            let args = vec![
+                "--nsec",
+                TEST_KEY_1_NSEC,
+                "--password",
+                TEST_PASSWORD,
+                "--disable-cli-spinners",
+                "send",
+                "HEAD~3",
+                "--no-cover-letter",
+            ];
+            CliTester::new_from_dir(&git_repo.dir, args)
+        }
+        fn expect_msgs_first(p: &mut CliTester) -> Result<()> {
+            p.expect("creating patch for 3 commits\r\n")?;
+            p.expect("searching for profile and relay updates...\r\n")?;
+            p.expect("\r")?;
+            p.expect("logged in as fred\r\n")?;
+            p.expect("posting 3 patches without a covering letter...\r\n")?;
+            Ok(())
+        }
+        async fn prep_run_create_proposal() -> Result<(
+            Relay<'static>,
+            Relay<'static>,
+            Relay<'static>,
+            Relay<'static>,
+            Relay<'static>,
+        )> {
+            let git_repo = prep_git_repo()?;
+            // fallback (51,52) user write (53, 55) repo (55, 56)
+            let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                Relay::new(
+                    8051,
+                    None,
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![
+                                generate_test_key_1_metadata_event("fred"),
+                                generate_test_key_1_relay_list_event(),
+                            ],
+                        )?;
+                        Ok(())
+                    }),
+                ),
+                Relay::new(8052, None, None),
+                Relay::new(8053, None, None),
+                Relay::new(
+                    8055,
+                    None,
+                    Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                        relay.respond_events(
+                            client_id,
+                            &subscription_id,
+                            &vec![generate_repo_ref_event()],
+                        )?;
+                        Ok(())
+                    }),
+                ),
+                Relay::new(8056, None, None),
+            );
+
+            // // check relay had the right number of events
+            let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                let mut p = cli_tester_create_proposal(&git_repo);
+                p.expect_end_eventually()?;
+                for p in [51, 52, 53, 55, 56] {
+                    relay::shutdown_relay(8000 + p)?;
+                }
+                Ok(())
+            });
+
+            // launch relay
+            let _ = join!(
+                r51.listen_until_close(),
+                r52.listen_until_close(),
+                r53.listen_until_close(),
+                r55.listen_until_close(),
+                r56.listen_until_close(),
+            );
+            cli_tester_handle.join().unwrap()?;
+            Ok((r51, r52, r53, r55, r56))
+        }
+        mod cli_ouput {
+            use super::*;
+
+            async fn run_test_async() -> Result<()> {
+                let git_repo = prep_git_repo()?;
+
+                let (mut r51, mut r52, mut r53, mut r55, mut r56) = (
+                    Relay::new(
+                        8051,
+                        None,
+                        Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                            relay.respond_events(
+                                client_id,
+                                &subscription_id,
+                                &vec![
+                                    generate_test_key_1_metadata_event("fred"),
+                                    generate_test_key_1_relay_list_event(),
+                                ],
+                            )?;
+                            Ok(())
+                        }),
+                    ),
+                    Relay::new(8052, None, None),
+                    Relay::new(8053, None, None),
+                    Relay::new(
+                        8055,
+                        None,
+                        Some(&|relay, client_id, subscription_id, _| -> Result<()> {
+                            relay.respond_events(
+                                client_id,
+                                &subscription_id,
+                                &vec![generate_repo_ref_event()],
+                            )?;
+                            Ok(())
+                        }),
+                    ),
+                    Relay::new(8056, None, None),
+                );
+
+                // // check relay had the right number of events
+                let cli_tester_handle = std::thread::spawn(move || -> Result<()> {
+                    let mut p = cli_tester_create_proposal(&git_repo);
+
+                    expect_msgs_first(&mut p)?;
+                    relay::expect_send_with_progress(
+                        &mut p,
+                        vec![
+                            (" [my-relay] [repo-relay] ws://localhost:8055", true, ""),
+                            (" [my-relay] ws://localhost:8053", true, ""),
+                            (" [repo-relay] ws://localhost:8056", true, ""),
+                            (" [default] ws://localhost:8051", true, ""),
+                            (" [default] ws://localhost:8052", true, ""),
+                        ],
+                        3,
+                    )?;
+                    p.expect_end_with_whitespace()?;
+                    for p in [51, 52, 53, 55, 56] {
+                        relay::shutdown_relay(8000 + p)?;
+                    }
+                    Ok(())
+                });
+
+                // launch relay
+                let _ = join!(
+                    r51.listen_until_close(),
+                    r52.listen_until_close(),
+                    r53.listen_until_close(),
+                    r55.listen_until_close(),
+                    r56.listen_until_close(),
+                );
+                cli_tester_handle.join().unwrap()?;
+                Ok(())
+            }
+
+            #[tokio::test]
+            #[serial]
+            async fn check_cli_output() -> Result<()> {
+                run_test_async().await?;
+                Ok(())
+            }
+        }
+
+        #[tokio::test]
+        #[serial]
+        async fn three_patch_events() -> Result<()> {
+            let (_, _, r53, r55, r56) = prep_run_create_proposal().await?;
+            for relay in [&r53, &r55, &r56] {
+                assert_eq!(relay.events.iter().filter(|e| is_patch(e)).count(), 3);
+            }
+            Ok(())
+        }
+
+        #[tokio::test]
+        #[serial]
+        async fn first_patch_is_ancestor_and_root_others_in_correct_order() -> Result<()> {
+            let (_, _, r53, r55, r56) = prep_run_create_proposal().await?;
+            for relay in [&r53, &r55, &r56] {
+                let patch_events = relay
+                    .events
+                    .iter()
+                    .filter(|e| is_patch(e))
+                    .collect::<Vec<&nostr::Event>>();
+
+                // first patch tagged as root
+                assert!(
+                    patch_events[0]
+                        .iter_tags()
+                        .any(|t| t.as_vec()[0].eq("t") && t.as_vec()[1].eq("root"))
+                );
+                // first patch is ancestor
+                assert_eq!(
+                    patch_events[0]
+                        .iter_tags()
+                        .find(|t| t.as_vec()[0].eq("commit"))
+                        .unwrap()
+                        .as_vec()[1],
+                    "431b84edc0d2fa118d63faa3c2db9c73d630a5ae"
+                );
+                // second patch not tagged as root
+                assert_eq!(
+                    patch_events[1]
+                        .iter_tags()
+                        .find(|t| t.as_vec()[0].eq("commit"))
+                        .unwrap()
+                        .as_vec()[1],
+                    "232efb37ebc67692c9e9ff58b83c0d3d63971a0a"
+                );
+                // second patch not tagged as root
+                assert_eq!(
+                    patch_events[2]
+                        .iter_tags()
+                        .find(|t| t.as_vec()[0].eq("commit"))
+                        .unwrap()
+                        .as_vec()[1],
+                    "fe973a840fba2a8ab37dd505c154854a69a6505c"
+                );
+            }
+            Ok(())
+        }
+    }
 }