git-helpers

#!/bin/sh

# reset everything we define here
# so that we pick up any changes
# when re-sourced
unset -f git_branch
unset -f git_branch_p
unset -f ci
unset -f cm
unset -f show-push
unset -f bdiff
unset -f bdiv
unset -f glog
unset -f changelog
unset -f print_changelog
unset -f shortlog
unset -f checkout
unset -f branch
unset -f utags
unset -f update
unset -f story
unset -f _git_branches_both
unset -f copy_all_branches
unset -f git_color
unset -f gdiff
unalias branches 2> /dev/null
unalias push 2> /dev/null
unalias pull 2> /dev/null
unalias add 2> /dev/null
unalias merge 2> /dev/null
unalias gdiff 2> /dev/null
unalias st 2> /dev/null
unalias unpushed 2> /dev/null
unalias gl 2> /dev/null
unalias glt 2> /dev/null
unalias gll 2> /dev/null

USE_CTAGS="true"
TAB_COMPLETE_REMOTE_BRANCHES="true"

# Example prompt which shows current branch / commit:
#
#export PS1='\[\033]0;\u@\h:\w\007\][\[\e[1;32m\]\u@\h\[\e[0m\] \[\e[1;34m\]\W\[\e[0m\]\[$(git_color)\]$(git_branch_p)\[\e[0m\]]\$ '

# Get current branch name or commit
git_branch() {
        branch=`git symbolic-ref HEAD 2>/dev/null | sed -e 's|^refs/heads/||'`
        if [[ -z $branch ]]; then
                branch=`git rev-parse --short HEAD 2>/dev/null`
        fi
        echo $branch
}

git_branch_p() {
        branch=`git_branch`
        if [[ -n $branch ]]; then
                printf " $branch"
        fi
}

# List all branches, local and remote
SED_EX=r
if [[ `echo 'foo' | sed -Ee 's/foo/bar/' 2> /dev/null` ]]; then
    SED_EX=E
fi
alias branches='git branch -a | sed -'$SED_EX'e "s:^\*? *::" | sed -'$SED_EX'e "s:^(remotes/[^/]+)?/::g" | grep -v "HEAD -> origin/master" | sort | uniq'

alias push='git push'
alias pull='git pull'
alias add='git add'
alias merge='git merge'
#alias unpushed='git branch -vv | grep ahead'
alias unpushed='git log --branches --not --remotes --simplify-by-decoration --decorate --oneline'
alias gl='glog -10 --show-tags'
alias gll='git log --graph --decorate --pretty=oneline --abbrev-commit'

DEVHELPERS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
DHP=$DEVHELPERS_DIR/helpers.py

gdiff() {
    if git -p diff --exit-code "$@"; then
        git diff --cached "$@"
    fi
}

ci() {
    STORY=$($DHP story_from_branch $(git_branch))
    if [[ $? -ne 0 ]]; then
        return 1
    fi
    git_opts=$($DHP git_opts)
    if [[ $# == 0 ]]; then
        git_opts="$git_opts -e"
    fi
    git commit -am "$($DHP format_commit_message $STORY "$*")" $($DHP git_opts)
}

cm() {
    STORY=$($DHP story_from_branch $(git_branch))
    if [[ $? -ne 0 ]]; then
        return 1
    fi
    git_opts=$($DHP git_opts)
    if [[ $# == 0 ]]; then
        git_opts="$git_opts -e"
    fi
    git commit -m "$($DHP format_commit_message $STORY "$*")" $($DHP git_opts)
}

# Show what will be pushed from the current branch
show-push() {
    bdiff "$@" origin/$(git_branch)
}

# Show what will be pushed from the current branch
show-pull() {
    bdiff "$@" origin/$(git_branch) $(git_branch)
}

# Show what non-merge commits are in one branch but not another
# Usage:
#   bdiff IN NOT_IN
#
# So, `bdiff HEAD master` shows what's in current HEAD that's not in master
#
# With no arguments, defaults to bdiff HEAD BASE_BRANCH
# With one argument, defaults to bdiff HEAD $1
bdiff() {
    VERBOSE=""
    MERGES="--no-merges"
    OPTS=""
    unset A
    unset B
    while [[ $# -gt 0 ]]; do
        case "$1" in
            -m|--show-merges) MERGES="";;
            -v|--verbose) VERBOSE="true";;
            -vv|--very-verbose) VERBOSE="very";;
            -*) OPTS="$OPTS $1";;
            *)
                if [[ -z $A ]]; then
                    A=$1
                elif [[ -z $B ]]; then
                    B=$1
                else
                    echo "Too many paramaters: $1"
                    return
                fi;;
        esac
        shift
    done
    if [[ -z $A ]]; then
        A=`git_branch`
        B=`$DHP base_branch`
    elif [[ -z $B ]]; then
        B=$A
        A=`git_branch`
    fi
    if [[ "$VERBOSE" == "true" ]]; then
        git log $MERGES --stat --date=short $OPTS $* $A ^$B
    elif [[ "$VERBOSE" == "very" ]]; then
        git log $MERGES --stat -p --date=short $OPTS $* $A ^$B
    else
        if [[ "$MERGES" == "" ]]; then
            MERGES="--show-merges"
        fi
        glog $MERGES $OPTS "$@" $A ^$B
    fi
}

# List the divergence between two branches.
#
# This is similar to bdiff except that it shows
# the differences in both directions.  It shows
# all commits that are in master but not in HEAD
# first, then all commits in HEAD that are not
# in master.
bdiv() {
    A=$1
    B=$2
    if [[ "$A" == "" ]]; then
        A=`git_branch`
        B=`$DHP base_branch`
    elif [[ "$B" == "" ]]; then
        A=`git_branch`
        B=$1
    fi
    A_B_DIFFS=`git log --oneline --no-merges $A..$B | wc -l`
    B_A_DIFFS=`git log --oneline --no-merges $B..$A | wc -l`
    if [[ $A_B_DIFFS -eq 0 && $B_A_DIFFS -eq 0 ]]; then
        echo "Branches are not diverged"
        return
    fi
    echo
    if [[ $A_B_DIFFS -gt 0 ]]; then
        echo -e "In $B, not in $A:"
        bdiff $B $A | sed -e 's/^/  /'
    fi
    if [[ $A_B_DIFFS -gt 0 && $B_A_DIFFS -gt 0 ]]; then
        echo
    fi
    if [[ $B_A_DIFFS -gt 0 ]]; then
        echo "In $A, not in $B:"
        bdiff $A $B | sed -e 's/^/  /'
    fi
    echo
}

# Prettier version of git log --oneline
glog() {
    MERGES="--no-merges"
    TAGS=""
    OPTS=""
    while [[ $# -gt 0 && $1 == -* ]]; do
        if [[ "$1" == "--show-merges" ]]; then
            MERGES=""
        elif [[ "$1" == "--show-tags" ]]; then
            TAGS=" %C(yellow)%d%Creset"
        else
            OPTS="$OPTS $1"
        fi
        shift
    done
    git --no-pager log $MERGES --pretty=format:"%h : %ad : %an : %s $TAGS" --date=short $OPTS "$@" | perl -ne 'BEGIN { $max = 0; } @_ = split /:/, $_, 4; push @lines, [@_[0..3]]; $max = length($_[2]) if length($_[2]) > $max; END { printf "\e[0;33m%s\e[0m:%s:\e[1;34m%-${max}s\e[0m:%s", @$_ for @lines }' | less -RXF
}

# Show the full changelog, marked by release tags, starting with HEAD
changelog() {
    usage="Usage: changelog [-p PATTERN] [FROM] [TO]

      PATTERN  Fragment of tags to match, e.g. 'releaase-'
      FROM     Tag to start from
      TO       Tag to show up until (non-inclusive)
"
    pat=
    range=
    while [ "$1" ]; do
        case $1 in
            -h) echo "$usage"; return;;
            -p) shift; pat="-l*$1*";;
            *)
                if [[ -z $range ]]; then
                    range=$1
                else
                    range=$1..$range
                fi
                ;;
        esac
        shift
    done

    IFS=$'\n';
    for i in $(git --no-pager tag "$pat" | sort -r | awk '{ if (a) print a " " $1; else print "HEAD " $1 ;a=$1}'); do
        print_changelog ${i% *} ${i#* }
        echo
    done
    echo
}

# Prints the changelog between one tag and another; used by changelog()
print_changelog() {
    echo $1;
    git --no-pager log --pretty=format:"    %h [%an] %s" --date=short --no-merges $2..$1
    echo
}

# A pretty-printed shortlog without merges
shortlog() {
        git --no-pager log --no-merges --pretty=format:"%h : %ad : %an : %s" --date=short $* | perl -ne 'BEGIN { $max = 0; } split /:/, $_, 4; push @lines, [@_[0..3]]; $max = length($_[2]) if length($_[2]) > $max; END { printf "\e[0;33m%s\e[0m:%s:\e[1;34m%-${max}s\e[0m:%s", @$_ for @lines }' | less -FR
        echo
}

# Intelligent wrapper around git checkout.
#
# With this, you don't need to worry about whether you've checked
# out the branch before or not, whether you've set it up for remote
# tracking, or the syntax for creating a new branch from any other
# ref, remote or local.
checkout() {
    usage="Usage: checkout [-f] [-o ORIGIN] WHAT [FROM]

      WHAT  Ref to check out, or branch name to create
      FROM  If creating a new branch, what ref to create it from
            (e.g., master, HEAD, branch, tag) (defaults to master)
"
    new=
    old=$($DHP base_branch)
    cur=$(git_branch)
    file=
    remote_origin=

    if [[ -z $cur ]]; then
        echo "Not in a git repository"
        return 1
    fi

    while [ "$1" ]; do
        case $1 in
            -h) echo "$usage"; return;;
            -f) file=true;;
            -o) shift; remote_origin=$1;;
            *)
                if [[ -z $new ]]; then
                    new=$1
                else
                    old=$1
                fi
                ;;
        esac
        shift
    done

    if [[ -z $new ]]; then
        echo "Missing required argument"
        echo "$usage"
        return 1
    fi

    if [[ "$new" == "-" ]]; then
        git checkout @{-1}
        return
    fi

    if [[ -e $new && -n $file ]]; then
        echo -n "Confirm reset file? [y/N] "
        read confirm
        if [[ "$confirm" =~ [Yy] ]]; then
            git checkout -f $new
        fi
        return
    fi

    exists_locally=$(git rev-parse --verify -q $new)
    if [[ -z "$exists_locally" && "$new" == "master" ]]; then
        exists_locally=$(git rev-parse --verify -q main)
        if [[ -n "$exists_locally" ]]; then
            new="main"
        fi
    elif [[ -z "$exists_locally" && "$new" == "main" ]]; then
        exists_locally=$(git rev-parse --verify -q master)
        if [[ -n "$exists_locally" ]]; then
            new="master"
        fi
    fi
    if [[ -z "$remote_origin" ]]; then
        exists_remotely=$(git rev-parse --symbolic --remotes=*/$new | sed -e 's:^\(refs/remotes/\)\?\([^/]*\).*:\2:')
        if [[ -z "$exists_remotely" && "$new" == "master" ]]; then
            exists_remotely=$(git rev-parse --symbolic --remotes=*/main | sed -e 's:^\(refs/remotes/\)\?\([^/]*\).*:\2:')
            if [[ -n "$exists_remotely" ]]; then
                new="main"
            fi
        elif [[ -z "$exists_remotely" && "$new" == "main" ]]; then
            exists_remotely=$(git rev-parse --symbolic --remotes=*/master | sed -e 's:^\(refs/remotes/\)\?\([^/]*\).*:\2:')
            if [[ -n "$exists_remotely" ]]; then
                new="master"
            fi
        fi
        if [[ -z "$exists_remotely" ]]; then
            remote_origin=$(git remote | grep origin | head -1)
            if [[ -z "$remote_origin" ]]; then
                remote_origin=$(git remote | head -1)
            fi
        else
            remote_origin="$exists_remotely"
        fi
    else
        exists_remotely=$(git rev-parse --symbolic --remotes=$remote_origin/$new | sed -e 's:^refs/remotes/\([^/]*\).*:\1:')
        if [[ -z "$exists_remotely" && "$new" == "master" ]]; then
            exists_remotely=$(git rev-parse --symbolic --remotes=$remote_origin/main | sed -e 's:^\(refs/remotes/\)\?\([^/]*\).*:\2:')
            if [[ -n "$exists_remotely" ]]; then
                new="main"
            fi
        elif [[ -z "$exists_remotely" && "$new" == "main" ]]; then
            exists_remotely=$(git rev-parse --symbolic --remotes=$remote_origin/master | sed -e 's:^\(refs/remotes/\)\?\([^/]*\).*:\2:')
            if [[ -n "$exists_remotely" ]]; then
                new="master"
            fi
        fi
    fi

    if [[ -n $exists_locally ]]; then
        if [[ "$new" != "$cur" ]]; then
            git checkout $new
            if [ $? -gt 0 ]; then
                return $?
            fi
        fi
    elif [[ -n $exists_remotely ]]; then
        git checkout -b $new $remote_origin/$new
        if [ $? -gt 0 ]; then
            return $?
        fi
    else
        echo -n "Confirm new branch? [Y/n] "
        read confirm
        if [[ "$confirm" =~ [Nn] ]]; then
            return
        fi

        git checkout -b $new $old
        if [ $? -gt 0 ]; then
            return $?
        fi
        echo "New branch $new created from $old"
    fi

    if [[ -z `git config branch.$new.remote` ]]; then
        git config branch.$new.remote $remote_origin
        if [ $? -gt 0 ]; then
            return $?
        fi
    fi
    if [[ -z `git config branch.$new.merge` ]]; then
        git config branch.$new.merge refs/heads/$new
        if [ $? -gt 0 ]; then
            return $?
        fi
    fi
    utags
}

# Wrapper around git commit and git branch -D that DWYM
# Supports -r for remote deleting of branches
branch() {
        remote=
        delete=
        branch=
        for i in {1..9}; do
                case ${!i} in
                        -d) delete=true;;
                        -r) remote=true;;
                        *)
                                if [[ -z $branch ]]; then
                                        branch=${!i}
                                fi
                                ;;
                esac
        done
        if [[ -z $delete ]]; then
                checkout "$@"
                return
        fi
        if [[ -z $branch ]]; then
                echo "Missing branch name"
                return
        fi
        git branch -D $branch
        if [[ -n $remote ]]; then
                git push origin :$branch
        fi
}

alias st='git status'

utags() {
    if [[ "$USE_CTAGS" != "true" ]]; then
        return
    fi
    pushd . > /dev/null
    while [ ! -e .git ]; do
        cd ..
    done
    (ctags -R --c++-kinds=+p --fields=+iaS --extra=+q . 2> /dev/null &)
    popd > /dev/null
}

update() {
    BRANCH=`git_branch`
    UPDATE_FROM=$1
    MERGE_FROM=$1
    if [[ -z $UPDATE_FROM ]]; then
        UPDATE_FROM=$($DHP base_branch)
        MERGE_FROM="origin/$UPDATE_FROM"
    fi
    git diff --quiet HEAD &> /dev/null
    DIRTY=$?
    if [[ $DIRTY == 1 ]]; then
        git stash
    fi
    _use_ctags=$USE_CTAGS
    USE_CTAGS=false
    exists_remotely=$(git rev-parse --verify -q origin/$BRANCH)
    if [[ -n $exists_remotely ]]; then
        pull || return $?
    fi
    checkout $UPDATE_FROM && pull && checkout $BRANCH && merge $MERGE_FROM
    result=$?
    USE_CTAGS=$_use_ctags
    if [[ $DIRTY == 1 ]]; then
        git stash pop
    fi
    utags
    return $result
}

if [[ `type -t __gitcomp` ]]; then
    _git_branches_both() {
        __gitcomp "$(branches)"
    }

    commands="checkout update bdiff bdiv merge pre-merge"
    if [[ "$TAB_COMPLETE_REMOTE_BRANCHES" == "true" ]]; then
        for cmd in $commands; do
            complete -o default -o nospace -F _git_branches_both $cmd
        done
    else
        for cmd in $commands; do
            complete -o default -o nospace -F _git_checkout $cmd
        done
    fi
fi

red(){
    printf "\033[1;31m$*\033[0m"
}
green(){
    printf "\033[1;32m$*\033[0m"
}
yellow(){
    printf "\033[1;33m$*\033[0m"
}
white(){
    printf "\033[1;37m$*\033[0m"
}

story () {
    # FIXME: Currently doesn't use the DEVHELPERSRC; has hard-coded branch pattern
    # make sure story_number and number_found are both integers by adding zero to them
    story_raw_number=$(($1 + 0))
    story_number="[/]$story_raw_number[-]"
    branches_found=$(git branch -a | egrep 'remotes[/]origin' | egrep "$story_number")
    possible_name=$(echo $branches_found | head -1 | sed 's,[ ]*remotes/origin/,,g')
    number_found=$((`echo "$branches_found" | wc -l` + 0))

    if [ $number_found -gt 1 ]; then
        red "found more than one branch with the pattern '$story_number'.\n";
        for branch_name in `echo $branches_found`; do
            white "    $branch_name\n"
        done;
        red "please checkout it manually!\n";
        return 1
    fi;

    if [ $number_found -eq 1 ] && [ ${#possible_name} -gt 0 ]; then
        green "Sweet! I've found it!\n"
        echo
        white "Matched story: '"
        yellow "$possible_name"
        white "', now I'm checking it out...\n"

        (git checkout -qb $possible_name --track origin/$possible_name 2>&1 > /dev/null) 2>&1 > /dev/null
        if [ $? -ne 0 ]; then
            (git checkout $possible_name 2>&1 > /dev/null) 2>&1 > /dev/null
        fi;
        return 1

    else

        white "there is no branch for story number "
        yellow $story_raw_number
        white ",\n"

        white "do you want me to create for you ? ["
        green "Y"
        white "/"
        red "n"
        white "]"

        read confirm
        if [[ "$confirm" =~ [Nn] ]]; then
            return
        fi

        echo
        green "OK then, your new branch will be based on an updated master\n"
        green "and its name will be 'story/$USER/$story_raw_number-some-description-you-give-below'\n"

        description="notgiven"
        while [ $description = "notgiven" ]; do
            echo
            yellow ":: please describe your story in a few words:\n"
            read dsc

            chk=$(echo "$dsc" | sed 's,[ ]*,,g')
            if [ ${#chk} -eq 0 ]; then
                red "  -> invalid description, don't be slacker, write something decent!\n"
            else
                export description=$(echo $dsc | sed 's,[^a-zA-Z0-9],-,g' | sed 's,^[-]*,,g' | sed 's,[-]*$,,g')
                name="story/$USER/$story_raw_number-$description"
                checkout "$name" master
            fi;
        done;
        return
    fi;
}

# Copy all branches from one remote to another.
# e.g.: copy_all_branches origin sb
# pulls all branches from origin and pushes them to sb
copy_all_branches() {
    git push $2 +refs/remotes/$1/*:refs/heads/*
}

# Output a color escape sequence based on the status of the current branch
function git_color {
    local git_status="$(git status 2> /dev/null)"
    local red='\e[1;31m'
    local green='\e[1;32m'
    local yellow='\e[1;33m'

    if [[ ! $git_status =~ "working directory clean" ]]; then
        echo -e $red
    elif [[ $git_status =~ "Your branch is ahead of" ]]; then
        echo -e $yellow
    elif [[ $git_status =~ "nothing to commit" ]]; then
        echo -e $green
    fi
}