git-latexdiff/git-latexdiff

#! /bin/sh

# Author: Matthieu Moy <Matthieu.Moy@imag.fr> (2012, 2013)
#
# Copying and distribution of this file, with or without modification,
# are permitted in any medium without royalty provided the copyright
# notice and this notice are preserved.  This file is offered as-is,
# without any warranty.
#
# git-latexdiff is a wrapper around latexdiff
# (http://www.ctan.org/pkg/latexdiff) that allows using it to diff two
# revisions of a LaTeX file.
#
# The script internally checks out the full tree for the specified
# revisions, and calls latexdiff with the --flatten option, hence this
# works if the document is split into multiple .tex files.
#
# Try "git latexdiff -h" for more information.
#
# To install, just copy git-latexdiff in your $PATH.

# Missing features (patches welcome ;-):
# - diff the index
# - checkout only a subdirectory of the repo
# - hardlink temporary checkouts as much as possible

# Alternatives:
#
# There is another script doing essentially the same here:
# https://github.com/cawka/latexdiff/blob/master/latexdiff-git
# My experience is that latexdiff-git is more buggy than
# git-latexdiff, but they probably just don't have the same bugs ;-)
#
# There are a bunch of other alternatives cited here:
#
#   http://tex.stackexchange.com/questions/1325/using-latexdiff-with-git
#
# Ideally, these scripts should be merged.

git_latexdiff_version=1.0

usage () {
    cat << EOF
Usage: $(basename $0) [options] OLD [NEW]
       $(basename $0) [options] OLD --
Call latexdiff on two Git revisions of a file.

OLD and NEW are Git revision identifiers. NEW defaults to HEAD.
If "--" is used for NEW, then diff against the working directory.

Options:
    --help                this help message
    --main <file.tex>     name of the main LaTeX file
    --no-view             don't display the resulting PDF file
    --bibtex, -b          run bibtex as well as latex
                             (pdflatex,bibtex,pdflatex,pdflatex)
    --biber			          run BibLaTex-Biber as well as latex
                             (pdflatex,bibtex,pdflatex,pdflatex)
    --view                view the resulting PDF file
                            (default if -o is not used)
    --pdf-viewer <cmd>    use <cmd> to view the PDF file (default: \$PDFVIEWER)
    --no-cleanup          don't cleanup temp dir after running
    --cleanup MODE	  Cleanup temporary files according to MODE:

                           - keeppdf (default): keep only the
                                  generated PDF file

                           - none: keep all temporary files
                                  (may eat your diskspace)

                           - all: erase all generated files.
                                  Problematic with --view when the
                                  viewer is e.g. evince, and doesn't
                                  like when the file being viewed is
                                  deleted.

    --latexmk             use latexmk
    -o <file>, --output <file>
                          copy resulting PDF into <file> (usually ending with .pdf)
			  Implies "--cleanup all"
    --tmpprefix           where temporary directory will be created (default: /tmp)
    --verbose, -v         give more verbose output
    --prepare <cmd>       run <cmd> before latexdiff (e.g. run make to generate
                             included files)
    --version             show git-latexdiff version.
EOF
}

die () {
    echo "fatal: $@"
    exit 1
}

verbose () {
    if test "$verbose" = 1 ; then
	printf "%s ..." "$@"
    fi
}

verbose_progress () {
    if test "$verbose" = 1 ; then
	printf "." "$@"
    fi
}

verbose_done () {
    if test "$verbose" = 1 ; then
	echo " ${1:-done}."
    fi
}

verbose_say () {
    if test "$verbose" = 1 ; then
	printf "%s\n" "$@"
    fi
}

old=
new=
main=
view=maybe
cleanup=keeppdf
verbose=0
bibtex=0
biber=0
output=
initial_dir=$PWD
tmpdir_prefix="/tmp"
prepare_cmd=
uselatexmk=

while test $# -ne 0; do
    case "$1" in
        "--help"|"-h")
            usage
            exit 0
            ;;
	"--main")
	    test $# -gt 1 && shift || die "missing argument for $1"
	    main=$1
	    ;;
	"--no-view")
	    view=0
	    ;;
	"--view")
	    view=1
	    ;;
	"--pdf-viewer")
	    test $# -gt 1 && shift || die "missing argument for $1"
	    PDFVIEWER="$1"
	    ;;
	"--no-cleanup")
	    cleanup=none
	    ;;
        "--cleanup")
            shift
            case "$1" in
                "none"|"all"|"keeppdf")
                    cleanup="$1"
                    ;;
                *)
                    echo "Bad argument --cleanup $1"
                    usage
                    exit 1
                    ;;
            esac
            ;;
	"-o"|"--output")
	    test $# -gt 1 && shift || die "missing argument for $1"
	    output=$1
	    cleanup=all
	    ;;
	"-b"|"--bibtex")
	    bibtex=1
	    ;;
	"--biber")
	    biber=1
	    ;;
	"--verbose"|"-v")
	    verbose=1
	    ;;
	"--version")
	    echo "$git_latexdiff_version"
            exit 0
	    ;;
	"--prepare")
	    shift
	    prepare_cmd="$1"
	    ;;
        "--latexmk")
            uselatexmk=1
            ;;
        "--tmpdirprefix")
	    shift
	    tmpdir_prefix="$1"
	    ;;
        *)
	    if test -z "$1" ; then
		echo "Empty string not allowed as argument"
		usage
		exit 1
	    elif test -z "$old" ; then
		old=$1
	    elif test -z "$new" ; then
		new=$1
	    else
		echo "Bad argument $1"
		usage
		exit 1
	    fi
            ;;
    esac
    shift
done

if test -z "$new" ; then
    new=HEAD
fi

if test -z "$old" ; then
    echo "fatal: Please, provide at least one revision to diff with."
    usage
    exit 1
fi

if test -z "$PDFVIEWER" ; then
    verbose "Auto-detecting PDF viewer"
    candidates="xdg-open evince okular xpdf acroread"
    if test "$(uname)" = Darwin ; then
        # open exists on GNU/Linux, but does not open PDFs
	candidates="open $candidates"
    fi

    for command in $candidates; do
	if command -v "$command" >/dev/null 2>&1; then
	    PDFVIEWER="$command"
	    break
	else
	    verbose_progress
	fi
    done
    verbose_done "$PDFVIEWER"
fi

case "$view" in
    maybe|1)
	if test -z "$PDFVIEWER" ; then
	    echo "warning: could not find a PDF viewer on your system."
	    echo "warning: Please set \$PDFVIEWER or use --pdf-viewer CMD."
	    PDFVIEWER=false
	fi
	;;
esac

if test -z "$main" ; then
    printf "%s" "No --main provided, trying to guess ... "
    main=$(git grep -l '^[ \t]*\\documentclass')
    # May return multiple results, but if so the result won't be a file.
    if test -r "$main" ; then
	echo "Using $main as the main file."
    else
	if test -z "$main" ; then
	    echo "No candidate for main file."
	else
	    echo "Multiple candidates for main file:"
	    printf "%s\n" "$main" | sed 's/^/\t/'
	fi
	die "Please, provide a main file with --main FILE.tex."
    fi
fi

if test ! -r "$main" ; then
    die "Cannot read $main."
fi

verbose "Creating temporary directories"

git_prefix=$(git rev-parse --show-prefix)
git_dir="$(git rev-parse --git-dir)" || die "Not a git repository?"
cd "$(git rev-parse --show-cdup)" || die "Can't cd back to repository root"
git_dir=$(cd "$git_dir"; pwd)

main=$git_prefix/$main

tmpdir=$tmpdir_prefix/git-latexdiff.$$
mkdir "$tmpdir" || die "Cannot create temporary directory."

cd "$tmpdir" || die "Cannot cd to $tmpdir"

mkdir old new diff || die "Cannot create old, new and diff directories."

verbose_done
verbose "Checking out old and new version"

cd old || die "Cannot cd to old/"
# in case the work directory contained uncommited important files
ln -s "$initial_dir"/* .

git --git-dir="$git_dir" --work-tree=. checkout "$old" -- . || die "checkout failed for old/"
verbose_progress
cd ../new || die "Cannot cd to new/"
ln -s "$initial_dir"/* .
if test "$new" != "--"; then
    # if new == "--" then diff working dir (already there thanks to ln
    # -s above).
    git --git-dir="$git_dir" --work-tree=. checkout "$new" -- . || die "checkout failed for new/"
fi
verbose_progress
cd ..

verbose_done

for dir in old new
do
    verbose "Running preparation command $prepare_cmd in $dir/"
    ( cd "$dir/$git_prefix/" && $prepare_cmd )
    verbose_done
done

verbose "Running latexdiff --flatten old/$main new/$main > $main"

latexdiff --flatten old/"$main" new/"$main" > diff.tex || die "latexdiff failed"

mv -f diff.tex new/"$main"

verbose_done

mainbase=$(basename "$main" .tex)
maindir=$(dirname "$main")

verbose "Compiling result"

compile_error=0
cd new/"$maindir" || die "Can't cd to new/$maindir"
if test -f Makefile ; then
    make || compile_error=1
elif test "$uselatexmk" = 1; then
    latexmk -f -pdf -silent "$mainbase"
else
    pdflatex --interaction errorstopmode "$mainbase" || compile_error=1
    if test "$bibtex" = 1 ; then
	bibtex "$mainbase"  || compile_error=1
    fi
    if test "$biber" = 1 ; then
	biber "$mainbase"  || compile_error=1
    fi
    pdflatex --interaction errorstopmode "$mainbase" || compile_error=1
    pdflatex --interaction errorstopmode "$mainbase" || compile_error=1
fi

verbose_done

pdffile="$mainbase".pdf
if test ! -r "$pdffile" ; then
    echo "No PDF file generated."
    compile_error=1
fi

if test ! -s "$pdffile" ; then
    echo "PDF file generated is empty."
    compile_error=1
fi

if test "$compile_error" = "1" ; then
    echo "Error during compilation. Please examine and cleanup if needed:"
    echo "Directory: $tmpdir/new/$maindir/"
    echo "     File: $mainbase.tex"
    # Don't clean up to let the user diagnose.
    exit 1
fi

if test -n "$output" ; then
    abs_pdffile="$PWD/$pdffile"
    (cd "$initial_dir" && mv "$abs_pdffile" "$output")
    echo "Output written on $output"
elif [ -f "$pdffile" ]; then
    new_pdffile="$tmpdir"/"$pdffile"
    mv "$pdffile" "$new_pdffile"
    pdffile="$new_pdffile"
fi


if test "$view" = 1  || test "$view" = maybe  && test -z "$output" ; then
    "$PDFVIEWER" "$pdffile"
fi

case "$cleanup" in
    "all")
	verbose "Cleaning-up result"
	rm -fr "$tmpdir"
	verbose_done
	;;
    "keeppdf")
	verbose "Cleaning-up all but pdf (kept in $pdffile)"
	rm -fr "$tmpdir"/old "$tmpdir"/new "$tmpdir"/diff
	verbose_done
	;;
    "none")
	verbose_say "Generated files kept in $tmpdir/"
	;;
esac