pratdiff 3.1.1

A colorfull diff tool based on the patience diff algorithm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::error::Error;
use std::io::Read;
use std::path::PathBuf;

use clap::ColorChoice;
use clap::CommandFactory;
use clap::Parser;
use clap_complete_command::Shell;
use common_path::common_path;

#[derive(Parser, Debug)]
#[command(version = concat!(
    env!("CARGO_PKG_VERSION"),
    " (",
    env!("VERGEN_GIT_DESCRIBE"),
    ", built ",
    env!("VERGEN_BUILD_DATE"),
    ")"
))]
#[command(about = "Diff files with token level colorization")]
#[command(override_usage = r#"
    pratdiff [OPTIONS] <OLD_FILE> <NEW_FILE>
        Diff two files or directory trees.

    <diff tool> | pratdiff [OPTIONS]
        Rediff an existing diff, adding pratdiff goodness.

        Examples:
          git diff | pratdiff
          diff -u old.txt new.txt | pratdiff --cluster"#)]
struct Args {
  /// Path to old file, directory tree, or `-` for stdin.
  #[clap(name = "OLD_FILE")]
  lhs: Option<PathBuf>,

  /// Path to new file, directory tree, or `-` for stdin.
  #[clap(name = "NEW_FILE")]
  rhs: Option<PathBuf>,

  /// Display NUM lines of unchanged context before and after changes
  #[clap(short, long, value_name = "NUM", default_value_t = 3)]
  context: usize,

  /// Print full paths instead of stripping a common prefix
  #[clap(short, long)]
  verbose_paths: bool,

  #[clap(long, default_value_t = ColorChoice::Auto)]
  color: ColorChoice,

  /// Group diffs into clusters by change signature
  #[clap(long)]
  cluster: bool,

  /// The shell to generate the completions for
  #[arg(long = "completions", value_name = "SHELL", value_enum)]
  shell: Option<Shell>,
}

fn main() -> Result<(), Box<dyn Error>> {
  let args = Args::parse();
  if let Some(shell) = args.shell {
    shell.generate(&mut Args::command(), &mut std::io::stdout());
    return Ok(());
  }

  match args.color {
    ColorChoice::Auto => anstream::ColorChoice::Auto,
    ColorChoice::Always => anstream::ColorChoice::Always,
    ColorChoice::Never => anstream::ColorChoice::Never,
  }
  .write_global();

  let mut stdout = anstream::stdout();

  match (args.lhs, args.rhs) {
    (Some(lhs), Some(rhs)) => {
      let common_prefix = if args.verbose_paths {
        PathBuf::new()
      } else {
        common_path(&lhs, &rhs).unwrap_or_default()
      };
      let mut p =
        pratdiff::Printer::default(&mut stdout, args.context, common_prefix);
      if args.cluster {
        let clusters = pratdiff::cluster_files(&lhs, &rhs);
        p.print_clusters(&clusters)?;
      } else {
        pratdiff::diff_files(&mut p, &lhs, &rhs)?;
      }
    }
    (Some(_), None) => {
      Args::command()
        .error(
          clap::error::ErrorKind::MissingRequiredArgument,
          "NEW_FILE is required when OLD_FILE is supplied",
        )
        .exit();
    }
    (None, _) => {
      // Re-diff mode: read diff from stdin and re-render.
      let mut input = Vec::new();
      std::io::stdin().read_to_end(&mut input)?;
      let input = anstream::adapter::strip_bytes(&input).into_vec();

      let mut p =
        pratdiff::Printer::default(&mut stdout, args.context, PathBuf::new());
      if args.cluster {
        let diffs = pratdiff::parse_diff::parse(&input);
        let clusters = pratdiff::rediff_cluster(&diffs);
        p.print_clusters(&clusters)?;
      } else {
        pratdiff::rediff(&mut p, &input)?;
      }
    }
  }
  Ok(())
}