Merged guilt.lib into guilt

[guilt.git] / guilt

#!/bin/bash
#
# Copyright (c) Josef "Jeff" Sipek, 2006, 2007
#

if [ `basename $0` = "guilt" ]; then
        # being run as standalone

        # by default, we shouldn't fail
        fail=0

        if [ $# -ne 0 ]; then
                # take first arg, and try to execute it

                cmd="$1"
                dir=`dirname $0`

                if [ ! -x "$dir/guilt-$cmd" ]; then
                        echo "Command $cmd not found" >&2
                        echo "" >&2
                        fail=1
                else
                        shift
                        exec "$dir/guilt-$cmd" "$@"

                        # this is not reached because of the exec
                        echo "Exec failed! Something is terribly wrong!" >&2
                        exit 1
                fi
        fi

        # no args passed or invalid command entered, just output help summary

        echo "Pick a command:"
        for x in `dirname $0`/guilt-*; do
                [ -x $x ] && echo -e "\t`basename $x`"
        done

        echo ""
        echo "Example:"
        echo -e "\tguilt-push"
        echo "or"
        echo -e "\tguilt push"

        # now, let's exit
        exit $fail
fi

########

#
# Library goodies
#

function find_git_dir
{
        local d=`git-rev-parse --git-dir`

        if [ $? -ne 0 -o -z "$d" ]; then
                echo "Not a git repository" >&2
                return 1
        fi

        echo "$d"
}

function get_branch
{
        git-symbolic-ref HEAD | sed -e 's,^refs/heads/,,'
}

function verify_branch
{
        local b=$branch

        [ ! -d "$GIT_DIR/patches" ] &&
                echo "Patches directory doesn't exist, try guilt-init" >&2 &&
                return 1
        [ ! -d "$GIT_DIR/patches/$b" ] &&
                echo "Branch $b is not initialized, try guilt-init" >&2 &&
                return 1
        [ ! -f "$GIT_DIR/patches/$b/series" ] &&
                echo "Branch $b does not have a series file" >&2 &&
                return 1
        [ ! -f "$GIT_DIR/patches/$b/status" ] &&
                echo "Branch $b does not have a status file" >&2 &&
                return 1
        [ -f "$GIT_DIR/patches/$b/applied" ] &&
                echo "Warning: Branch $b has 'applied' file - guilt is not compatible with stgit" >&2 &&
                return 1

        return 0
}

function get_top
{
        tail -1 $GUILT_DIR/$branch/status
}

function get_prev
{
        local n=`wc -l < $GUILT_DIR/$branch/status`
        local n=`expr $n - 1`

        local idx=0
        for p in `cat $GUILT_DIR/$branch/status`; do
                idx=`expr $idx + 1`
                [ $idx -lt $n ] && continue
                [ $idx -gt $n ] && break

                echo $p
        done
}

function get_series
{
        # ignore all lines matching:
        #       - empty lines
        #       - whitespace only
        #       - optional whitespace followed by '#' followed by more
        #         optional whitespace
        grep -ve '^[[:space:]]*\(#.*\)*$' < $series
}

# usage: index_update_magic
function index_update_magic
{
        while read l; do
                fil=`echo $l | cut -d: -f 2`
                git-update-index --add --remove "$fil"
        done
}

# usage: do_get_header patchfile
function do_get_header
{
        cat $1 | awk 'BEGIN{ok=1}/^(diff|---)/{ok=0}{if (ok==1) print $0}'
}

# usage: pop_patch
function pop_patch
{
        git reset --hard HEAD^

        head -n -1 < $applied > $applied.tmp
        mv $applied{.tmp,}
}

# usage: push_patch patchname
function push_patch
{
        local p="$GUILT_DIR/$branch/$1"
        local pname="$1"

        local bail=0

        # apply the patch if and only if there is something to apply
        if [ `wc -l < $p` -gt 0 ]; then
                git-apply --reject $p > /dev/null 2> /tmp/guilt.log.$$
                bail=$?

                [ $bail -ne 0 ] && cat /tmp/guilt.log.$$ >&2

                ( git-apply --numstat $p | awk '{print "changed:" $3}';
                #git-apply --summary $p | awk '
                #       /^ (create|delete)/{print $1 ":" $4}
                #       /^ mode change/{print "mode:" $6}'
                )| index_update_magic
        fi

        # grab a commit message out of the patch
        do_get_header $p > /tmp/guilt.msg.$$

        # make a default commit message if patch doesn't contain one
        [ ! -s /tmp/guilt.msg.$$ ] && echo "patch $pname" > /tmp/guilt.msg.$$

        # commit
        local treeish=`git-write-tree`
        local commitish=`git-commit-tree $treeish -p HEAD < /tmp/guilt.msg.$$`
        echo $commitish > $GIT_DIR/`git-symbolic-ref HEAD`

        rm -f /tmp/guilt.msg.$$ /tmp/guilt.log.$$

        return $bail
}

# usage: must_commit_first
function must_commit_first
{
        [ `git-diff-files | wc -l` -eq 0 ]
        return $?
}

# usage: refresh_patch patchname
function refresh_patch
{
        local p="$GUILT_DIR/$branch/$1"

        git-diff-files --name-only | (while read n; do git-update-index $n ; done)

        # get the patch header
        do_get_header $p > /tmp/guilt.diff.$$

        # get the new patch
        git-diff HEAD^ >> /tmp/guilt.diff.$$

        # drop the current commit
        git-reset --hard HEAD^

        # move the new patch in
        mv $p $p.prev
        mv /tmp/guilt.diff.$$ $p

        push_patch $1
}

#
# The following gets run every time this file is source'd
#

export GIT_DIR=`find_git_dir`
[ $? -ne 0 ] && exit 1

GUILT_DIR="$GIT_DIR/patches"

branch=`get_branch`

# most of the time we want to verify that the repo's branch has been
# initialized, but every once in a blue moon (e.g., we want to run guilt-init),
# we must avoid the checks
if [ -z "$DO_NOT_CHECK_BRANCH_EXISTENCE" ]; then
        verify_branch || exit 1
fi

# very useful files
series="$GUILT_DIR/$branch/series"
applied="$GUILT_DIR/$branch/status"