← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mail_client.py

  • Committer: John Arbash Meinel
  • Date: 2010-02-17 17:11:16 UTC
  • mfrom: (4797.2.17 2.1)
  • mto: (4797.2.18 2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: john@arbash-meinel.com-20100217171116-h7t9223ystbnx5h8
merge bzr.2.1 in preparation for NEWS entry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mail_client.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import errno
18
18
import os
19
19
import subprocess
20
20
import sys
21
21
import tempfile
 
22
import urllib
22
23
 
 
24
import bzrlib
23
25
from bzrlib import (
24
26
    email_message,
25
27
    errors,
26
28
    msgeditor,
27
29
    osutils,
28
30
    urlutils,
 
31
    registry
29
32
    )
30
33
 
 
34
mail_client_registry = registry.Registry()
 
35
 
31
36
 
32
37
class MailClient(object):
33
38
    """A mail client that can send messages with attachements."""
36
41
        self.config = config
37
42
 
38
43
    def compose(self, prompt, to, subject, attachment, mime_subtype,
39
 
                extension):
 
44
                extension, basename=None, body=None):
40
45
        """Compose (and possibly send) an email message
41
46
 
42
47
        Must be implemented by subclasses.
51
56
            "plain", "x-patch", etc.
52
57
        :param extension: The file extension associated with the attachment
53
58
            type, e.g. ".patch"
 
59
        :param basename: The name to use for the attachment, e.g.
 
60
            "send-nick-3252"
54
61
        """
55
62
        raise NotImplementedError
56
63
 
57
 
    def compose_merge_request(self, to, subject, directive):
 
64
    def compose_merge_request(self, to, subject, directive, basename=None,
 
65
                              body=None):
58
66
        """Compose (and possibly send) a merge request
59
67
 
60
68
        :param to: The address to send the request to
61
69
        :param subject: The subject line to use for the request
62
70
        :param directive: A merge directive representing the merge request, as
63
71
            a bytestring.
 
72
        :param basename: The name to use for the attachment, e.g.
 
73
            "send-nick-3252"
64
74
        """
65
75
        prompt = self._get_merge_prompt("Please describe these changes:", to,
66
76
                                        subject, directive)
67
77
        self.compose(prompt, to, subject, directive,
68
 
            'x-patch', '.patch')
 
78
            'x-patch', '.patch', basename, body)
69
79
 
70
80
    def _get_merge_prompt(self, prompt, to, subject, attachment):
71
81
        """Generate a prompt string.  Overridden by Editor.
81
91
class Editor(MailClient):
82
92
    """DIY mail client that uses commit message editor"""
83
93
 
 
94
    supports_body = True
 
95
 
84
96
    def _get_merge_prompt(self, prompt, to, subject, attachment):
85
97
        """See MailClient._get_merge_prompt"""
86
98
        return (u"%s\n\n"
90
102
                         attachment.decode('utf-8', 'replace')))
91
103
 
92
104
    def compose(self, prompt, to, subject, attachment, mime_subtype,
93
 
                extension):
 
105
                extension, basename=None, body=None):
94
106
        """See MailClient.compose"""
95
 
        body = msgeditor.edit_commit_message(prompt)
 
107
        if not to:
 
108
            raise errors.NoMailAddressSpecified()
 
109
        body = msgeditor.edit_commit_message(prompt, start_message=body)
96
110
        if body == '':
97
111
            raise errors.NoMessageSupplied()
98
112
        email_message.EmailMessage.send(self.config,
102
116
                                        body,
103
117
                                        attachment,
104
118
                                        attachment_mime_subtype=mime_subtype)
105
 
 
106
 
 
107
 
class ExternalMailClient(MailClient):
108
 
    """An external mail client."""
 
119
mail_client_registry.register('editor', Editor,
 
120
                              help=Editor.__doc__)
 
121
 
 
122
 
 
123
class BodyExternalMailClient(MailClient):
 
124
 
 
125
    supports_body = True
109
126
 
110
127
    def _get_client_commands(self):
111
128
        """Provide a list of commands that may invoke the mail client"""
116
133
            return self._client_commands
117
134
 
118
135
    def compose(self, prompt, to, subject, attachment, mime_subtype,
119
 
                extension):
 
136
                extension, basename=None, body=None):
120
137
        """See MailClient.compose.
121
138
 
122
139
        Writes the attachment to a temporary file, invokes _compose.
123
140
        """
124
 
        fd, pathname = tempfile.mkstemp(extension, 'bzr-mail-')
 
141
        if basename is None:
 
142
            basename = 'attachment'
 
143
        pathname = osutils.mkdtemp(prefix='bzr-mail-')
 
144
        attach_path = osutils.pathjoin(pathname, basename + extension)
 
145
        outfile = open(attach_path, 'wb')
125
146
        try:
126
 
            os.write(fd, attachment)
 
147
            outfile.write(attachment)
127
148
        finally:
128
 
            os.close(fd)
129
 
        self._compose(prompt, to, subject, pathname, mime_subtype, extension)
 
149
            outfile.close()
 
150
        if body is not None:
 
151
            kwargs = {'body': body}
 
152
        else:
 
153
            kwargs = {}
 
154
        self._compose(prompt, to, subject, attach_path, mime_subtype,
 
155
                      extension, **kwargs)
130
156
 
131
157
    def _compose(self, prompt, to, subject, attach_path, mime_subtype,
132
 
                extension):
 
158
                 extension, body=None, from_=None):
133
159
        """Invoke a mail client as a commandline process.
134
160
 
135
161
        Overridden by MAPIClient.
140
166
            "text", but the precise subtype can be specified here
141
167
        :param extension: A file extension (including period) associated with
142
168
            the attachment type.
 
169
        :param body: Optional body text.
 
170
        :param from_: Optional From: header.
143
171
        """
144
172
        for name in self._get_client_commands():
145
 
            cmdline = [name]
 
173
            cmdline = [self._encode_path(name, 'executable')]
 
174
            if body is not None:
 
175
                kwargs = {'body': body}
 
176
            else:
 
177
                kwargs = {}
 
178
            if from_ is not None:
 
179
                kwargs['from_'] = from_
146
180
            cmdline.extend(self._get_compose_commandline(to, subject,
147
 
                                                         attach_path))
 
181
                                                         attach_path,
 
182
                                                         **kwargs))
148
183
            try:
149
184
                subprocess.call(cmdline)
150
185
            except OSError, e:
155
190
        else:
156
191
            raise errors.MailClientNotFound(self._client_commands)
157
192
 
158
 
    def _get_compose_commandline(self, to, subject, attach_path):
 
193
    def _get_compose_commandline(self, to, subject, attach_path, body):
159
194
        """Determine the commandline to use for composing a message
160
195
 
161
196
        Implemented by various subclasses
165
200
        """
166
201
        raise NotImplementedError
167
202
 
168
 
 
169
 
class Evolution(ExternalMailClient):
 
203
    def _encode_safe(self, u):
 
204
        """Encode possible unicode string argument to 8-bit string
 
205
        in user_encoding. Unencodable characters will be replaced
 
206
        with '?'.
 
207
 
 
208
        :param  u:  possible unicode string.
 
209
        :return:    encoded string if u is unicode, u itself otherwise.
 
210
        """
 
211
        if isinstance(u, unicode):
 
212
            return u.encode(osutils.get_user_encoding(), 'replace')
 
213
        return u
 
214
 
 
215
    def _encode_path(self, path, kind):
 
216
        """Encode unicode path in user encoding.
 
217
 
 
218
        :param  path:   possible unicode path.
 
219
        :param  kind:   path kind ('executable' or 'attachment').
 
220
        :return:        encoded path if path is unicode,
 
221
                        path itself otherwise.
 
222
        :raise:         UnableEncodePath.
 
223
        """
 
224
        if isinstance(path, unicode):
 
225
            try:
 
226
                return path.encode(osutils.get_user_encoding())
 
227
            except UnicodeEncodeError:
 
228
                raise errors.UnableEncodePath(path, kind)
 
229
        return path
 
230
 
 
231
 
 
232
class ExternalMailClient(BodyExternalMailClient):
 
233
    """An external mail client."""
 
234
 
 
235
    supports_body = False
 
236
 
 
237
 
 
238
class Evolution(BodyExternalMailClient):
170
239
    """Evolution mail client."""
171
240
 
172
241
    _client_commands = ['evolution']
173
242
 
174
 
    def _get_compose_commandline(self, to, subject, attach_path):
 
243
    def _get_compose_commandline(self, to, subject, attach_path, body=None):
175
244
        """See ExternalMailClient._get_compose_commandline"""
176
245
        message_options = {}
177
246
        if subject is not None:
178
247
            message_options['subject'] = subject
179
248
        if attach_path is not None:
180
249
            message_options['attach'] = attach_path
 
250
        if body is not None:
 
251
            message_options['body'] = body
181
252
        options_list = ['%s=%s' % (k, urlutils.escape(v)) for (k, v) in
182
 
                        message_options.iteritems()]
183
 
        return ['mailto:%s?%s' % (to or '', '&'.join(options_list))]
184
 
 
185
 
 
186
 
class Thunderbird(ExternalMailClient):
 
253
                        sorted(message_options.iteritems())]
 
254
        return ['mailto:%s?%s' % (self._encode_safe(to or ''),
 
255
            '&'.join(options_list))]
 
256
mail_client_registry.register('evolution', Evolution,
 
257
                              help=Evolution.__doc__)
 
258
 
 
259
 
 
260
class Mutt(BodyExternalMailClient):
 
261
    """Mutt mail client."""
 
262
 
 
263
    _client_commands = ['mutt']
 
264
 
 
265
    def _get_compose_commandline(self, to, subject, attach_path, body=None):
 
266
        """See ExternalMailClient._get_compose_commandline"""
 
267
        message_options = []
 
268
        if subject is not None:
 
269
            message_options.extend(['-s', self._encode_safe(subject)])
 
270
        if attach_path is not None:
 
271
            message_options.extend(['-a',
 
272
                self._encode_path(attach_path, 'attachment')])
 
273
        if body is not None:
 
274
            # Store the temp file object in self, so that it does not get
 
275
            # garbage collected and delete the file before mutt can read it.
 
276
            self._temp_file = tempfile.NamedTemporaryFile(
 
277
                prefix="mutt-body-", suffix=".txt")
 
278
            self._temp_file.write(body)
 
279
            self._temp_file.flush()
 
280
            message_options.extend(['-i', self._temp_file.name])
 
281
        if to is not None:
 
282
            message_options.extend(['--', self._encode_safe(to)])
 
283
        return message_options
 
284
mail_client_registry.register('mutt', Mutt,
 
285
                              help=Mutt.__doc__)
 
286
 
 
287
 
 
288
class Thunderbird(BodyExternalMailClient):
187
289
    """Mozilla Thunderbird (or Icedove)
188
290
 
189
291
    Note that Thunderbird 1.5 is buggy and does not support setting
194
296
    """
195
297
 
196
298
    _client_commands = ['thunderbird', 'mozilla-thunderbird', 'icedove',
197
 
        '/Applications/Mozilla/Thunderbird.app/Contents/MacOS/thunderbird-bin']
 
299
        '/Applications/Mozilla/Thunderbird.app/Contents/MacOS/thunderbird-bin',
 
300
        '/Applications/Thunderbird.app/Contents/MacOS/thunderbird-bin']
198
301
 
199
 
    def _get_compose_commandline(self, to, subject, attach_path):
 
302
    def _get_compose_commandline(self, to, subject, attach_path, body=None):
200
303
        """See ExternalMailClient._get_compose_commandline"""
201
304
        message_options = {}
202
305
        if to is not None:
203
 
            message_options['to'] = to
 
306
            message_options['to'] = self._encode_safe(to)
204
307
        if subject is not None:
205
 
            message_options['subject'] = subject
 
308
            message_options['subject'] = self._encode_safe(subject)
206
309
        if attach_path is not None:
207
310
            message_options['attachment'] = urlutils.local_path_to_url(
208
311
                attach_path)
209
 
        options_list = ["%s='%s'" % (k, v) for k, v in
210
 
                        sorted(message_options.iteritems())]
 
312
        if body is not None:
 
313
            options_list = ['body=%s' % urllib.quote(self._encode_safe(body))]
 
314
        else:
 
315
            options_list = []
 
316
        options_list.extend(["%s='%s'" % (k, v) for k, v in
 
317
                        sorted(message_options.iteritems())])
211
318
        return ['-compose', ','.join(options_list)]
 
319
mail_client_registry.register('thunderbird', Thunderbird,
 
320
                              help=Thunderbird.__doc__)
212
321
 
213
322
 
214
323
class KMail(ExternalMailClient):
220
329
        """See ExternalMailClient._get_compose_commandline"""
221
330
        message_options = []
222
331
        if subject is not None:
223
 
            message_options.extend( ['-s', subject ] )
 
332
            message_options.extend(['-s', self._encode_safe(subject)])
224
333
        if attach_path is not None:
225
 
            message_options.extend( ['--attach', attach_path] )
 
334
            message_options.extend(['--attach',
 
335
                self._encode_path(attach_path, 'attachment')])
226
336
        if to is not None:
227
 
            message_options.extend( [ to ] )
228
 
 
229
 
        return message_options
230
 
 
231
 
 
232
 
class XDGEmail(ExternalMailClient):
 
337
            message_options.extend([self._encode_safe(to)])
 
338
        return message_options
 
339
mail_client_registry.register('kmail', KMail,
 
340
                              help=KMail.__doc__)
 
341
 
 
342
 
 
343
class Claws(ExternalMailClient):
 
344
    """Claws mail client."""
 
345
 
 
346
    supports_body = True
 
347
 
 
348
    _client_commands = ['claws-mail']
 
349
 
 
350
    def _get_compose_commandline(self, to, subject, attach_path, body=None,
 
351
                                 from_=None):
 
352
        """See ExternalMailClient._get_compose_commandline"""
 
353
        compose_url = []
 
354
        if from_ is not None:
 
355
            compose_url.append('from=' + urllib.quote(from_))
 
356
        if subject is not None:
 
357
            # Don't use urllib.quote_plus because Claws doesn't seem
 
358
            # to recognise spaces encoded as "+".
 
359
            compose_url.append(
 
360
                'subject=' + urllib.quote(self._encode_safe(subject)))
 
361
        if body is not None:
 
362
            compose_url.append(
 
363
                'body=' + urllib.quote(self._encode_safe(body)))
 
364
        # to must be supplied for the claws-mail --compose syntax to work.
 
365
        if to is None:
 
366
            raise errors.NoMailAddressSpecified()
 
367
        compose_url = 'mailto:%s?%s' % (
 
368
            self._encode_safe(to), '&'.join(compose_url))
 
369
        # Collect command-line options.
 
370
        message_options = ['--compose', compose_url]
 
371
        if attach_path is not None:
 
372
            message_options.extend(
 
373
                ['--attach', self._encode_path(attach_path, 'attachment')])
 
374
        return message_options
 
375
 
 
376
    def _compose(self, prompt, to, subject, attach_path, mime_subtype,
 
377
                 extension, body=None, from_=None):
 
378
        """See ExternalMailClient._compose"""
 
379
        if from_ is None:
 
380
            from_ = self.config.get_user_option('email')
 
381
        super(Claws, self)._compose(prompt, to, subject, attach_path,
 
382
                                    mime_subtype, extension, body, from_)
 
383
 
 
384
 
 
385
mail_client_registry.register('claws', Claws,
 
386
                              help=Claws.__doc__)
 
387
 
 
388
 
 
389
class XDGEmail(BodyExternalMailClient):
233
390
    """xdg-email attempts to invoke the user's preferred mail client"""
234
391
 
235
392
    _client_commands = ['xdg-email']
236
393
 
 
394
    def _get_compose_commandline(self, to, subject, attach_path, body=None):
 
395
        """See ExternalMailClient._get_compose_commandline"""
 
396
        if not to:
 
397
            raise errors.NoMailAddressSpecified()
 
398
        commandline = [self._encode_safe(to)]
 
399
        if subject is not None:
 
400
            commandline.extend(['--subject', self._encode_safe(subject)])
 
401
        if attach_path is not None:
 
402
            commandline.extend(['--attach',
 
403
                self._encode_path(attach_path, 'attachment')])
 
404
        if body is not None:
 
405
            commandline.extend(['--body', self._encode_safe(body)])
 
406
        return commandline
 
407
mail_client_registry.register('xdg-email', XDGEmail,
 
408
                              help=XDGEmail.__doc__)
 
409
 
 
410
 
 
411
class EmacsMail(ExternalMailClient):
 
412
    """Call emacsclient to have a mail buffer.
 
413
 
 
414
    This only work for emacs >= 22.1 due to recent -e/--eval support.
 
415
 
 
416
    The good news is that this implementation will work with all mail
 
417
    agents registered against ``mail-user-agent``. So there is no need
 
418
    to instantiate ExternalMailClient for each and every GNU Emacs
 
419
    MUA.
 
420
 
 
421
    Users just have to ensure that ``mail-user-agent`` is set according
 
422
    to their tastes.
 
423
    """
 
424
 
 
425
    _client_commands = ['emacsclient']
 
426
 
 
427
    def __init__(self, config):
 
428
        super(EmacsMail, self).__init__(config)
 
429
        self.elisp_tmp_file = None
 
430
 
 
431
    def _prepare_send_function(self):
 
432
        """Write our wrapper function into a temporary file.
 
433
 
 
434
        This temporary file will be loaded at runtime in
 
435
        _get_compose_commandline function.
 
436
 
 
437
        This function does not remove the file.  That's a wanted
 
438
        behaviour since _get_compose_commandline won't run the send
 
439
        mail function directly but return the eligible command line.
 
440
        Removing our temporary file here would prevent our sendmail
 
441
        function to work.  (The file is deleted by some elisp code
 
442
        after being read by Emacs.)
 
443
        """
 
444
 
 
445
        _defun = r"""(defun bzr-add-mime-att (file)
 
446
  "Attach FILE to a mail buffer as a MIME attachment."
 
447
  (let ((agent mail-user-agent))
 
448
    (if (and file (file-exists-p file))
 
449
        (cond
 
450
         ((eq agent 'sendmail-user-agent)
 
451
          (progn
 
452
            (mail-text)
 
453
            (newline)
 
454
            (if (functionp 'etach-attach)
 
455
              (etach-attach file)
 
456
              (mail-attach-file file))))
 
457
         ((or (eq agent 'message-user-agent)
 
458
              (eq agent 'gnus-user-agent)
 
459
              (eq agent 'mh-e-user-agent))
 
460
          (progn
 
461
            (mml-attach-file file "text/x-patch" "BZR merge" "inline")))
 
462
         ((eq agent 'mew-user-agent)
 
463
          (progn
 
464
            (mew-draft-prepare-attachments)
 
465
            (mew-attach-link file (file-name-nondirectory file))
 
466
            (let* ((nums (mew-syntax-nums))
 
467
                   (syntax (mew-syntax-get-entry mew-encode-syntax nums)))
 
468
              (mew-syntax-set-cd syntax "BZR merge")
 
469
              (mew-encode-syntax-print mew-encode-syntax))
 
470
            (mew-header-goto-body)))
 
471
         (t
 
472
          (message "Unhandled MUA, report it on bazaar@lists.canonical.com")))
 
473
      (error "File %s does not exist." file))))
 
474
"""
 
475
 
 
476
        fd, temp_file = tempfile.mkstemp(prefix="emacs-bzr-send-",
 
477
                                         suffix=".el")
 
478
        try:
 
479
            os.write(fd, _defun)
 
480
        finally:
 
481
            os.close(fd) # Just close the handle but do not remove the file.
 
482
        return temp_file
 
483
 
237
484
    def _get_compose_commandline(self, to, subject, attach_path):
238
 
        """See ExternalMailClient._get_compose_commandline"""
239
 
        commandline = [to]
 
485
        commandline = ["--eval"]
 
486
 
 
487
        _to = "nil"
 
488
        _subject = "nil"
 
489
 
 
490
        if to is not None:
 
491
            _to = ("\"%s\"" % self._encode_safe(to).replace('"', '\\"'))
240
492
        if subject is not None:
241
 
            commandline.extend(['--subject', subject])
 
493
            _subject = ("\"%s\"" %
 
494
                        self._encode_safe(subject).replace('"', '\\"'))
 
495
 
 
496
        # Funcall the default mail composition function
 
497
        # This will work with any mail mode including default mail-mode
 
498
        # User must tweak mail-user-agent variable to tell what function
 
499
        # will be called inside compose-mail.
 
500
        mail_cmd = "(compose-mail %s %s)" % (_to, _subject)
 
501
        commandline.append(mail_cmd)
 
502
 
 
503
        # Try to attach a MIME attachment using our wrapper function
242
504
        if attach_path is not None:
243
 
            commandline.extend(['--attach', attach_path])
 
505
            # Do not create a file if there is no attachment
 
506
            elisp = self._prepare_send_function()
 
507
            self.elisp_tmp_file = elisp
 
508
            lmmform = '(load "%s")' % elisp
 
509
            mmform  = '(bzr-add-mime-att "%s")' % \
 
510
                self._encode_path(attach_path, 'attachment')
 
511
            rmform = '(delete-file "%s")' % elisp
 
512
            commandline.append(lmmform)
 
513
            commandline.append(mmform)
 
514
            commandline.append(rmform)
 
515
 
244
516
        return commandline
245
 
 
246
 
 
247
 
class MAPIClient(ExternalMailClient):
 
517
mail_client_registry.register('emacsclient', EmacsMail,
 
518
                              help=EmacsMail.__doc__)
 
519
 
 
520
 
 
521
class MAPIClient(BodyExternalMailClient):
248
522
    """Default Windows mail client launched using MAPI."""
249
523
 
250
524
    def _compose(self, prompt, to, subject, attach_path, mime_subtype,
251
 
                 extension):
 
525
                 extension, body=None):
252
526
        """See ExternalMailClient._compose.
253
527
 
254
528
        This implementation uses MAPI via the simplemapi ctypes wrapper
255
529
        """
256
530
        from bzrlib.util import simplemapi
257
531
        try:
258
 
            simplemapi.SendMail(to or '', subject or '', '', attach_path)
 
532
            simplemapi.SendMail(to or '', subject or '', body or '',
 
533
                                attach_path)
259
534
        except simplemapi.MAPIError, e:
260
535
            if e.code != simplemapi.MAPI_USER_ABORT:
261
536
                raise errors.MailClientNotFound(['MAPI supported mail client'
262
537
                                                 ' (error %d)' % (e.code,)])
 
538
mail_client_registry.register('mapi', MAPIClient,
 
539
                              help=MAPIClient.__doc__)
 
540
 
 
541
 
 
542
class MailApp(BodyExternalMailClient):
 
543
    """Use MacOS X's Mail.app for sending email messages.
 
544
 
 
545
    Although it would be nice to use appscript, it's not installed
 
546
    with the shipped Python installations.  We instead build an
 
547
    AppleScript and invoke the script using osascript(1).  We don't
 
548
    use the _encode_safe() routines as it's not clear what encoding
 
549
    osascript expects the script to be in.
 
550
    """
 
551
 
 
552
    _client_commands = ['osascript']
 
553
 
 
554
    def _get_compose_commandline(self, to, subject, attach_path, body=None,
 
555
                                from_=None):
 
556
       """See ExternalMailClient._get_compose_commandline"""
 
557
 
 
558
       fd, self.temp_file = tempfile.mkstemp(prefix="bzr-send-",
 
559
                                         suffix=".scpt")
 
560
       try:
 
561
           os.write(fd, 'tell application "Mail"\n')
 
562
           os.write(fd, 'set newMessage to make new outgoing message\n')
 
563
           os.write(fd, 'tell newMessage\n')
 
564
           if to is not None:
 
565
               os.write(fd, 'make new to recipient with properties'
 
566
                   ' {address:"%s"}\n' % to)
 
567
           if from_ is not None:
 
568
               # though from_ doesn't actually seem to be used
 
569
               os.write(fd, 'set sender to "%s"\n'
 
570
                   % sender.replace('"', '\\"'))
 
571
           if subject is not None:
 
572
               os.write(fd, 'set subject to "%s"\n'
 
573
                   % subject.replace('"', '\\"'))
 
574
           if body is not None:
 
575
               # FIXME: would be nice to prepend the body to the
 
576
               # existing content (e.g., preserve signature), but
 
577
               # can't seem to figure out the right applescript
 
578
               # incantation.
 
579
               os.write(fd, 'set content to "%s\\n\n"\n' %
 
580
                   body.replace('"', '\\"').replace('\n', '\\n'))
 
581
 
 
582
           if attach_path is not None:
 
583
               # FIXME: would be nice to first append a newline to
 
584
               # ensure the attachment is on a new paragraph, but
 
585
               # can't seem to figure out the right applescript
 
586
               # incantation.
 
587
               os.write(fd, 'tell content to make new attachment'
 
588
                   ' with properties {file name:"%s"}'
 
589
                   ' at after the last paragraph\n'
 
590
                   % self._encode_path(attach_path, 'attachment'))
 
591
           os.write(fd, 'set visible to true\n')
 
592
           os.write(fd, 'end tell\n')
 
593
           os.write(fd, 'end tell\n')
 
594
       finally:
 
595
           os.close(fd) # Just close the handle but do not remove the file.
 
596
       return [self.temp_file]
 
597
mail_client_registry.register('mail.app', MailApp,
 
598
                              help=MailApp.__doc__)
263
599
 
264
600
 
265
601
class DefaultMail(MailClient):
266
602
    """Default mail handling.  Tries XDGEmail (or MAPIClient on Windows),
267
603
    falls back to Editor"""
268
604
 
 
605
    supports_body = True
 
606
 
269
607
    def _mail_client(self):
270
608
        """Determine the preferred mail client for this platform"""
271
609
        if osutils.supports_mapi():
274
612
            return XDGEmail(self.config)
275
613
 
276
614
    def compose(self, prompt, to, subject, attachment, mime_subtype,
277
 
                extension):
 
615
                extension, basename=None, body=None):
278
616
        """See MailClient.compose"""
279
617
        try:
280
618
            return self._mail_client().compose(prompt, to, subject,
281
619
                                               attachment, mimie_subtype,
282
 
                                               extension)
 
620
                                               extension, basename, body)
283
621
        except errors.MailClientNotFound:
284
622
            return Editor(self.config).compose(prompt, to, subject,
285
 
                          attachment, mimie_subtype, extension)
 
623
                          attachment, mimie_subtype, extension, body)
286
624
 
287
 
    def compose_merge_request(self, to, subject, directive):
 
625
    def compose_merge_request(self, to, subject, directive, basename=None,
 
626
                              body=None):
288
627
        """See MailClient.compose_merge_request"""
289
628
        try:
290
629
            return self._mail_client().compose_merge_request(to, subject,
291
 
                                                             directive)
 
630
                    directive, basename=basename, body=body)
292
631
        except errors.MailClientNotFound:
293
632
            return Editor(self.config).compose_merge_request(to, subject,
294
 
                          directive)
 
633
                          directive, basename=basename, body=body)
 
634
mail_client_registry.register('default', DefaultMail,
 
635
                              help=DefaultMail.__doc__)
 
636
mail_client_registry.default_key = 'default'
 
637
 
 
638