git-latexdiff: Git and Latexdiff working together

git-latexdiff: Git and Latexdiff working together

[Matthieu Moy]

[-- Attachment #1: Type: text/plain, Size: 721 bytes --]

Hi,

You may know latexdiff, a neat tool to visualize differences between
LaTeX files (it annotates your .tex file with colors for removed/added
parts, producing another compilable .tex file).

I wrote a little shell-script that allows one to use latexdiff on files
versionned by Git, with e.g.

  git latexdiff HEAD^ --main foo.tex --output foo.pdf

Essentially, it does a checkout of the old and new revisions, and calls
latexdiff + pdflatex for you.

The result is attached in case anyone is interested.

It may be relevant to add this to contrib/ in git.git. If anyone's
interested, let me know, and I'll resend the code in the form of a
patch doing that.

Regards,

-- 
Matthieu Moy
http://www-verimag.imag.fr/~moy/

[-- Attachment #2: git-latexdiff --]
[-- Type: application/octet-stream, Size: 4613 bytes --]

#! /bin/sh

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

OLD and NEW are Git revision identifiers. NEW defaults to HEAD.

Options:
	--help		This help message
	--main FILE.tex	Name of the main LaTeX file
	--no-view	Don't display the resulting PDF file
	--view		View the resulting PDF file
			(default if -o is not used)
	--no-cleanup	Don't cleanup temp dir after running
	-o FILE, --output FILE
			Copy resulting PDF into FILE
			(usually ending with .pdf)
EOF
}

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

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

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

verbose_done () {
    if [ "$verbose" = 1 ]; then
	echo " done."
    fi
}

old=
new=
main=
view=maybe
cleanup=1
verbose=0
output=
initial_dir=$PWD

while test $# -ne 0; do
    case "$1" in
        "--help"|"-h")
            usage
            exit 0
            ;;
	"--main")
	    shift
	    main=$1
	    ;;
	"--no-view")
	    view=0
	    ;;
	"--view")
	    view=1
	    ;;
	"--no-cleanup")
	    cleanup=0
	    ;;
	"-o"|"--output")
	    shift
	    output=$1
	    ;;
	"--verbose"|"-v")
	    verbose=1
	    ;;
        *)
	    if [ "$1" = "" ]; then
		echo "Empty string not allowed as argument"
		usage
		exit 1
	    elif [ "$old" = "" ]; then
		old=$1
	    elif [ "$new" = "" ]; then
		new=$1
	    else
		echo "Bad argument $1"
		usage
		exit 1
	    fi
            ;;
    esac
    shift
done

if [ "$new" = "" ]; then
    new=HEAD
fi

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

if [ "$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 [ -r "$main" ]; then
	echo "Using $main as the main file."
    else
	if [ "$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 [ ! -r "$main" ]; then
    die "Cannot read $main."
fi

verbose "Creating temporary directories"

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

main=$git_prefix/$main

tmpdir=$initial_dir/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/"
git --git-dir="$git_dir" --work-tree=. checkout "$old" -- . || die "checkout failed for old/"
verbose_progress
cd ../new || die "Cannot cd to new/"
git --git-dir="$git_dir" --work-tree=. checkout "$new" -- . || die "checkout failed for new/"
verbose_progress
cd ../diff || die "Cannot cd to diff/"
git --git-dir="$git_dir" --work-tree=. checkout "$new" -- . || die "checkout failed for diff/"
verbose_progress
cd .. || die "Cannot cd back to toplevel"

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

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

verbose_done

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

verbose "Compiling result"

compile_error=0
cd diff/"$maindir" || die "Can't cd to diff/$maindir"
if [ -f Makefile ]; then
    make || compile_error=1
else
    pdflatex --interaction errorstopmode "$mainbase" || compile_error=1
fi

verbose_done

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

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

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

if [ "$output" != "" ]; then
    abs_pdffile="$PWD/$pdffile"
    (cd "$initial_dir" && cp "$abs_pdffile" "$output")
    echo "Output written on $output"
fi

if [ "$view" = 1 ] || [ "$view" = maybe ] && [ "$output" = "" ]; then
    xpdf "$pdffile"
fi

if [ "$cleanup" = 1 ]; then
    verbose "Cleaning-up result"
    rm -fr "$tmpdir"
    verbose_done
fi

Re: git-latexdiff: Git and Latexdiff working together

[Tim Haga]

Hi,

your tool seems very useful for LaTeX users, especially in scientific
work. I could not test it in detail until now, but i had two or
three runs with an article draft and it seems to work.

Long story short, i would appreciate it if your tool would be
integrated in git.

T.


Am Tue, 14 Feb 2012 14:22:45 +0100
schrieb Matthieu Moy <Matthieu.Moy@grenoble-inp.fr>:

> Hi,
> 
> You may know latexdiff, a neat tool to visualize differences between
> LaTeX files (it annotates your .tex file with colors for removed/added
> parts, producing another compilable .tex file).
> 
> I wrote a little shell-script that allows one to use latexdiff on files
> versionned by Git, with e.g.
> 
>   git latexdiff HEAD^ --main foo.tex --output foo.pdf
> 
> Essentially, it does a checkout of the old and new revisions, and calls
> latexdiff + pdflatex for you.
> 
> The result is attached in case anyone is interested.
> 
> It may be relevant to add this to contrib/ in git.git. If anyone's
> interested, let me know, and I'll resend the code in the form of a
> patch doing that.
> 
> Regards,
> 

Re: git-latexdiff: Git and Latexdiff working together

[Jeff King]

On Tue, Feb 14, 2012 at 02:22:45PM +0100, Matthieu Moy wrote:

> I wrote a little shell-script that allows one to use latexdiff on files
> versionned by Git, with e.g.
> 
>   git latexdiff HEAD^ --main foo.tex --output foo.pdf

My latex usage is all from a past life, so I didn't even try out your
tool.  But I did wonder what your rationale was in making a separate
command as opposed to providing a script that could be plugged in as an
external diff.

-Peff

Re: git-latexdiff: Git and Latexdiff working together

[Matthieu Moy]

Jeff King <peff@peff.net> writes:

> My latex usage is all from a past life, so I didn't even try out your
> tool.  But I did wonder what your rationale was in making a separate
> command as opposed to providing a script that could be plugged in as an
> external diff.

My LaTeX documents are usually sets of .tex files including each other,
plus figures and possibly Makefiles. So, git-latexdiff does a full
checkout of the old and new tree, then runs latexdiff on the main file,
and then compiles the result.

A diff driver would work well for a standalone file, but I don't think
you can plug it in this kind of situation.

Also, git-latexdiff has a few hacks like detecting the main latex file
automatically by grepping all .tex files for "documentclass", detecting
the presence of a Makefile to compile the document, ... that would
hardly fit in a diff driver.

That said, that may be just me not knowing diff drivers or difftools
well enough.

-- 
Matthieu Moy
http://www-verimag.imag.fr/~moy/

Re: git-latexdiff: Git and Latexdiff working together

[Jeff King]

On Wed, Feb 15, 2012 at 12:13:40AM +0100, Matthieu Moy wrote:

> Jeff King <peff@peff.net> writes:
> 
> > My latex usage is all from a past life, so I didn't even try out your
> > tool.  But I did wonder what your rationale was in making a separate
> > command as opposed to providing a script that could be plugged in as an
> > external diff.
> 
> My LaTeX documents are usually sets of .tex files including each other,
> plus figures and possibly Makefiles. So, git-latexdiff does a full
> checkout of the old and new tree, then runs latexdiff on the main file,
> and then compiles the result.
> [...]

Ah, yeah. I didn't think about the fact that there's a whole ecosystem
of files that go into producing the output.

> That said, that may be just me not knowing diff drivers or difftools
> well enough.

No, your analysis is right. A diff driver wouldn't work well at all.

Thanks for satisfying my curiosity.

-Peff