postdiff

#!/usr/bin/env perl -w
#
# postdiff: Run diff after some other process on both files.
# 2006-10-30: Written by Steven J. DeRose.
#
use strict;
use Getopt::Long;

our %metadata = (
    'title'        => "postdiff",
    'description'  => "Run diff after some other process on both files.",
    'rightsHolder' => "Steven J. DeRose",
    'creator'      => "http://viaf.org/viaf/50334488",
    'type'         => "http://purl.org/dc/dcmitype/Software",
    'language'     => "Perl 5.18",
    'created'      => "2006-10-30",
    'modified'     => "2022-08-15",
    'publisher'    => "http://github.com/sderose",
    'license'      => "https://creativecommons.org/licenses/by-sa/3.0/"
);
our $VERSION_DATE = $metadata{'modified'};

my $dft_normalize = "normalizeUnicode --ligatures --dashes --allQuotes --spaces --runs";

my %dft_normalizers = (
    "txt"  => $dft_normalize,
    "xml"  => "normalizeXML -q -i -ic -btext -ballattrs -btags ",
);

=pod

=head1 Usage

postdiff [--cmd C] [options] file1 file2

Runs some command (specific via I<C>) on both files, then diffs the results.
Put '{}' wherever you want the filenames to appear in the command you give.
If there is no '{}', the filenames will be appended to the command.

I<--cmd> defaults to:
    $dft_normalize

A feature to use a different default I<--cmd> based on file extensions, may be added.


=head1 Options

=over

=item * B<--cmd> I<cmd>

A command or pipe to run on the files. This will be run twice, once for each
input file. If I<cmd> includes "{}", the filename is inserted in place of that;
otherwise, the filename is added at the end.

=item * B<--do> I<foo>

Pass I<foo> on to C<diff> (some options can also be
specified directly: -b -d -E -i -n -q -t -w -y).

=item * B<--preserve>

Don't erase the temp files when done.

=item * B<--verbose> OR B<-v>
Add more detailed messages.

=item * B<--version>

Display version info and exit.

=item * B<-x>

Shorthand to normalize XML files. Takes the place of I<--cmd>.

=back


=head1 Related commands

C<normalizeXML> -- re-breaks XML files in a standard way, allowing them to be
compared without worrying about whitespace variation, attribute quoting, etc.


=head1 Known bugs and lmitations

Recursive diffing is not supported.


=head1 History

    2006-10-30: Written by Steven J. DeRose.
    2006-12-28 sjd: Add -t -blank -comment -doctype, -l, $VERSION_DATE, rid for -i.
    2007-01-05 sjd: Fix some bugs, add -v, randomize temp file names.
    2007-01-09 sjd: Rename options, add noattrpat, nogenid, split noid/norid,
organize option parsing, help, and code to same order.
    2007-12-07 sjd: strict. Drop all the built-in processing (done better by normalizeXML).
    2007-12-31 sjd: Getopt.
    2008-01-25 sjd: Add -cvs, and various pass-through options.
    2008-09-24 sjd: Port to BSD.
    2010-09-12, 2012-10-05 sjd: Cleanup.
    2022-08-15: New layout. Drop (partial) cvs support.
    
    
=head1 To do

    Use a different default per file extension.
    Add git support.
    

=head1 Ownership

This work by Steven J. DeRose is licensed under a Creative Commons 
Attribution-Share Alike 3.0 Unported License. For further information on
this license, see L<http://creativecommons.org/licenses/by-sa/3.0/>.

For the most recent version, see L<http://www.derose.net/steve/utilities/>.

=cut


###############################################################################
# Process options
#
my $diffOptions = "";
my $pre         = "";
my $preserve    = 0;
my $quiet       = 0;
my $verbose     = 0;
my $xml         = 0;

my %getoptHash = (
    # Pass-throughs to 'diff':
    "b"                 => sub { $diffOptions .= " -b"; },
    "d"                 => sub { $diffOptions .= " -d"; },
    "E"                 => sub { $diffOptions .= " -E"; },
    "i"                 => sub { $diffOptions .= " -i"; },
    "n"                 => sub { $diffOptions .= " -n"; },
    "q"                 => sub { $diffOptions .= " -q"; },
    "t"                 => sub { $diffOptions .= " -t"; },
    "w"                 => sub { $diffOptions .= " -w"; },
    "y"                 => sub { $diffOptions .= " -y"; },
    
    # Our own options:
    "cmd=s"             => \$pre,
    "do=s"              => \$diffOptions,
    "h|help|?"          => sub { system "perldoc $0"; exit; },
    "preserve!"         => \$preserve,
    "xml!"              => \$xml,
    "v|verbose+"        => \$verbose,
    "version"           => sub {
        die "Version of $VERSION_DATE, by Steven J. DeRose.\n";
    },
    );

Getopt::Long::Configure ("ignore_case");
GetOptions(%getoptHash) || die("Bad options.\n");


###############################################################################
# Process and validate options
#
if (!$pre) {
	$pre = $dft_normalize;
}

if ($diffOptions =~ m/ -b/) {
	$diffOptions .= " -W $ENV{COLUMNS}";
}


###############################################################################
# Main
#
my $file1 = $ARGV[0];
my $file2 = $ARGV[1];
my $tmpfile = "/tmp/postdiff_$file1\_" . int(rand(100000));

(-e $file1) || die "Couldn't find file 1: '$file1'.\n";
(-e $file2) || die "Couldn't find file 2: '$file2'.\n";

# Set up output files
#
my $rr = int(rand(100000));
my $o1 = "/tmp/$ENV{USER}_postdiff_$rr.file1";
my $o2 = "/tmp/$ENV{USER}_postdiff_$rr.file2";

# Set up the pre-processing for both input files
my $cmd1; my $cmd2;
if ($pre =~ m/\{\}/) {
    $cmd1 = "$pre >$o1";
	$cmd1 =~ s/\{\}/$file1/g;
	$cmd2 = "$pre >$o2";
	$cmd2 =~ s/\{\}/$file2/g;
}
else {
	$cmd1 = "$pre $file1 >$o1";
	$cmd2 = "$pre $file2 >$o2";
}

# Pre-process
($verbose) && warn "Running: $cmd1\n";
system "$cmd1";
($verbose) && warn "Running: $cmd2\n";
system "$cmd2";

# Diff the pre-processed files
my $cmd = "diff $diffOptions $o1 $o2";
($verbose) && warn "Running: $cmd\n";
system "$cmd";

if (!$preserve) {
	system "rm $o1 $o2";
	system "rm $tmpfile 2>/dev/null";
}
else {
	warn "Temp files are: $o1 $o2.\n";
}

($verbose) && warn "Done.\n";

exit;