#!/bin/sh
#
# Copyright (c) 2007 Andy Parkins
#
# An example hook script to mail out commit update information.  This hook sends emails
# listing new revisions to the repository introduced by the change being reported.  The
# rule is that (for branch updates) each commit will appear on one email and one email
# only.
#
# This hook is stored in the contrib/hooks directory.  Your distribution will have put
# this somewhere standard.  You should make this script executable then link to it in
# the repository you would like to use it in.  For example, on debian the hook is stored
# in /usr/share/doc/git-core/contrib/hooks/post-receive-email:
#
#  chmod a+x post-receive-email
#  cd /path/to/your/repository.git
#  ln -sf /usr/share/doc/git-core/contrib/hooks/post-receive-email hooks/post-receive
#
# This hook script assumes it is enabled on the central repository of a project, with
# all users pushing only to it and not between each other.  It will still work if you
# don't operate in that style, but it would become possible for the email to be from
# someone other than the person doing the push.
#
# Config
# ------
# hooks.mailinglist
#   This is the list that all pushes will go to; leave it blank to not send
#   emails for every ref update.
# hooks.announcelist
#   This is the list that all pushes of annotated tags will go to.  Leave it
#   blank to default to the mailinglist field.  The announce emails lists the
#   short log summary of the changes since the last annotated tag.
# hook.envelopesender
#   If set then the -f option is passed to sendmail to allow the envelope sender
#   address to be set
#
# Notes
# -----
# All emails have their subjects prefixed with "[SCM]" to aid filtering.
# All emails include the headers "X-Git-Refname", "X-Git-Oldrev",
# "X-Git-Newrev", and "X-Git-Reftype" to enable fine tuned filtering and
# give information for debugging.
#

# ---------------------------- Functions

#
# Top level email generation function.  This decides what type of update
# this is and calls the appropriate body-generation routine after outputting
# the common header
#
# Note this function doesn't actually generate any email output, that is taken
# care of by the functions it calls:
#  - generate_email_header
#  - generate_create_XXXX_email
#  - generate_update_XXXX_email
#  - generate_delete_XXXX_email
#  - generate_email_footer
#
generate_email()
{
        # --- Arguments
        oldrev=$(git rev-parse $1)
        newrev=$(git rev-parse $2)
        refname="$3"

        # --- Interpret
        # 0000->1234 (create)
        # 1234->2345 (update)
        # 2345->0000 (delete)
        if expr "$oldrev" : '0*$' >/dev/null
        then
                change_type="create"
        else
                if expr "$newrev" : '0*$' >/dev/null
                then
                        change_type="delete"
                else
                        change_type="update"
                fi
        fi

        # --- Get the revision types
        newrev_type=$(git cat-file -t $newrev 2> /dev/null)
        oldrev_type=$(git cat-file -t "$oldrev" 2> /dev/null)
        case "$change_type" in
        create|update)
                rev="$newrev"
                rev_type="$newrev_type"
                ;;
        delete)
                rev="$oldrev"
                rev_type="$oldrev_type"
                ;;
        esac

        # The revision type tells us what type the commit is, combined with
        # the location of the ref we can decide between
        #  - working branch
        #  - tracking branch
        #  - unannoted tag
        #  - annotated tag
        case "$refname","$rev_type" in
                refs/tags/*,commit)
                        # un-annotated tag
                        refname_type="tag"
                        short_refname=${refname##refs/tags/}
                        ;;
                refs/tags/*,tag)
                        # annotated tag
                        refname_type="annotated tag"
                        short_refname=${refname##refs/tags/}
                        # change recipients
                        if [ -n "$announcerecipients" ]; then
                                recipients="$announcerecipients"
                        fi
                        ;;
                refs/heads/*,commit)
                        # branch
                        refname_type="branch"
                        short_refname=${refname##refs/heads/}
                        ;;
                refs/remotes/*,commit)
                        # tracking branch
                        refname_type="tracking branch"
                        short_refname=${refname##refs/remotes/}
                        echo >&2 "*** Push-update of tracking branch, $refname"
                        echo >&2 "***  - no email generated."
                        exit 0
                        ;;
                *)
                        # Anything else (is there anything else?)
                        echo >&2 "*** Unknown type of update to $refname ($rev_type)"
                        echo >&2 "***  - no email generated"
                        exit 1
                        ;;
        esac

        # Check if we've got anyone to send to
        if [ -z "$recipients" ]; then
                echo >&2 "*** hooks.recipients is not set so no email will be sent"
                echo >&2 "*** for $refname update $oldrev->$newrev"
                exit 0
        fi

        # Email parameters
        # The committer will be obtained from the latest existing rev; so
        # for a deletion it will be the oldrev, for the others, then newrev
        committer=$(git show --pretty=full -s $rev | sed -ne "s/^Commit: //p" |
                sed -ne 's/\(.*\) </"\1" </p')
        # The email subject will contain the best description of the ref
        # that we can build from the parameters
        describe=$(git describe $rev 2>/dev/null)
        if [ -z "$describe" ]; then
                describe=$rev
        fi

        generate_email_header

        # Call the correct body generation function
        fn_name=general
        case "$refname_type" in
        "tracking branch"|branch)
                fn_name=branch
                ;;
        "annotated tag")
                fn_name=atag
                ;;
        esac
        generate_${change_type}_${fn_name}_email

        generate_email_footer
}

generate_email_header()
{
        # --- Email (all stdout will be the email)
        # Generate header
        cat <<-EOF
        From: $committer
        To: $recipients
        Subject: ${EMAILPREFIX}$projectdesc $refname_type, $short_refname, ${change_type}d. $describe
        X-Git-Refname: $refname
        X-Git-Reftype: $refname_type
        X-Git-Oldrev: $oldrev
        X-Git-Newrev: $newrev

        This is an automated email from the git hooks/post-receive script. It was
        generated because a ref change was pushed to the repository containing
        the project "$projectdesc".

        The $refname_type, $short_refname has been ${change_type}d
        EOF
}

generate_email_footer()
{
        cat <<-EOF


        hooks/post-receive
        -- 
        $projectdesc
        EOF
}

# --------------- Branches

#
# Called for the creation of a branch
#
generate_create_branch_email()
{
        # This is a new branch and so oldrev is not valid
        echo "        at  $newrev ($newrev_type)"
        echo ""

        echo $LOGBEGIN
        # This shows all log entries that are not already covered by
        # another ref - i.e. commits that are now accessible from this
        # ref that were previously not accessible (see generate_update_branch_email
        # for the explanation of this command)
        git rev-parse --not --branches | grep -v $(git rev-parse $refname) |
        git rev-list --pretty --stdin $newrev
        echo $LOGEND
}

#
# Called for the change of a pre-existing branch
#
generate_update_branch_email()
{
        # 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.

        # List all of the revisions that were removed by this update, in a fast forward
        # update, this list will be empty, because rev-list O ^N is empty.  For a non
        # fast forward, O ^N is the list of removed revisions
        fastforward=""
        rev=""
        for rev in $(git rev-list $newrev..$oldrev)
        do
                revtype=$(git cat-file -t "$rev")
                echo "  discards  $rev ($revtype)"
        done
        if [ -z "$rev" ]; then
                fast_forward=1
        fi

        # List all the revisions from baserev to newrev in a kind of
        # "table-of-contents"; note this list can include revisions that have
        # already had notification emails and is present to show the full detail
        # of the change from rolling back the old revision to the base revision and
        # then forward to the new revision
        for rev in $(git rev-list $oldrev..$newrev)
        do
                revtype=$(git cat-file -t "$rev")
                echo "       via  $rev ($revtype)"
        done

        if [ -z "$fastforward" ]; then
                echo "      from  $oldrev ($oldrev_type)"
        else
                echo ""
                echo "This update added new revisions after undoing old revisions.  That is to"
                echo "say, the old revision is not a strict subset of the new revision.  This"
                echo "situation occurs when you --force push a change and generate a"
                echo "repository containing something like this:"
                echo ""
                echo " * -- * -- B -- O -- O -- O ($oldrev)"
                echo "            \\"
                echo "             N -- N -- N ($newrev)"
                echo ""
                echo "When this happens we assume that you've already had alert emails for all"
                echo "of the O revisions, and so we here report only the revisions in the N"
                echo "branch from the common base, B."
        fi

        echo ""
        echo "Those revisions listed above that are new to this repository have"
        echo "not appeared on any other notification email; so we list those"
        echo "revisions in full, below."

        echo ""
        echo $LOGBEGIN
        git rev-parse --not --branches | grep -v $(git rev-parse $refname) |
        git rev-list --pretty --stdin $oldrev..$newrev

        # XXX: Need a way of detecting whether git rev-list actually outputted
        # anything, so that we can issue a "no new revisions added by this
        # update" message

        echo $LOGEND

        # The diffstat is shown from the old revision to the new revision.  This
        # is to show the truth of what happened in this change.  There's no point
        # showing the stat from the base to the new revision because the base
        # is effectively a random revision at this point - the user will be
        # interested in what this revision changed - including the undoing of
        # previous revisions in the case of non-fast forward updates.
        echo ""
        echo "Summary of changes:"
        git diff-tree --stat --summary --find-copies-harder $oldrev..$newrev
}

#
# Called for the deletion of a branch
#
generate_delete_branch_email()
{
        echo "       was  $oldrev"
        echo ""
        echo $LOGEND
        git show -s --pretty=oneline $oldrev
        echo $LOGEND
}

# --------------- Annotated tags

#
# Called for the creation of an annotated tag
#
generate_create_atag_email()
{
        echo "        at  $newrev ($newrev_type)"

        generate_atag_email
}

#
# Called for the update of an annotated tag (this is probably a rare event
# and may not even be allowed)
#
generate_update_atag_email()
{
        echo "        to  $newrev ($newrev_type)"
        echo "      from  $oldrev (which is now obsolete)"

        generate_atag_email
}

#
# Called when an annotated tag is created or changed
#
generate_atag_email()
{
        # Use git-for-each-ref to pull out the individual fields from the tag
        eval $(git for-each-ref --shell --format='
        tagobject=%(*objectname)
        tagtype=%(*objecttype)
        tagger=%(taggername)
        tagged=%(taggerdate)' $refname
        )

        echo "   tagging  $tagobject ($tagtype)"
        case "$tagtype" in
        commit)
                # If the tagged object is a commit, then we assume this is a
                # release, and so we calculate which tag this tag is replacing
                prevtag=$(git describe --abbrev=0 $newrev^ 2>/dev/null)

                if [ -n "$prevtag" ]; then
                        echo "  replaces  $prevtag"
                fi
                ;;
        *)
                echo "    length  $(git cat-file -s $tagobject) bytes"
                ;;
        esac
        echo " tagged by  $tagger"
        echo "        on  $tagged"

        echo ""
        echo $LOGBEGIN

        # Show the content of the tag message; this might contain a change log
        # or release notes so is worth displaying.
        git cat-file tag $newrev | sed -e '1,/^$/d'

        echo ""
        case "$tagtype" in
        commit)
                # Only commit tags make sense to have rev-list operations performed
                # on them
                if [ -n "$prevtag" ]; then
                        # Show changes since the previous release
                        git rev-list --pretty=short "$prevtag..$newrev" | git shortlog
                else
                        # No previous tag, show all the changes since time began
                        git rev-list --pretty=short $newrev | git shortlog
                fi
                ;;
        *)
                # XXX: Is there anything useful we can do for non-commit objects?
                ;;
        esac

        echo $LOGEND
}

#
# Called for the deletion of an annotated tag
#
generate_delete_atag_email()
{
        echo "       was  $oldrev"
        echo ""
        echo $LOGEND
        git show -s --pretty=oneline $oldrev
        echo $LOGEND
}

# --------------- General references

#
# Called when any other type of reference is created (most likely a
# non-annotated tag)
#
generate_create_general_email()
{
        echo "        at  $newrev ($newrev_type)"

        generate_general_email
}

#
# Called when any other type of reference is updated (most likely a
# non-annotated tag)
#
generate_update_general_email()
{
        echo "        to  $newrev ($newrev_type)"
        echo "      from  $oldrev"

        generate_general_email
}

#
# Called for creation or update of any other type of reference
#
generate_general_email()
{
        # Unannotated tags are more about marking a point than releasing a version;
        # therefore we don't do the shortlog summary that we do for annotated tags
        # above - we simply show that the point has been marked, and print the log
        # message for the marked point for reference purposes
        #
        # Note this section also catches any other reference type (although there
        # aren't any) and deals with them in the same way.

        echo ""
        if [ "$newrev_type" = "commit" ]; then
                echo $LOGBEGIN
                git show --no-color --root -s $newrev
                echo $LOGEND
        else
                # What can we do here?  The tag marks an object that is not a commit,
                # so there is no log for us to display.  It's probably not wise to
                # output git-cat-file as it could be a binary blob.  We'll just say how
                # big it is
                echo "$newrev is a $newrev_type, and is $(git cat-file -s $newrev) bytes long."
        fi
}

#
# Called for the deletion of any other type of reference
#
generate_delete_general_email()
{
        echo "       was  $oldrev"
        echo ""
        echo $LOGEND
        git show -s --pretty=oneline $oldrev
        echo $LOGEND
}

# ---------------------------- main()

# --- Constants
EMAILPREFIX="[SCM] "
LOGBEGIN="- Log -----------------------------------------------------------------"
LOGEND="-----------------------------------------------------------------------"

# --- Config
# Set GIT_DIR either from the working directory, or from the environment
# variable.
GIT_DIR=$(git rev-parse --git-dir 2>/dev/null)
if [ -z "$GIT_DIR" ]; then
        echo >&2 "fatal: post-receive: GIT_DIR not set"
        exit 1
fi

projectdesc=$(sed -e '1p' "$GIT_DIR/description")
# Check if the description is unchanged from it's default, and shorten it to a
# more manageable length if it is
if expr "$projectdesc" : "Unnamed repository.*$" >/dev/null
then
        projectdesc="UNNAMED PROJECT"
fi

recipients=$(git repo-config hooks.mailinglist)
announcerecipients=$(git repo-config hooks.announcelist)
envelopesender=$(git-repo-config hooks.envelopesender)

# --- Main loop
# Allow dual mode: run from the command line just like the update hook, or if
# no arguments are given then run as a hook script
if [ -n "$1" -a -n "$2" -a -n "$3" ]; then
        # Output to the terminal in command line mode - if someone wanted to
        # resend an email; they could redirect the output to sendmail themselves
        PAGER= generate_email $2 $3 $1
else
        if [ -n "$envelopesender" ]; then
                envelopesender="-f '$envelopesender'"
        fi

        while read oldrev newrev refname
        do
                generate_email $oldrev $newrev $refname |
                /usr/sbin/sendmail -t $envelopesender
        done
fi