#! /usr/bin/env python2

# Copyright (c) 2012-2014 Michael Haggerty and others

# Derived from contrib/hooks/post-receive-email, which is

# Copyright (c) 2007 Andy Parkins

# and also includes contributions by other authors.

#

# This file is part of git-multimail.

#

# git-multimail is free software: you can redistribute it and/or

# modify it under the terms of the GNU General Public License version

# 2 as published by the Free Software Foundation.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see

# <http: licenses="" www.gnu.org="">.</http:>

"""Generate notification emails for pushes to a git repository.

This hook sends emails describing changes introduced by pushes to a

git repository.  For each reference that was changed, it emits one

ReferenceChange email summarizing how the reference was changed,

followed by one Revision email for each new commit that was introduced

by the reference change.

Each commit is announced in exactly one Revision email.  If the same

commit is merged into another branch in the same or a later push, then

the ReferenceChange email will list the commit's SHA1 and its one-line

summary, but no new Revision email will be generated.

This script is designed to be used as a "post-receive" hook in a git

repository (see githooks(5)).  It can also be used as an "update"

script, but this usage is not completely reliable and is deprecated.

To help with debugging, this script accepts a --stdout option, which

causes the emails to be written to standard output rather than sent

using sendmail.

See the accompanying README file for the complete documentation.

"""

import sys

import os

import re

import bisect

import socket

import subprocess

import shlex

import optparse

import smtplib

import time

try:

    from email.utils import make_msgid

    from email.utils import getaddresses

    from email.utils import formataddr

    from email.utils import formatdate

    from email.header import Header

except ImportError:

    # Prior to Python 2.5, the email module used different names:

    from email.Utils import make_msgid

    from email.Utils import getaddresses

    from email.Utils import formataddr

    from email.Utils import formatdate

    from email.Header import Header

DEBUG = False

ZEROS = '0' * 40

LOGBEGIN = '- Log -------------------------------------------------------'\

    '----------\n'

LOGEND = '---------------------------------------------------------------'\

    '--------\n'

ADDR_HEADERS = set(['from', 'to', 'cc', 'bcc', 'reply-to', 'sender'])

# It is assumed in many places that the encoding is uniformly UTF-8,

# so changing these constants is unsupported.  But define them here

# anyway, to make it easier to find (at least most of) the places

# where the encoding is important.

(ENCODING, CHARSET) = ('UTF-8', 'utf-8')

REF_CREATED_SUBJECT_TEMPLATE = (

    '%(emailprefix)s%(refname_type)s %(short_refname)s created'

    ' (now %(newrev_short)s)'

    )

REF_UPDATED_SUBJECT_TEMPLATE = (

    '%(emailprefix)s%(refname_type)s %(short_refname)s updated'

    ' (%(oldrev_short)s -> %(newrev_short)s)'

    )

REF_DELETED_SUBJECT_TEMPLATE = (

    '%(emailprefix)s%(refname_type)s %(short_refname)s deleted'

    ' (was %(oldrev_short)s)'

    )

REFCHANGE_HEADER_TEMPLATE = """\

Date: %(send_date)s

To: %(recipients)s

Subject: %(subject)s

MIME-Version: 1.0

Content-Type: text/plain; charset=%(charset)s

Content-Transfer-Encoding: 8bit

Message-ID: %(msgid)s

From: %(fromaddr)s

Reply-To: %(reply_to)s

X-Git-Host: %(fqdn)s

X-Git-Repo: %(repo_shortname)s

X-Git-Refname: %(refname)s

X-Git-Reftype: %(refname_type)s

X-Git-Oldrev: %(oldrev)s

X-Git-Newrev: %(newrev)s

Auto-Submitted: auto-generated

"""

REFCHANGE_INTRO_TEMPLATE = """\

This is an automated email from the git hooks/post-receive script.

%(pusher)s pushed a change to %(refname_type)s %(short_refname)s

in repository %(repo_shortname)s.

"""

FOOTER_TEMPLATE = """\

-- \n\

To stop receiving notification emails like this one, please contact

%(administrator)s.

"""

REWIND_ONLY_TEMPLATE = """\

This update removed existing revisions from the reference, leaving the

reference pointing at a previous point in the repository history.

 * -- * -- N   %(refname)s (%(newrev_short)s)

            \\

             O -- O -- O   (%(oldrev_short)s)

Any revisions marked "omits" are not gone; other references still

refer to them.  Any revisions marked "discards" are gone forever.

"""

NON_FF_TEMPLATE = """\

This update added new revisions after undoing existing revisions.

That is to say, some revisions that were in the old version of the

%(refname_type)s are not in the new version.  This situation occurs

when a user --force pushes a change and generates a repository

containing something like this:

 * -- * -- B -- O -- O -- O   (%(oldrev_short)s)

            \\

             N -- N -- N   %(refname)s (%(newrev_short)s)

You should already have received notification emails for all of the O

revisions, and so the following emails describe only the N revisions

from the common base, B.

Any revisions marked "omits" are not gone; other references still

refer to them.  Any revisions marked "discards" are gone forever.

"""

NO_NEW_REVISIONS_TEMPLATE = """\

No new revisions were added by this update.

"""

DISCARDED_REVISIONS_TEMPLATE = """\

This change permanently discards the following revisions:

"""

NO_DISCARDED_REVISIONS_TEMPLATE = """\

The revisions that were on this %(refname_type)s are still contained in

other references; therefore, this change does not discard any commits

from the repository.

"""

NEW_REVISIONS_TEMPLATE = """\

The %(tot)s revisions listed above as "new" are entirely new to this

repository and will be described in separate emails.  The revisions

listed as "adds" were already present in the repository and have only

been added to this reference.

"""

TAG_CREATED_TEMPLATE = """\

        at  %(newrev_short)-9s (%(newrev_type)s)

"""

TAG_UPDATED_TEMPLATE = """\

*** WARNING: tag %(short_refname)s was modified! ***

      from  %(oldrev_short)-9s (%(oldrev_type)s)

        to  %(newrev_short)-9s (%(newrev_type)s)

"""

TAG_DELETED_TEMPLATE = """\

*** WARNING: tag %(short_refname)s was deleted! ***

"""

# The template used in summary tables.  It looks best if this uses the

# same alignment as TAG_CREATED_TEMPLATE and TAG_UPDATED_TEMPLATE.

BRIEF_SUMMARY_TEMPLATE = """\

%(action)10s  %(rev_short)-9s %(text)s

"""

NON_COMMIT_UPDATE_TEMPLATE = """\

This is an unusual reference change because the reference did not

refer to a commit either before or after the change.  We do not know

how to provide full information about this reference change.

"""

REVISION_HEADER_TEMPLATE = """\

Date: %(send_date)s

To: %(recipients)s

Subject: %(emailprefix)s%(num)02d/%(tot)02d: %(oneline)s

MIME-Version: 1.0

Content-Type: text/plain; charset=%(charset)s

Content-Transfer-Encoding: 8bit

From: %(fromaddr)s

Reply-To: %(reply_to)s

In-Reply-To: %(reply_to_msgid)s

References: %(reply_to_msgid)s

X-Git-Host: %(fqdn)s

X-Git-Repo: %(repo_shortname)s

X-Git-Refname: %(refname)s

X-Git-Reftype: %(refname_type)s

X-Git-Rev: %(rev)s

Auto-Submitted: auto-generated

"""

REVISION_INTRO_TEMPLATE = """\

This is an automated email from the git hooks/post-receive script.

%(pusher)s pushed a commit to %(refname_type)s %(short_refname)s

in repository %(repo_shortname)s.

"""

REVISION_FOOTER_TEMPLATE = FOOTER_TEMPLATE

class CommandError(Exception):

    def __init__(self, cmd, retcode):

        self.cmd = cmd

        self.retcode = retcode

        Exception.__init__(

            self,

            'Command "%s" failed with retcode %s' % (' '.join(cmd), retcode,)

            )

class ConfigurationException(Exception):

    pass

# The "git" program (this could be changed to include a full path):

GIT_EXECUTABLE = 'git'

# How "git" should be invoked (including global arguments), as a list

# of words.  This variable is usually initialized automatically by

# read_git_output() via choose_git_command(), but if a value is set

# here then it will be used unconditionally.

GIT_CMD = None

def choose_git_command():

    """Decide how to invoke git, and record the choice in GIT_CMD."""

    global GIT_CMD

    if GIT_CMD is None:

        try:

            # Check to see whether the "-c" option is accepted (it was

            # only added in Git 1.7.2).  We don't actually use the

            # output of "git --version", though if we needed more

            # specific version information this would be the place to

            # do it.

            cmd = [GIT_EXECUTABLE, '-c', 'foo.bar=baz', '--version']

            read_output(cmd)

            GIT_CMD = [

                GIT_EXECUTABLE, '-c',

                'i18n.logoutputencoding=%s' % (ENCODING,)]

        except CommandError:

            GIT_CMD = [GIT_EXECUTABLE]

def read_git_output(args, input=None, keepends=False, **kw):

    """Read the output of a Git command."""

    if GIT_CMD is None:

        choose_git_command()

    return read_output(

        GIT_CMD + args, input=input, keepends=keepends, **kw)

def read_output(cmd, input=None, keepends=False, **kw):

    if input:

        stdin = subprocess.PIPE

    else:

        stdin = None

    p = subprocess.Popen(

        cmd, stdin=stdin, stdout=subprocess.PIPE,

        stderr=subprocess.PIPE, **kw

        )

    (out, err) = p.communicate(input)

    retcode = p.wait()

    if retcode:

        raise CommandError(cmd, retcode)

    if not keepends:

        out = out.rstrip('\n\r')

    return out

def read_git_lines(args, keepends=False, **kw):

    """Return the lines output by Git command.

    Return as single lines, with newlines stripped off."""

    return read_git_output(args, keepends=True, **kw).splitlines(keepends)

def header_encode(text, header_name=None):

    """Encode and line-wrap the value of an email header field."""

    try:

        if isinstance(text, str):

            text = text.decode(ENCODING, 'replace')

        return Header(text, header_name=header_name).encode()

    except UnicodeEncodeError:

        return Header(text, header_name=header_name, charset=CHARSET,

                      errors='replace').encode()

def addr_header_encode(text, header_name=None):

    """Encode and line-wrap the value of an email header field containing

    email addresses."""

    return Header(

        ', '.join(

            formataddr((header_encode(name), emailaddr))

            for name, emailaddr in getaddresses([text])

            ),

        header_name=header_name

        ).encode()

class Config(object):

    def __init__(self, section, git_config=None):

        """Represent a section of the git configuration.

        If git_config is specified, it is passed to "git config" in

        the GIT_CONFIG environment variable, meaning that "git config"

        will read the specified path rather than the Git default

        config paths."""

        self.section = section

        if git_config:

            self.env = os.environ.copy()

            self.env['GIT_CONFIG'] = git_config

        else:

            self.env = None

    @staticmethod

    def _split(s):

        """Split NUL-terminated values."""

        words = s.split('\0')

        assert words[-1] == ''

        return words[:-1]

    def get(self, name, default=None):

        try:

            values = self._split(read_git_output(

                ['config', '--get', '--null', '%s.%s' % (self.section, name)],

                env=self.env, keepends=True,

                ))

            assert len(values) == 1

            return values[0]

        except CommandError:

            return default

    def get_bool(self, name, default=None):

        try:

            value = read_git_output(

                ['config', '--get', '--bool', '%s.%s' % (self.section, name)],

                env=self.env,

                )

        except CommandError:

            return default

        return value == 'true'

    def get_all(self, name, default=None):

        """Read a (possibly multivalued) setting from the configuration.

        Return the result as a list of values, or default if the name

        is unset."""

        try:

            return self._split(read_git_output(

                ['config', '--get-all', '--null', '%s.%s' % (

                    elf.section, name)],

                env=self.env, keepends=True,

                ))

        except CommandError, e:

            if e.retcode == 1:

                # "the section or key is invalid"; i.e., there is no

                # value for the specified key.

                return default

            else:

                raise

    def get_recipients(self, name, default=None):

        """Read a recipients list from the configuration.

        Return the result as a comma-separated list of email

        addresses, or default if the option is unset.  If the setting

        has multiple values, concatenate them with comma separators."""

        lines = self.get_all(name, default=None)

        if lines is None:

            return default

        return ', '.join(line.strip() for line in lines)

    def set(self, name, value):

        read_git_output(

            ['config', '%s.%s' % (self.section, name), value],

            env=self.env,

            )

    def add(self, name, value):

        read_git_output(

            ['config', '--add', '%s.%s' % (self.section, name), value],

            env=self.env,

            )

    def has_key(self, name):

        return self.get_all(name, default=None) is not None

    def unset_all(self, name):

        try:

            read_git_output(

                ['config', '--unset-all', '%s.%s' % (self.section, name)],

                env=self.env,

                )

        except CommandError, e:

            if e.retcode == 5:

                # The name doesn't exist, which is what we wanted anyway...

                pass

            else:

                raise

    def set_recipients(self, name, value):

        self.unset_all(name)

        for pair in getaddresses([value]):

            self.add(name, formataddr(pair))

def generate_summaries(*log_args):

    """Generate a brief summary for each revision requested.

    log_args are strings that will be passed directly to "git log" as

    revision selectors.  Iterate over (sha1_short, subject) for each

    commit specified by log_args (subject is the first line of the

    commit message as a string without EOLs)."""

    cmd = [

        'log', '--abbrev', '--format=%h %s',

        ] + list(log_args) + ['--']

    for line in read_git_lines(cmd):

        yield tuple(line.split(' ', 1))

def limit_lines(lines, max_lines):

    for (index, line) in enumerate(lines):

        if index < max_lines:

            yield line

    if index >= max_lines:

        yield '... %d lines suppressed ...\n' % (index + 1 - max_lines,)

def limit_linelength(lines, max_linelength):

    for line in lines:

        # Don't forget that lines always include a trailing newline.

        if len(line) > max_linelength + 1:

            line = line[:max_linelength - 7] + ' [...]\n'

        yield line

class CommitSet(object):

    """A (constant) set of object names.

    The set should be initialized with full SHA1 object names.  The

    __contains__() method returns True iff its argument is an

    abbreviation of any the names in the set."""

    def __init__(self, names):

        self._names = sorted(names)

    def __len__(self):

        return len(self._names)

    def __contains__(self, sha1_abbrev):

        """Return True iff this set contains sha1_abbrev (which might

        be abbreviated)."""

        i = bisect.bisect_left(self._names, sha1_abbrev)

        return i < len(self) and self._names[i].startswith(sha1_abbrev)

class GitObject(object):

    def __init__(self, sha1, type=None):

        if sha1 == ZEROS:

            self.sha1 = self.type = self.commit_sha1 = None

        else:

            self.sha1 = sha1

            self.type = type or read_git_output(

                ['cat-file', '-t', self.sha1])

            if self.type == 'commit':

                self.commit_sha1 = self.sha1

            elif self.type == 'tag':

                try:

                    self.commit_sha1 = read_git_output(

                        ['rev-parse', '--verify', '%s^0' % (self.sha1,)]

                        )

                except CommandError:

                    # Cannot deref tag to determine commit_sha1

                    self.commit_sha1 = None

            else:

                self.commit_sha1 = None

        self.short = read_git_output(['rev-parse', '--short', sha1])

    def get_summary(self):

        """Return (sha1_short, subject) for this commit."""

        if not self.sha1:

            raise ValueError('Empty commit has no summary')

        return iter(generate_summaries('--no-walk', self.sha1)).next()

    def __eq__(self, other):

        return isinstance(other, GitObject) and self.sha1 == other.sha1

    def __hash__(self):

        return hash(self.sha1)

    def __nonzero__(self):

        return bool(self.sha1)

    def __str__(self):

        return self.sha1 or ZEROS

class Change(object):

    """A Change that has been made to the Git repository.

    Abstract class from which both Revisions and ReferenceChanges are

    derived.  A Change knows how to generate a notification email

    describing itself."""

    def __init__(self, environment):

        self.environment = environment

        self._values = None

    def _compute_values(self):

        """Return a dictionary {keyword : expansion} for this Change.

        Derived classes overload this method to add more entries to

        the return value.  This method is used internally by

        get_values().  The return value should always be a new

        dictionary."""

        return self.environment.get_values()

    def get_values(self, **extra_values):

        """Return a dictionary {keyword : expansion} for this Change.

        Return a dictionary mapping keywords to the values that they

        should be expanded to for this Change (used when interpolating

        template strings).  If any keyword arguments are supplied, add

        those to the return value as well.  The return value is always

        a new dictionary."""

        if self._values is None:

            self._values = self._compute_values()

        values = self._values.copy()

        if extra_values:

            values.update(extra_values)

        return values

    def expand(self, template, **extra_values):

        """Expand template.

        Expand the template (which should be a string) using string

        interpolation of the values for this Change.  If any keyword

        arguments are provided, also include those in the keywords

        available for interpolation."""

        return template % self.get_values(**extra_values)

    def expand_lines(self, template, **extra_values):

        """Break template into lines and expand each line."""

        values = self.get_values(**extra_values)

        for line in template.splitlines(True):

            yield line % values

    def expand_header_lines(self, template, **extra_values):

        """Break template into lines and expand each line as an RFC 2822

        header.

        Encode values and split up lines that are too long.  Silently

        skip lines that contain references to unknown variables."""

        values = self.get_values(**extra_values)

        for line in template.splitlines():

            (name, value) = line.split(':', 1)

            try:

                value = value % values

            except KeyError, e:

                if DEBUG:

                    sys.stderr.write(

                        'Warning: unknown variable %r in the following '

                        'line; line skipped:\n'

                        '    %s\n'

                        % (e.args[0], line,)

                        )

            else:

                if name.lower() in ADDR_HEADERS:

                    value = addr_header_encode(value, name)

                else:

                    value = header_encode(value, name)

                for splitline in (

                        '%s: %s\n' % (name, value)).splitlines(True):

                    yield splitline

    def generate_email_header(self):

        """Generate the RFC 2822 email headers for this Change, a line at a

        time.

        The output should not include the trailing blank line."""

        raise NotImplementedError()

    def generate_email_intro(self):

        """Generate the email intro for this Change, a line at a time.

        The output will be used as the standard boilerplate at the top

        of the email body."""

        raise NotImplementedError()

    def generate_email_body(self):

        """Generate the main part of the email body, a line at a time.

        The text in the body might be truncated after a specified

        number of lines (see multimailhook.emailmaxlines)."""

        raise NotImplementedError()

    def generate_email_footer(self):

        """Generate the footer of the email, a line at a time.

        The footer is always included, irrespective of

        multimailhook.emailmaxlines."""

        raise NotImplementedError()

    def generate_email(self, push, body_filter=None, extra_header_values={}):

        """Generate an email describing this change.

        Iterate over the lines (including the header lines) of an

        email describing this change.  If body_filter is not None,

        then use it to filter the lines that are intended for the

        email body.

        The extra_header_values field is received as a dict and not as

        **kwargs, to allow passing other keyword arguments in the

        future (e.g. passing extra values to generate_email_intro()"""

        for line in self.generate_email_header(**extra_header_values):

            yield line

        yield '\n'

        for line in self.generate_email_intro():

            yield line

        body = self.generate_email_body(push)

        if body_filter is not None:

            body = body_filter(body)

        for line in body:

            yield line

        for line in self.generate_email_footer():

            yield line

class Revision(Change):

    """A Change consisting of a single git commit."""

    def __init__(self, reference_change, rev, num, tot):

        Change.__init__(self, reference_change.environment)

        self.reference_change = reference_change

        self.rev = rev

        self.change_type = self.reference_change.change_type

        self.refname = self.reference_change.refname

        self.num = num

        self.tot = tot

        self.author = read_git_output(

            ['log', '--no-walk', '--format=%aN <%aE>', self.rev.sha1])

        self.recipients = self.environment.get_revision_recipients(self)

    def _compute_values(self):

        values = Change._compute_values(self)

        oneline = read_git_output(

            ['log', '--format=%s', '--no-walk', self.rev.sha1]

            )

        values['rev'] = self.rev.sha1

        values['rev_short'] = self.rev.short

        values['change_type'] = self.change_type

        values['refname'] = self.refname

        values['short_refname'] = self.reference_change.short_refname

        values['refname_type'] = self.reference_change.refname_type

        values['reply_to_msgid'] = self.reference_change.msgid

        values['num'] = self.num

        values['tot'] = self.tot

        values['recipients'] = self.recipients

        values['oneline'] = oneline

        values['author'] = self.author

        reply_to = self.environment.get_reply_to_commit(self)

        if reply_to:

            values['reply_to'] = reply_to

        return values

    def generate_email_header(self, **extra_values):

        for line in self.expand_header_lines(

                REVISION_HEADER_TEMPLATE, **extra_values):

            yield line

    def generate_email_intro(self):

        for line in self.expand_lines(REVISION_INTRO_TEMPLATE):

            yield line

    def generate_email_body(self, push):

        """Show this revision."""

        return read_git_lines(

            ['log'] + self.environment.commitlogopts + ['-1', self.rev.sha1],

            keepends=True,

            )

    def generate_email_footer(self):

        return self.expand_lines(REVISION_FOOTER_TEMPLATE)

class ReferenceChange(Change):

    """A Change to a Git reference.

    An abstract class representing a create, update, or delete of a

    Git reference.  Derived classes handle specific types of reference

    (e.g., tags vs. branches).  These classes generate the main

    reference change email summarizing the reference change and

    whether it caused any any commits to be added or removed.

    ReferenceChange objects are usually created using the static

    create() method, which has the logic to decide which derived class

    to instantiate."""

    REF_RE = re.compile(r'^refs\/(?P<area>[^\/]+)\/(?P<shortname>.*)$')</shortname>

    @staticmethod

    def create(environment, oldrev, newrev, refname):

        """Return a ReferenceChange object representing the change.

        Return an object that represents the type of change that is being

        made. oldrev and newrev should be SHA1s or ZEROS."""

        old = GitObject(oldrev)

        new = GitObject(newrev)

        rev = new or old

        # 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

        #  - unannotated tag

        #  - annotated tag

        m = ReferenceChange.REF_RE.match(refname)

        if m:

            area = m.group('area')

            short_refname = m.group('shortname')

        else:

            area = ''

            short_refname = refname

        if rev.type == 'tag':

            # Annotated tag:

            klass = AnnotatedTagChange

        elif rev.type == 'commit':

            if area == 'tags':

                # Non-annotated tag:

                klass = NonAnnotatedTagChange

            elif area == 'heads':

                # Branch:

                klass = BranchChange

            elif area == 'remotes':

                # Tracking branch:

                sys.stderr.write(

                    '*** Push-update of tracking branch %r\n'

                    '***  - incomplete email generated.\n' % (refname,)

                    )

                klass = OtherReferenceChange

            else:

                # Some other reference namespace:

                sys.stderr.write(

                    '*** Push-update of strange reference %r\n'

                    '***  - incomplete email generated.\n' % (refname,)

                    )

                klass = OtherReferenceChange

        else:

            # Anything else (is there anything else?)

            sys.stderr.write(

                '*** Unknown type of update to %r (%s)\n'

                '***  - incomplete email generated.\n' % (refname, rev.type,)

                )

            klass = OtherReferenceChange

        return klass(

            environment,

            refname=refname, short_refname=short_refname,

            old=old, new=new, rev=rev,

            )

    def __init__(self, environment, refname, short_refname, old, new, rev):

        Change.__init__(self, environment)

        self.change_type = {

            (False, True): 'create',

            (True, True): 'update',

            (True, False): 'delete',

            }[bool(old), bool(new)]

        self.refname = refname

        self.short_refname = short_refname

        self.old = old

        self.new = new

        self.rev = rev

        self.msgid = make_msgid()

        self.diffopts = environment.diffopts

        self.logopts = environment.logopts

        self.commitlogopts = environment.commitlogopts