mktar: Use `wc` instead of `du` in summary message

[sunny256-utils.git] / git-testadd

#!/bin/sh

#==============================================================================
# git-testadd
# File ID: ae2451d2-43a1-11e6-86fa-175746503fe8
#
# Execute a command with only the staged changes in Git applied.
#
# Author: Øyvind A. Holm <sunny@sunbase.org>
# License: GNU General Public License version 2 or later.
#==============================================================================

progname=git-testadd
VERSION=0.11.1

opt_git=''
opt_help=0
opt_label=''
opt_dry_run=0
opt_pristine=0
opt_quiet=0
opt_ref=''
opt_unmodified=0
opt_verbose=0
while test -n "$1"; do
        case "$1" in
        -g|--git) opt_git="$2"; shift 2 ;;
        -h|--help) opt_help=1; shift ;;
        -l|--label) opt_label="$2"; shift 2 ;;
        -n|--dry-run) opt_dry_run=1; shift ;;
        -p|--pristine) opt_pristine=1; shift ;;
        -q|--quiet) opt_quiet=$(($opt_quiet + 1)); shift ;;
        -r|--ref) opt_ref="$2"; shift 2 ;;
        -u|--unmodified) opt_unmodified=1; shift ;;
        -v|--verbose) opt_verbose=$(($opt_verbose + 1)); shift ;;
        --version) echo $progname $VERSION; exit 0 ;;
        --) shift; break ;;
        *)
                if printf '%s\n' "$1" | grep -q ^-; then
                        echo "$progname: $1: Unknown option" >&2
                        exit 1
                else
                        break
                fi
        break ;;
        esac
done
opt_verbose=$(($opt_verbose - $opt_quiet))

msg() {
        test $1 -gt $opt_verbose && return;
        shift
        echo "$progname: $*" >&2
}

checkout_ref() {
        (
                $sim cd "$tmpdir" || {
                        echo $progname: $tmpdir: chdir error >&2
                        exit 1
                }
                $sim $GIT checkout $opt_ref || {
                        echo $progname: Cannot check out ref \"$opt_ref\" >&2
                        exit 1
                }
        )
}

tmpdir=".testadd.tmp"

if test "$opt_help" = "1"; then
        test $opt_verbose -gt 0 && { echo; echo $progname $VERSION; }
        cat <<END

Execute a command with only the staged changes in Git applied.

Usage: $progname [options] [--] COMMAND

If you have lots of unrelated uncommitted changes in the current 
repository and want to split up the commit, how can you easily check if 
the changes passes the test suite? With all the other unrelated changes 
it can be hard to make sure that only relevant changes becomes part of 
the commit, and that they don't result in regressions. This script 
clones the repository to the directory "$tmpdir" in the current 
directory and applies the staged changes there (unless -u/--unmodified 
or -p/--pristine is specified), chdirs to the same relative directory in 
the clone and executes the command specified on the command line there.

If COMMAND contains any options starting with '-', add "--" in front of 
the command so they won't be parsed by $progname, or surround it with 
quotes.

Examples:

  user@host:~/src/myproject/src/t \$ $progname make test

    The command will be executed in ~/src/myproject/src/t/$tmpdir/ with 
    only the staged changes applied.

  user@host:~/src/myproject/src/t \$ $progname -- ./run-tests -v

    This command contains a "-v" option. Disable option parsing of the 
    command by prefixing it with "--".

  $ $progname "make && cd t && make 2>&1 | less || echo fail"

    With quotes, even control operators and pipes can be used.

Options:

  -g X, --git X
    Specify alternative git executable to use. It can also be set with 
    the TESTADD_GIT environment variable.
  -h, --help
    Show this help.
  -l LABEL, --label LABEL
    Add LABEL to the name of the destination directory, specify 
    destination directory to use.
  -n, --dry-run
    Don't do anything, only print all commands to stdout.
  -p, --pristine
    Don't apply the staged changes, run the command with a clean HEAD.
  -q, --quiet
    Be more quiet. Can be repeated to increase silence.
  -r REF, --ref REF
    Check out REF (a commit, branch or tag) before the patch is applied 
    and the command is executed. The script will abort if the patch 
    couldn't be applied to this ref.
  -u, --unmodified
    Don't remove $tmpdir/, clone the repo and apply the patch, only 
    chdir to $tmpdir/ and run the command there as it was left from the 
    previous run. For example:
      $ $progname make         # This takes a long time, won't repeat
      $ $progname -u make test # Run the tests in a finished build
  -v, --verbose
    Increase level of verbosity. Can be repeated.
  --version
    Print version information.

END
        exit 0
fi

if test "$opt_dry_run" = "1"; then
        sim=echo
else
        sim=''
fi

if test -n "$opt_label"; then
        tmpdir=".testadd-$opt_label.tmp"
fi

if test -n "$opt_git"; then
        GIT="$opt_git"
elif test -n "$TESTADD_GIT"; then
        GIT="$TESTADD_GIT"
else
        GIT=git
fi

if test -z "$1"; then
        echo $progname: No command specified >&2
        exit 1
fi

topdir="$($GIT rev-parse --show-toplevel)"
subdir="$($GIT rev-parse --show-prefix)"

if test -z "$topdir"; then
        echo $progname: Could not get root dir of repo >&2
        exit 1
fi

if test -n "$opt_ref"; then
        if test -z "$($GIT rev-parse --verify $opt_ref^{commit})"; then
                echo $progname: $opt_ref: Invalid Git ref >&2
                exit 1
        fi
fi

msg 0 Using \"$tmpdir\" as destination directory

if test "$opt_unmodified" = "1"; then
        if test ! -d "$tmpdir"; then
                echo $progname: $tmpdir not found, -u/--unmodified needs it >&2
                exit 1
        fi
        msg 0 "No changes made in $tmpdir/"
else
        $sim rm -rf "$tmpdir"
        $sim $GIT clone "$topdir" "$tmpdir"
        test -n "$opt_ref" && checkout_ref "$opt_ref"

        if test "$opt_pristine" = "1"; then
                msg 0 Running command with unmodified HEAD
        elif $GIT diff --cached --binary --no-textconv | grep -q .; then
                msg 0 Applying staged changes
                ap="$GIT diff --cached --binary --no-textconv | "
                ap="$ap(cd \"$tmpdir\" && $GIT apply)"
                $sim eval "$ap" || {
                        echo $progname: Could not apply patch >&2
                        exit 1
                }
        else
                msg 0 No staged changes, running command with clean HEAD
        fi
fi

newdir="$tmpdir/$subdir"
$sim cd "$newdir" || {
        echo "$progname: $newdir: Cannot chdir" >&2
        exit 1
}

echo >&2
msg 0 "Executing \"$*\" in $(pwd)"
$sim eval "$@"

# vim: set ts=8 sw=8 sts=8 noet fo+=w tw=79 fenc=UTF-8 :