← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/mail_client.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mail_client.py
1
 
# Copyright (C) 2007 Canonical Ltd
 
1
# Copyright (C) 2007-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
89
89
 
90
90
 
91
91
class Editor(MailClient):
92
 
    """DIY mail client that uses commit message editor"""
 
92
    __doc__ = """DIY mail client that uses commit message editor"""
93
93
 
94
94
    supports_body = True
95
95
 
155
155
                      extension, **kwargs)
156
156
 
157
157
    def _compose(self, prompt, to, subject, attach_path, mime_subtype,
158
 
                extension, body=None):
 
158
                 extension, body=None, from_=None):
159
159
        """Invoke a mail client as a commandline process.
160
160
 
161
161
        Overridden by MAPIClient.
166
166
            "text", but the precise subtype can be specified here
167
167
        :param extension: A file extension (including period) associated with
168
168
            the attachment type.
 
169
        :param body: Optional body text.
 
170
        :param from_: Optional From: header.
169
171
        """
170
172
        for name in self._get_client_commands():
171
173
            cmdline = [self._encode_path(name, 'executable')]
173
175
                kwargs = {'body': body}
174
176
            else:
175
177
                kwargs = {}
 
178
            if from_ is not None:
 
179
                kwargs['from_'] = from_
176
180
            cmdline.extend(self._get_compose_commandline(to, subject,
177
181
                                                         attach_path,
178
182
                                                         **kwargs))
226
230
 
227
231
 
228
232
class ExternalMailClient(BodyExternalMailClient):
229
 
    """An external mail client."""
 
233
    __doc__ = """An external mail client."""
230
234
 
231
235
    supports_body = False
232
236
 
233
237
 
234
238
class Evolution(BodyExternalMailClient):
235
 
    """Evolution mail client."""
 
239
    __doc__ = """Evolution mail client."""
236
240
 
237
241
    _client_commands = ['evolution']
238
242
 
253
257
                              help=Evolution.__doc__)
254
258
 
255
259
 
256
 
class Mutt(ExternalMailClient):
257
 
    """Mutt mail client."""
 
260
class Mutt(BodyExternalMailClient):
 
261
    __doc__ = """Mutt mail client."""
258
262
 
259
263
    _client_commands = ['mutt']
260
264
 
261
 
    def _get_compose_commandline(self, to, subject, attach_path):
 
265
    def _get_compose_commandline(self, to, subject, attach_path, body=None):
262
266
        """See ExternalMailClient._get_compose_commandline"""
263
267
        message_options = []
264
268
        if subject is not None:
266
270
        if attach_path is not None:
267
271
            message_options.extend(['-a',
268
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])
269
281
        if to is not None:
270
 
            message_options.append(self._encode_safe(to))
 
282
            message_options.extend(['--', self._encode_safe(to)])
271
283
        return message_options
272
284
mail_client_registry.register('mutt', Mutt,
273
285
                              help=Mutt.__doc__)
274
286
 
275
287
 
276
288
class Thunderbird(BodyExternalMailClient):
277
 
    """Mozilla Thunderbird (or Icedove)
 
289
    __doc__ = """Mozilla Thunderbird (or Icedove)
278
290
 
279
291
    Note that Thunderbird 1.5 is buggy and does not support setting
280
292
    "to" simultaneously with including a attachment.
309
321
 
310
322
 
311
323
class KMail(ExternalMailClient):
312
 
    """KDE mail client."""
 
324
    __doc__ = """KDE mail client."""
313
325
 
314
326
    _client_commands = ['kmail']
315
327
 
329
341
 
330
342
 
331
343
class Claws(ExternalMailClient):
332
 
    """Claws mail client."""
 
344
    __doc__ = """Claws mail client."""
 
345
 
 
346
    supports_body = True
333
347
 
334
348
    _client_commands = ['claws-mail']
335
349
 
336
 
    def _get_compose_commandline(self, to, subject, attach_path):
 
350
    def _get_compose_commandline(self, to, subject, attach_path, body=None,
 
351
                                 from_=None):
337
352
        """See ExternalMailClient._get_compose_commandline"""
338
 
        compose_url = ['mailto:']
339
 
        if to is not None:
340
 
            compose_url.append(self._encode_safe(to))
341
 
        compose_url.append('?')
 
353
        compose_url = []
 
354
        if from_ is not None:
 
355
            compose_url.append('from=' + urllib.quote(from_))
342
356
        if subject is not None:
343
357
            # Don't use urllib.quote_plus because Claws doesn't seem
344
358
            # to recognise spaces encoded as "+".
345
359
            compose_url.append(
346
 
                'subject=%s' % urllib.quote(self._encode_safe(subject)))
 
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))
347
369
        # Collect command-line options.
348
 
        message_options = ['--compose', ''.join(compose_url)]
 
370
        message_options = ['--compose', compose_url]
349
371
        if attach_path is not None:
350
372
            message_options.extend(
351
373
                ['--attach', self._encode_path(attach_path, 'attachment')])
352
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
 
353
385
mail_client_registry.register('claws', Claws,
354
386
                              help=Claws.__doc__)
355
387
 
356
388
 
357
389
class XDGEmail(BodyExternalMailClient):
358
 
    """xdg-email attempts to invoke the user's preferred mail client"""
 
390
    __doc__ = """xdg-email attempts to invoke the user's preferred mail client"""
359
391
 
360
392
    _client_commands = ['xdg-email']
361
393
 
377
409
 
378
410
 
379
411
class EmacsMail(ExternalMailClient):
380
 
    """Call emacsclient to have a mail buffer.
 
412
    __doc__ = """Call emacsclient to have a mail buffer.
381
413
 
382
414
    This only work for emacs >= 22.1 due to recent -e/--eval support.
383
415
 
392
424
 
393
425
    _client_commands = ['emacsclient']
394
426
 
 
427
    def __init__(self, config):
 
428
        super(EmacsMail, self).__init__(config)
 
429
        self.elisp_tmp_file = None
 
430
 
395
431
    def _prepare_send_function(self):
396
432
        """Write our wrapper function into a temporary file.
397
433
 
468
504
        if attach_path is not None:
469
505
            # Do not create a file if there is no attachment
470
506
            elisp = self._prepare_send_function()
 
507
            self.elisp_tmp_file = elisp
471
508
            lmmform = '(load "%s")' % elisp
472
509
            mmform  = '(bzr-add-mime-att "%s")' % \
473
510
                self._encode_path(attach_path, 'attachment')
482
519
 
483
520
 
484
521
class MAPIClient(BodyExternalMailClient):
485
 
    """Default Windows mail client launched using MAPI."""
 
522
    __doc__ = """Default Windows mail client launched using MAPI."""
486
523
 
487
524
    def _compose(self, prompt, to, subject, attach_path, mime_subtype,
488
 
                 extension, body):
 
525
                 extension, body=None):
489
526
        """See ExternalMailClient._compose.
490
527
 
491
528
        This implementation uses MAPI via the simplemapi ctypes wrapper
502
539
                              help=MAPIClient.__doc__)
503
540
 
504
541
 
 
542
class MailApp(BodyExternalMailClient):
 
543
    __doc__ = """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__)
 
599
 
 
600
 
505
601
class DefaultMail(MailClient):
506
 
    """Default mail handling.  Tries XDGEmail (or MAPIClient on Windows),
 
602
    __doc__ = """Default mail handling.  Tries XDGEmail (or MAPIClient on Windows),
507
603
    falls back to Editor"""
508
604
 
 
605
    supports_body = True
 
606
 
509
607
    def _mail_client(self):
510
608
        """Determine the preferred mail client for this platform"""
511
609
        if osutils.supports_mapi():
536
634
mail_client_registry.register('default', DefaultMail,
537
635
                              help=DefaultMail.__doc__)
538
636
mail_client_registry.default_key = 'default'
 
637
 
 
638