# patchbomb.py - sending Mercurial changesets as patch emails

#

#  Copyright 2005-2009 Matt Mackall <mpm@selenic.com> and others

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

'''command to send changesets as (a series of) patch emails

The series is started off with a "[PATCH 0 of N]" introduction, which

describes the series as a whole.

Each patch email has a Subject line of "[PATCH M of N] ...", using the

first line of the changeset description as the subject text. The

message contains two or three body parts:

- The changeset description.

- [Optional] The result of running diffstat on the patch.

- The patch itself, as generated by :hg:`export`.

Each message refers to the first in the series using the In-Reply-To

and References headers, so they will show up as a sequence in threaded

mail and news readers, and in mail archives.

To configure other defaults, add a section like this to your

configuration file::

  [email]

  from = My Name <my@email>

  to = recipient1, recipient2, ...

  cc = cc1, cc2, ...

  bcc = bcc1, bcc2, ...

  reply-to = address1, address2, ...

Use ``[patchbomb]`` as configuration section name if you need to

override global ``[email]`` address settings.

Then you can use the :hg:`email` command to mail a series of

changesets as a patchbomb.

You can also either configure the method option in the email section

to be a sendmail compatible mailer or fill out the [smtp] section so

that the patchbomb extension can automatically send patchbombs

directly from the commandline. See the [email] and [smtp] sections in

hgrc(5) for details.

By default, :hg:`email` will prompt for a ``To`` or ``CC`` header if

you do not supply one via configuration or the command line.  You can

override this to never prompt by configuring an empty value::

  [email]

  cc =

You can control the default inclusion of an introduction message with the

``patchbomb.intro`` configuration option. The configuration is always

overwritten by command line flags like --intro and --desc::

  [patchbomb]

  intro=auto   # include introduction message if more than 1 patch (default)

  intro=never  # never include an introduction message

  intro=always # always include an introduction message

You can specify a template for flags to be added in subject prefixes. Flags

specified by --flag option are exported as ``{flags}`` keyword::

  [patchbomb]

  flagtemplate = "{separate(' ',

                            ifeq(branch, 'default', '', branch|upper),

                            flags)}"

You can set patchbomb to always ask for confirmation by setting

``patchbomb.confirm`` to true.

'''

from __future__ import absolute_import

import email as emailmod

import email.generator as emailgen

import email.utils as eutil

import errno

import os

import socket

import tempfile

from mercurial.i18n import _

from mercurial import (

    cmdutil,

    commands,

    encoding,

    error,

    formatter,

    hg,

    mail,

    node as nodemod,

    patch,

    pycompat,

    registrar,

    repair,

    scmutil,

    templater,

    util,

)

stringio = util.stringio

cmdtable = {}

command = registrar.command(cmdtable)

configtable = {}

configitem = registrar.configitem(configtable)

configitem('patchbomb', 'bundletype',

    default=None,

)

configitem('patchbomb', 'bcc',

    default=None,

)

configitem('patchbomb', 'cc',

    default=None,

)

configitem('patchbomb', 'confirm',

    default=False,

)

configitem('patchbomb', 'flagtemplate',

    default=None,

)

configitem('patchbomb', 'from',

    default=None,

)

configitem('patchbomb', 'intro',

    default='auto',

)

configitem('patchbomb', 'publicurl',

    default=None,

)

configitem('patchbomb', 'reply-to',

    default=None,

)

configitem('patchbomb', 'to',

    default=None,

)

# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for

# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should

# be specifying the version(s) of Mercurial they are tested with, or

# leave the attribute unspecified.

testedwith = 'ships-with-hg-core'

def _addpullheader(seq, ctx):

    """Add a header pointing to a public URL where the changeset is available

    """

    repo = ctx.repo()

    # experimental config: patchbomb.publicurl

    # waiting for some logic that check that the changeset are available on the

    # destination before patchbombing anything.

    publicurl = repo.ui.config('patchbomb', 'publicurl')

    if publicurl:

        return ('Available At %s\n'

                '#              hg pull %s -r %s' % (publicurl, publicurl, ctx))

    return None

def uisetup(ui):

    cmdutil.extraexport.append('pullurl')

    cmdutil.extraexportmap['pullurl'] = _addpullheader

def reposetup(ui, repo):

    if not repo.local():

        return

    repo._wlockfreeprefix.add('last-email.txt')

def prompt(ui, prompt, default=None, rest=':'):

    if default:

        prompt += ' [%s]' % default

    return ui.prompt(prompt + rest, default)

def introwanted(ui, opts, number):

    '''is an introductory message apparently wanted?'''

    introconfig = ui.config('patchbomb', 'intro')

    if opts.get('intro') or opts.get('desc'):

        intro = True

    elif introconfig == 'always':

        intro = True

    elif introconfig == 'never':

        intro = False

    elif introconfig == 'auto':

        intro = 1 < number

    else:

        ui.write_err(_('warning: invalid patchbomb.intro value "%s"\n')

                     % introconfig)

        ui.write_err(_('(should be one of always, never, auto)\n'))

        intro = 1 < number

    return intro

def _formatflags(ui, repo, rev, flags):

    """build flag string optionally by template"""

    tmpl = ui.config('patchbomb', 'flagtemplate')

    if not tmpl:

        return ' '.join(flags)

    out = util.stringio()

    opts = {'template': templater.unquotestring(tmpl)}

    with formatter.templateformatter(ui, out, 'patchbombflag', opts) as fm:

        fm.startitem()

        fm.context(ctx=repo[rev])

        fm.write('flags', '%s', fm.formatlist(flags, name='flag'))

    return out.getvalue()

def _formatprefix(ui, repo, rev, flags, idx, total, numbered):

    """build prefix to patch subject"""

    flag = _formatflags(ui, repo, rev, flags)

    if flag:

        flag = ' ' + flag

    if not numbered:

        return '[PATCH%s]' % flag

    else:

        tlen = len(str(total))

        return '[PATCH %0*d of %d%s]' % (tlen, idx, total, flag)

def makepatch(ui, repo, rev, patchlines, opts, _charsets, idx, total, numbered,

              patchname=None):

    desc = []

    node = None

    body = ''

    for line in patchlines:

        if line.startswith('#'):

            if line.startswith('# Node ID'):

                node = line.split()[-1]

            continue

        if line.startswith('diff -r') or line.startswith('diff --git'):

            break

        desc.append(line)

    if not patchname and not node:

        raise ValueError

    if opts.get('attach') and not opts.get('body'):

        body = ('\n'.join(desc[1:]).strip() or

                'Patch subject is complete summary.')

        body += '\n\n\n'

    if opts.get('plain'):

        while patchlines and patchlines[0].startswith('# '):

            patchlines.pop(0)

        if patchlines:

            patchlines.pop(0)

        while patchlines and not patchlines[0].strip():

            patchlines.pop(0)

    ds = patch.diffstat(patchlines)

    if opts.get('diffstat'):

        body += ds + '\n\n'

    addattachment = opts.get('attach') or opts.get('inline')

    if not addattachment or opts.get('body'):

        body += '\n'.join(patchlines)

    if addattachment:

        msg = emailmod.MIMEMultipart.MIMEMultipart()

        if body:

            msg.attach(mail.mimeencode(ui, body, _charsets, opts.get('test')))

        p = mail.mimetextpatch('\n'.join(patchlines), 'x-patch',

                               opts.get('test'))

        binnode = nodemod.bin(node)

        # if node is mq patch, it will have the patch file's name as a tag

        if not patchname:

            patchtags = [t for t in repo.nodetags(binnode)

                         if t.endswith('.patch') or t.endswith('.diff')]

            if patchtags:

                patchname = patchtags[0]

            elif total > 1:

                patchname = cmdutil.makefilename(repo[node], '%b-%n.patch',

                                                 seqno=idx, total=total)

            else:

                patchname = cmdutil.makefilename(repo[node], '%b.patch')

        disposition = 'inline'

        if opts.get('attach'):

            disposition = 'attachment'

        p['Content-Disposition'] = disposition + '; filename=' + patchname

        msg.attach(p)

    else:

        msg = mail.mimetextpatch(body, display=opts.get('test'))

    prefix = _formatprefix(ui, repo, rev, opts.get('flag'), idx, total,

                           numbered)

    subj = desc[0].strip().rstrip('. ')

    if not numbered:

        subj = ' '.join([prefix, opts.get('subject') or subj])

    else:

        subj = ' '.join([prefix, subj])

    msg['Subject'] = mail.headencode(ui, subj, _charsets, opts.get('test'))

    msg['X-Mercurial-Node'] = node

    msg['X-Mercurial-Series-Index'] = '%i' % idx

    msg['X-Mercurial-Series-Total'] = '%i' % total

    return msg, subj, ds

def _getpatches(repo, revs, **opts):

    """return a list of patches for a list of revisions

    Each patch in the list is itself a list of lines.

    """

    ui = repo.ui

    prev = repo['.'].rev()

    for r in revs:

        if r == prev and (repo[None].files() or repo[None].deleted()):

            ui.warn(_('warning: working directory has '

                      'uncommitted changes\n'))

        output = stringio()

        cmdutil.export(repo, [r], fp=output,

                     opts=patch.difffeatureopts(ui, opts, git=True))

        yield output.getvalue().split('\n')

def _getbundle(repo, dest, **opts):

    """return a bundle containing changesets missing in "dest"

    The `opts` keyword-arguments are the same as the one accepted by the

    `bundle` command.

    The bundle is a returned as a single in-memory binary blob.

    """

    ui = repo.ui

    tmpdir = tempfile.mkdtemp(prefix='hg-email-bundle-')

    tmpfn = os.path.join(tmpdir, 'bundle')

    btype = ui.config('patchbomb', 'bundletype')

    if btype:

        opts[r'type'] = btype

    try:

        commands.bundle(ui, repo, tmpfn, dest, **opts)

        return util.readfile(tmpfn)

    finally:

        try:

            os.unlink(tmpfn)

        except OSError:

            pass

        os.rmdir(tmpdir)

def _getdescription(repo, defaultbody, sender, **opts):

    """obtain the body of the introduction message and return it

    This is also used for the body of email with an attached bundle.

    The body can be obtained either from the command line option or entered by

    the user through the editor.

    """

    ui = repo.ui

    if opts.get(r'desc'):

        body = open(opts.get(r'desc')).read()

    else:

        ui.write(_('\nWrite the introductory message for the '

                   'patch series.\n\n'))

        body = ui.edit(defaultbody, sender, repopath=repo.path,

                       action='patchbombbody')

        # Save series description in case sendmail fails

        msgfile = repo.vfs('last-email.txt', 'wb')

        msgfile.write(body)

        msgfile.close()

    return body

def _getbundlemsgs(repo, sender, bundle, **opts):

    """Get the full email for sending a given bundle

    This function returns a list of "email" tuples (subject, content, None).

    The list is always one message long in that case.

    """

    ui = repo.ui

    _charsets = mail._charsets(ui)

    subj = (opts.get(r'subject')

            or prompt(ui, 'Subject:', 'A bundle for your repository'))

    body = _getdescription(repo, '', sender, **opts)

    msg = emailmod.MIMEMultipart.MIMEMultipart()

    if body:

        msg.attach(mail.mimeencode(ui, body, _charsets, opts.get(r'test')))

    datapart = emailmod.MIMEBase.MIMEBase('application', 'x-mercurial-bundle')

    datapart.set_payload(bundle)

    bundlename = '%s.hg' % opts.get(r'bundlename', 'bundle')

    datapart.add_header('Content-Disposition', 'attachment',

                        filename=bundlename)

    emailmod.Encoders.encode_base64(datapart)

    msg.attach(datapart)

    msg['Subject'] = mail.headencode(ui, subj, _charsets, opts.get(r'test'))