``` (stderr)

$ rad diff

! Deprecated: The command/option `rad diff` is deprecated and will be removed. Please use `git diff` instead.

```

Exploring `rad diff`.

``` ./main.c

#include <stdio.h>

int main(void) {

    printf("Hello World!\n");

    return 0;

}

```

```

$ ls

README

main.c

```

```

$ git mv README README.md

$ git add main.c

$ git commit -m "Make changes"

[master 5f771e0] Make changes

 2 files changed, 6 insertions(+)

 rename README => README.md (100%)

 create mode 100644 main.c

```

```

$ rad diff HEAD^ HEAD

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

│ README -> README.md ❲moved❳                │

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

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

│ main.c +6 ❲created❳                        │

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

│ @@ -0,0 +1,6 @@                            │

│      1     + #include <stdio.h>            │

│      2     +                               │

│      3     + int main(void) {              │

│      4     +     printf("Hello World!/n"); │

│      5     +     return 0;                 │

│      6     + }                             │

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

```

```

$ sed -i 's/Hello World/Hello Radicle/' main.c

$ rad diff

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

│ main.c -1 +1                                 │

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

│ @@ -1,6 +1,6 @@                              │

│ 1    1       #include <stdio.h>              │

│ 2    2                                       │

│ 3    3       int main(void) {                │

│ 4          -     printf("Hello World!/n");   │

│      4     +     printf("Hello Radicle!/n"); │

│ 5    5           return 0;                   │

│ 6    6       }                               │

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

```

```

$ git add main.c

$ rad diff

$ rad diff --staged

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

│ main.c -1 +1                                 │

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

│ @@ -1,6 +1,6 @@                              │

│ 1    1       #include <stdio.h>              │

│ 2    2                                       │

│ 3    3       int main(void) {                │

│ 4          -     printf("Hello World!/n");   │

│      4     +     printf("Hello Radicle!/n"); │

│ 5    5           return 0;                   │

│ 6    6       }                               │

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

```

```

$ git rm -f -q main.c

$ rad diff --staged

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

│ main.c -6 ❲deleted❳                        │

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

│ @@ -1,6 +0,0 @@                            │

│ 1          - #include <stdio.h>            │

│ 2          -                               │

│ 3          - int main(void) {              │

│ 4          -     printf("Hello World!/n"); │

│ 5          -     return 0;                 │

│ 6          - }                             │

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

```

For now, copies are not detected.

```

$ git reset --hard master -q

$ mkdir docs

$ cp README.md docs/README.md

$ git add docs

$ rad diff --staged

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

│ docs/README.md +1 ❲created❳ │

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

│ @@ -0,0 +1,1 @@             │

│      1     + Hello World!   │

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

$ git reset

$ git checkout .

```

Empty file.

```

$ touch EMPTY

$ git add EMPTY

$ rad diff --staged

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

│ EMPTY ❲created❳ │

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

$ git reset

$ git checkout .

```

File mode change.

```

$ chmod +x README.md

$ rad diff

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

│ README.md 100644 -> 100755 ❲mode changed❳ │

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

$ git reset -q

$ git checkout .

```

Binary file.

```

$ touch file.bin

$ truncate -s 8 file.bin

$ git add file.bin

$ rad diff --staged

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

│ file.bin ❲binary❳ ❲created❳ │

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

```

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

│ README.md +1 ❲created❳    │

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

│ @@ -0,0 +1,1 @@           │

│      1     + Hello World! │

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

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

│ RADICLE.md +1 ❲created❳     │

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

│ @@ -0,0 +1,1 @@             │

│      1     + Hello Radicle! │

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

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

│ README.md +1 ❲created❳      │

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

│ @@ -0,0 +1,1 @@             │

│      1     + Hello World!   │

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

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

│ README.md +1 ❲created❳    │

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

│ @@ -0,0 +1,1 @@           │

│      1     + Hello World! │

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

pub mod diff;

use std::ffi::OsString;

use anyhow::anyhow;

use radicle::git;

use radicle::rad;

use radicle_surf as surf;

use crate::git::pretty_diff::ToPretty as _;

use crate::git::Rev;

use crate::terminal as term;

use crate::terminal::args::{Args, Error, Help};

use crate::terminal::highlight::Highlighter;

pub const HELP: Help = Help {

    name: "diff",

    description: "Show changes between commits",

    version: env!("RADICLE_VERSION"),

    usage: r#"

Usage

    rad diff [<commit>] [--staged] [<option>...]

    rad diff <commit> [<commit>] [<option>...]

    This command is meant to operate as closely as possible to `git diff`,

    except its output is optimized for human-readability.

Options

    --unified, -U   Context lines to show (default: 5)

    --staged        View staged changes

    --color         Force color output

    --help          Print help

"#,

};

pub struct Options {

    pub commits: Vec<Rev>,

    pub staged: bool,

    pub unified: usize,

    pub color: bool,

}

impl Args for Options {

    fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {

        use lexopt::prelude::*;

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

        let mut commits = Vec::new();

        let mut staged = false;

        let mut unified = 5;

        let mut color = false;

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

            match arg {

                Long("unified") | Short('U') => {

                    let val = parser.value()?;

                    unified = term::args::number(&val)?;

                }

                Long("staged") | Long("cached") => staged = true,

                Long("color") => color = true,

                Long("help") | Short('h') => return Err(Error::Help.into()),

                Value(val) => {

                    let rev = term::args::rev(&val)?;

                    commits.push(rev);

                }

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

            }

        }

        Ok((

            Options {

                commits,

                staged,

                unified,

                color,

            },

            vec![],

        ))

    }

}

pub fn run(options: Options, _ctx: impl term::Context) -> anyhow::Result<()> {

    crate::warning::deprecated("rad diff", "git diff");

    let repo = rad::repo()?;

    let oids = options

        .commits

        .into_iter()

        .map(|rev| {

            repo.revparse_single(rev.as_str())

                .map_err(|e| anyhow!("unknown object {rev}: {e}"))

                .and_then(|o| {

                    o.into_commit()

                        .map_err(|_| anyhow!("object {rev} is not a commit"))

                })

        })

        .collect::<Result<Vec<_>, _>>()?;

    let mut opts = git::raw::DiffOptions::new();

    opts.patience(true)

        .minimal(true)

        .context_lines(options.unified as u32);

    let mut find_opts = git::raw::DiffFindOptions::new();

    find_opts.exact_match_only(true);

    find_opts.all(true);

    let mut diff = match oids.as_slice() {

        [] => {

            if options.staged {

                let head = repo.head()?.peel_to_tree()?;

                // HEAD vs. index.

                repo.diff_tree_to_index(Some(&head), None, Some(&mut opts))

            } else {

                // Working tree vs. index.

                repo.diff_index_to_workdir(None, None)

            }

        }

        [commit] => {

            let commit = commit.tree()?;

            if options.staged {

                // Commit vs. index.

                repo.diff_tree_to_index(Some(&commit), None, Some(&mut opts))

            } else {

                // Commit vs. working tree.

                repo.diff_tree_to_workdir(Some(&commit), Some(&mut opts))

            }

        }

        [left, right] => {

            // Commit vs. commit.

            let left = left.tree()?;

            let right = right.tree()?;

            repo.diff_tree_to_tree(Some(&left), Some(&right), Some(&mut opts))

        }

        _ => {

            anyhow::bail!("Too many commits given. See `rad diff --help` for usage.");

        }

    }?;

    diff.find_similar(Some(&mut find_opts))?;

    term::Paint::force(options.color);

    let diff = surf::diff::Diff::try_from(diff)?;

    let mut hi = Highlighter::default();

    let pretty = diff.pretty(&mut hi, &(), &repo);

    crate::pager::run(pretty)?;

    Ok(())

}

    process::Command::new("rad")

        "diff" => {

            term::run_command_args::<diff::Options, _>(diff::HELP, diff::run, args.to_vec());

        }

fn rad_diff() {

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

    fixtures::repository(&tmp);

    test("examples/rad-diff.md", tmp, None, []).unwrap();

}

#[test]