#!/bin/sh

# Sets: new_commits
# Assumes: $oldrev $newrev $refname
#
# This is for use in post receive hooks, as it assumes the refname has moved and
# is now newrev, we need to discard it. This is down with bash string replace,
# as it will replace only the first match, compared to the canonical "grep -v"
# approach which will throw out multiple matches if the same commit is referred
# to by multiple branches.
#
# Excellent, excellent docs from Andy Parkin's email script
#
##################################################
#
# Consider this:
#   1 --- 2 --- O --- X --- 3 --- 4 --- N
#
# O is $oldrev for $refname
# N is $newrev for $refname
# X is a revision pointed to by some other ref, for which we may
#   assume that an email has already been generated.
# In this case we want to issue an email containing only revisions
# 3, 4, and N.  Given (almost) by
#
#  git rev-list N ^O --not --all
#
# The reason for the "almost", is that the "--not --all" will take
# precedence over the "N", and effectively will translate to
#
#  git rev-list N ^O ^X ^N
#
# So, we need to build up the list more carefully.  git rev-parse
# will generate a list of revs that may be fed into git rev-list.
# We can get it to make the "--not --all" part and then filter out
# the "^N" with:
#
#  git rev-parse --not --all | grep -v N
#
# Then, using the --stdin switch to git rev-list we have effectively
# manufactured
#
#  git rev-list N ^O ^X
#
# This leaves a problem when someone else updates the repository
# while this script is running.  Their new value of the ref we're
# working on would be included in the "--not --all" output; and as
# our $newrev would be an ancestor of that commit, it would exclude
# all of our commits.  What we really want is to exclude the current
# value of $refname from the --not list, rather than N itself.  So:
#
#  git rev-parse --not --all | grep -v $(git rev-parse $refname)
#
# Get's us to something pretty safe (apart from the small time
# between refname being read, and git rev-parse running - for that,
# I give up)
#
#
# Next problem, consider this:
#   * --- B --- * --- O ($oldrev)
#          \
#           * --- X --- * --- N ($newrev)
#
# That is to say, there is no guarantee that oldrev is a strict
# subset of newrev (it would have required a --force, but that's
# allowed).  So, we can't simply say rev-list $oldrev..$newrev.
# Instead we find the common base of the two revs and list from
# there.
#
# As above, we need to take into account the presence of X; if
# another branch is already in the repository and points at some of
# the revisions that we are about to output - we don't want them.
# The solution is as before: git rev-parse output filtered.
#
# Finally, tags: 1 --- 2 --- O --- T --- 3 --- 4 --- N
#
# Tags pushed into the repository generate nice shortlog emails that
# summarise the commits between them and the previous tag.  However,
# those emails don't include the full commit messages that we output
# for a branch update.  Therefore we still want to output revisions
# that have been output on a tag email.
#
# Luckily, git rev-parse includes just the tool.  Instead of using
# "--all" we use "--branches"; this has the added benefit that
# "remotes/" will be ignored as well.
#
##################################################
function set_new_commits() {
	nl=$'\n'

	# Get all the current branches, not'd as we want only new ones
	new_commits=$(git rev-parse --not --branches)

	# Strip off the not current branch
	new_hash=$(git rev-parse $refname)
	new_commits=${new_commits/^$new_hash/}

	# Put back newrev without the not
	new_commits=${new_commits}${nl}${newrev}

	# Put in ^oldrev if it's not a new branch
	if [ "$oldrev" != "0000000000000000000000000000000000000000" ] ; then
		new_commits=${new_commits}${nl}^${oldrev}
	fi

	new_commits=${new_commits/$nl$nl/$nl}
	new_commits=${new_commits/#$nl/}
}

# Sets: $change_type
# Assumes: $oldrev $newrev
#
# --- Interpret
# 0000->1234 (create)
# 1234->2345 (update)
# 2345->0000 (delete)
function set_change_type() {
	if [ "$oldrev" == "0000000000000000000000000000000000000000" ] ; then
		change_type="create"
	else
		if [ "$newrev" == "0000000000000000000000000000000000000000" ] ; then
			change_type="delete"
		else
			change_type="update"
		fi
	fi
}

# Sets: $newrev_type $oldrev_type $rev $rev_type
# Assumes: $newrev $oldrev
# --- Get the revision types
function set_rev_types() {
	newrev_type=$(git cat-file -t "$newrev" 2> /dev/null)
	oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
	if [ "$newrev" == "0000000000000000000000000000000000000000" ] ; then
		rev_type="$oldrev_type"
		rev="$oldrev"
	else
		rev_type="$newrev_type"
		rev="$newrev"
	fi
}

# Sets: $describe
# Assumes: $rev
#
# The email subject will contain the best description of the ref that we can build from the parameters
function set_describe() {
	rev_to_describe="$rev"
	if [ "$1" != "" ] ; then
		rev_to_describe="$1"
	fi

	describe=$(git describe $rev_to_describe 2>/dev/null)
	if [ -z "$describe" ]; then
		describe=$rev_to_describe
	fi
}

# Sets: $describe_tags
# Assumes: $rev
#
# The email subject will contain the best description of the ref that we can build from the parameters
function set_describe_tags() {
	rev_to_describe="$rev"
	if [ "$1" != "" ] ; then
		rev_to_describe="$1"
	fi

	describe_tags=$(git describe --tags $rev_to_describe 2>/dev/null)
	if [ -z "$describe_tags" ]; then
		describe_tags=$rev_to_describe
	fi
}

# Takes a lockfile path and command to execute once the lock is acquired.
#
# Retries every second for 5 minutes.
#
# with_lock "foo.lock" "echo a"             # Works
# with_lock "foo.lock" "echo b1 ; echo b2"  # Work
# function several() {
# echo several1 ; echo several2
# }
# with_lock "foo.lock" several              # Works
#
function with_lock() {
	lockfile="$1"
	block="$2"
	with_lock_has_lock=1

	trap with_lock_unlock_if_held INT TERM EXIT
	lockfile -1 -r 300 "$lockfile"
	with_lock_has_lock=$?
	if [ $with_lock_has_lock -ne 0 ] ; then
		exit $?
	fi
	eval "$block"
	rm -f "$lockfile"
	with_lock_has_lock=1
}

function with_lock_unlock_if_held() {
	if [[ "$with_lock_has_lock" -eq 0 ]] ; then
		rm -f "$lockfile"
	fi
}

function display_error_message() {
	echo "----------------------------------------------------" >&2
	echo ""                                                     >&2
	echo ""                                                     >&2
	for ((i=1;i<=$#;i+=1)); do
	eval message="$"$i
	echo "$message"                                             >&2
	done
	echo ""                                                     >&2
	echo ""                                                     >&2
	echo "----------------------------------------------------" >&2
}