/radicle-cli/target

In this example, we explore how the `ahead/behind` indicator works, and what is

shown as diffs in the case of divergent branches.

First we add the `CONTRIBUTORS` file to `master`, which contains one entry:

```

$ git checkout -q master

$ git add CONTRIBUTORS

$ git commit -a -q -m "Add contributors"

$ git push rad master

$ cat CONTRIBUTORS

Alice Jones

```

Then we create a feature branch which adds another entry:

```

$ git checkout -q -b feature/1

$ sed -i '$a Alan K' CONTRIBUTORS

$ git commit -a -q -m "Add Alan"

```

We go back to master, and add a different second entry, essentially forking

the history:

```

$ git checkout -q master

$ sed -i '$a Jason Bourne' CONTRIBUTORS

$ git commit -a -q -m "Add Jason"

$ git push rad master

$ git log --graph --decorate --abbrev-commit --pretty=oneline --all

* 5c88a79 (feature/1) Add Alan

| * e101a99 (HEAD -> master, rad/master) Add Jason

|/ [..]

* f64fb2c Add contributors

* f2de534 Second commit

* 08c788d Initial commit

```

Then we create a patch from `feature/1`:

``` (stderr)

$ git push rad feature/1:refs/patches

✓ Patch 866f59c001cd4d78a151f444b34265566c83c264 opened

To rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

 * [new reference]   feature/1 -> refs/patches

```

When listing, we see that it has one addition:

```

$ rad patch list

╭─────────────────────────────────────────────────────────────────────────────╮

│ ●  ID       Title     Author                  Head     +   -   Updated      │

├─────────────────────────────────────────────────────────────────────────────┤

│ ●  866f59c  Add Alan  z6MknSL…StBU8Vi  (you)  5c88a79  +1  -0  [   ...    ] │

╰─────────────────────────────────────────────────────────────────────────────╯

```

When showing the patch, we see that it is `ahead 1, behind 1`, since master has

diverged by one commit:

```

$ rad patch show -p 866f59c

╭────────────────────────────────────────────────────────────────────╮

│ Title     Add Alan                                                 │

│ Patch     866f59c001cd4d78a151f444b34265566c83c264                 │

│ Author    did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi │

│ Head      5c88a79d75f5c2b4cc51ee6f163d2db91ee198d7                 │

│ Branches  feature/1                                                │

│ Commits   ahead 1, behind 1                                        │

│ Status    open                                                     │

├────────────────────────────────────────────────────────────────────┤

│ 5c88a79 Add Alan                                                   │

├────────────────────────────────────────────────────────────────────┤

│ ● opened by (you) (z6MknSL…StBU8Vi) [              ...           ] │

╰────────────────────────────────────────────────────────────────────╯

commit 5c88a79d75f5c2b4cc51ee6f163d2db91ee198d7

Author: radicle <radicle@localhost>

Date:   Thu Dec 15 17:28:04 2022 +0000

    Add Alan

diff --git a/CONTRIBUTORS b/CONTRIBUTORS

index 3f60d25..6829c43 100644

--- a/CONTRIBUTORS

+++ b/CONTRIBUTORS

@@ -1 +1,2 @@

 Alice Jones

+Alan K

```

Then, we stack another change onto `feature/1`, adding another contributor:

``` (stderr)

$ git checkout -q -b feature/2 feature/1

$ sed -i '$a Mel Farna' CONTRIBUTORS

$ git commit -a -q -m "Add Mel"

$ git push -o patch.message="Add Mel" rad HEAD:refs/patches

✓ Patch 57cb9b2758518e547de324456ac967fda456c6c1 opened

To rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

 * [new reference]   HEAD -> refs/patches

```

When we look at the patch, we see that it has both commits, because this new

patch uses the same base as the previous patch:

```

$ rad patch show 57cb9b2758518e547de324456ac967fda456c6c1

╭────────────────────────────────────────────────────────────────────╮

│ Title     Add Mel                                                  │

│ Patch     57cb9b2758518e547de324456ac967fda456c6c1                 │

│ Author    did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi │

│ Head      7f63fcbcf23fc39eea784c091ad3d20d7e4bd005                 │

│ Branches  feature/2                                                │

│ Commits   ahead 2, behind 1                                        │

│ Status    open                                                     │

├────────────────────────────────────────────────────────────────────┤

│ 7f63fcb Add Mel                                                    │

│ 5c88a79 Add Alan                                                   │

├────────────────────────────────────────────────────────────────────┤

│ ● opened by (you) (z6MknSL…StBU8Vi) 5 months ago                   │

╰────────────────────────────────────────────────────────────────────╯

```

use radicle::cob::patch::{Clock, Patch, PatchId, Patches};

    let (from, to) = patch.range(repository)?;

    let stats = common::diff_stats(repository.raw(), &from, &to)?;

fn show_patch_diff(patch: &patch::Patch, stored: &Repository) -> anyhow::Result<()> {

    let (from, to) = patch.range(stored)?;

    let range = format!("{}..{}", from, to);

        .current_dir(stored.path())

        .args(["log", "--patch", &range])

    let (from, to) = patch.range(stored)?;

    let range = format!("{}..{}", from, to);

    let ahead_behind = common::ahead_behind(

        stored.raw(),

        *revision.head(),

        *patch.target().head(stored)?,

    )?;

use std::{env, fs};

fn rad_patch_ahead_behind() {

    let mut environment = Environment::new();

    let profile = environment.profile("alice");

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

    let home = &profile.home;

    // Setup a test repository.

    fixtures::repository(working.path());

    fs::write(working.path().join("CONTRIBUTORS"), "Alice Jones\n").unwrap();

    test("examples/rad-init.md", working.path(), Some(home), []).unwrap();

    test(

        "examples/rad-patch-ahead-behind.md",

        working.path(),

        Some(home),

        [],

    )

    .unwrap();

}

#[test]

use crate::identity;

impl MergeTarget {

    /// Get the head of the target branch.

    pub fn head<R: ReadRepository>(&self, repo: &R) -> Result<git::Oid, identity::IdentityError> {

        match self {

            MergeTarget::Delegates => {

                let (_, target) = repo.head()?;

                Ok(target)

            }

        }

    }

}

    /// Get the merge base of this patch.

    pub fn merge_base<R: ReadRepository>(&self, repo: &R) -> Result<git::Oid, git::ext::Error> {

        let target = self.target().head(repo).map_err(|_| {

            git::ext::Error::NotFound(git::ext::NotFound::NoSuchBranch(String::from("HEAD")))

        })?;

        let base = repo.merge_base(&target, self.head())?;

        Ok(base)

    }

    /// Get the commit range of this patch.

    pub fn range<R: ReadRepository>(

        &self,

        repo: &R,

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

        if self.is_merged() {

            Ok((*self.base(), *self.head()))

        } else {

            Ok((self.merge_base(repo)?, *self.head()))

        }

    }

    /// Check if the patch is merged.

    pub fn is_merged(&self) -> bool {

        matches!(self.state(), State::Merged { .. })

    }

    /// Get the merge base of two commits.

    fn merge_base(&self, left: &Oid, right: &Oid) -> Result<Oid, git::ext::Error>;

    fn merge_base(&self, left: &Oid, right: &Oid) -> Result<Oid, ext::Error> {

        self.backend

            .merge_base(**left, **right)

            .map(Oid::from)

            .map_err(ext::Error::from)

    }

    fn merge_base(&self, _left: &Oid, _right: &Oid) -> Result<Oid, git::ext::Error> {

        todo!()

    }