git-integration

#!/bin/bash

# Runs tests on all commits of a branch independently of working dir
# Copyright (C) 2013 Jean-Noël AVILA
# Licensed under the terms of the GNU General Public License version 2 (only).
# See the file COPYING for details.

usage(){
cat <<EOF
 usage : git integration [-m] [-c <cmd>] [-o <origin>]

    -h                    shows this text
    -m <branch>           test the merge with <branch>
    -c <cmd>              override the integration test command with <cmd>
    -o <origin>           override the origin branches with <origin>

EOF
}

while getopts "t:c:hm:o:" opt; do
    case $opt in
        t)
            tag="$OPTARG"
            ;;
        c)
            build_cmd="$OPTARG"
            ;;
        h)
            usage
            exit 0
            ;;
        m)
            try_merge=1
            merge_target="$OPTARG"
            ;;
        o)
            sequence_origin="$OPTARG"
            ;;
        :)
            echo "Option -$OPTARG requires an argument." >&2
            usage
            exit 1
            ;;
        \?)
            usage
            exit 1
            ;;
    esac
done

[ -n "$build_cmd" ] || build_cmd=$(git config integration.cmd)
if [ -z "$build_cmd" ]; then
    echo "please define config integration.cmd as a full command to build and test the project"
    exit 1;
fi

[ -n "$sequence_origin" ] || sequence_origin=$(git config integration.origin)
if [ -z "$sequence_origin" ]; then
    echo "please define config integration.origin as a space separated list of unwanted branches"
    exit 1;
fi

workinghead=$(git symbolic-ref HEAD 2> /dev/null | cut -b 12-)

PRIVATE_BUILD=$(git rev-parse --show-toplevel)/.privatebuild

if [ ! -d "$PRIVATE_BUILD" ]; then
  git worktree add -f --detach "$PRIVATE_BUILD">/dev/null || exit 1
fi

cd "$PRIVATE_BUILD" || exit 1
git clean -df

already_passed() {
    obdata=$t-$1
    obhash=`echo $obdata | git hash-object --stdin`
    git cat-file blob $obhash > /dev/null 2>/dev/null \
        && tput setaf 2 && echo "Already $commit_title" && tput sgr0
}

passed_on() {
    obdata=$t-$1
    echo $obdata | git hash-object -w --stdin > /dev/null
    tput setaf 2
    echo "Passed: $2"
    tput sgr0
    return 0
}

broke_on() {
    echo "Broke on $1"
    status=1
    return 1
}

new_test() {
    cd $(git rev-parse --show-toplevel)
    tput setaf 2
    echo "-----------------------------------------------------------------------------"
    echo "Testing: $1 $3"
    tput sgr0
    (git reset --hard $4 > /dev/null 2>/dev/null) && git clean -df && eval "$2" && passed_on "$1" "$3" || broke_on "$3"
    return $?
}

t=`echo "$build_cmd" | git hash-object --stdin`
status=0

if [ -n "$tag" ]
then
    tree_ver=`git rev-parse "${tag}^{tree}"`
    commit_title=$(git log --oneline -1 ${tag})
    passed_on $tree_ver "$commit_title"
    exit 0
fi

sequence_exclude=$(for s in $sequence_origin; do echo -n "^${s} "; done)
echo "Testing $build_cmd"
tput setaf 3
echo "on ${sequence_exclude} ${workinghead}"
tput sgr0
for v in $(git rev-list --reverse ${sequence_exclude} ${workinghead})
do
    tree_ver=`git rev-parse "$v^{tree}"`
    commit_title=$(git log --oneline -1 $v)
    already_passed $tree_ver "[$tree_ver] $commit_title" || new_test $tree_ver "$build_cmd" "$commit_title" $v || break
done
if [ "2$try_merge" -eq 21  ]; then
    echo "trying to merge"
    git checkout --detach "$merge_target"
    git merge --no-commit "$workinghead" || broke_on "merging $workinghead into $merge_target"
    eval "$build_cmd" && passed_on "0" "merge" || broke_on "testing merge"
fi

if [ $status -eq 0 ]; then
    tput bold;tput setaf 2
    echo "Integration OK"
    tput sgr0
else
    tput bold; tput setaf 1
    echo "Integration Failed!"
    tput sgr0
    exit $?
fi

cd - >/dev/null
git worktree remove -f .privatebuild