← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge_directive.py

  • Committer: Jelmer Vernooij
  • Date: 2010-12-20 11:57:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5577.
  • Revision ID: jelmer@samba.org-20101220115714-2ru3hfappjweeg7q
Don't use no-plugins.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge_directive.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
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
 
18
18
from StringIO import StringIO
23
23
    diff,
24
24
    errors,
25
25
    gpg,
 
26
    hooks,
26
27
    registry,
27
28
    revision as _mod_revision,
28
29
    rio,
29
30
    testament,
30
31
    timestamp,
 
32
    trace,
31
33
    )
32
34
from bzrlib.bundle import (
33
35
    serializer as bundle_serializer,
35
37
from bzrlib.email_message import EmailMessage
36
38
 
37
39
 
38
 
class _BaseMergeDirective(object):
 
40
class MergeRequestBodyParams(object):
 
41
    """Parameter object for the merge_request_body hook."""
 
42
 
 
43
    def __init__(self, body, orig_body, directive, to, basename, subject,
 
44
                 branch, tree=None):
 
45
        self.body = body
 
46
        self.orig_body = orig_body
 
47
        self.directive = directive
 
48
        self.branch = branch
 
49
        self.tree = tree
 
50
        self.to = to
 
51
        self.basename = basename
 
52
        self.subject = subject
 
53
 
 
54
 
 
55
class MergeDirectiveHooks(hooks.Hooks):
 
56
    """Hooks for MergeDirective classes."""
 
57
 
 
58
    def __init__(self):
 
59
        hooks.Hooks.__init__(self)
 
60
        self.create_hook(hooks.HookPoint('merge_request_body',
 
61
            "Called with a MergeRequestBodyParams when a body is needed for"
 
62
            " a merge request.  Callbacks must return a body.  If more"
 
63
            " than one callback is registered, the output of one callback is"
 
64
            " provided to the next.", (1, 15, 0), False))
 
65
 
 
66
 
 
67
class BaseMergeDirective(object):
 
68
    """A request to perform a merge into a branch.
 
69
 
 
70
    This is the base class that all merge directive implementations 
 
71
    should derive from.
 
72
 
 
73
    :cvar multiple_output_files: Whether or not this merge directive 
 
74
        stores a set of revisions in more than one file
 
75
    """
 
76
 
 
77
    hooks = MergeDirectiveHooks()
 
78
 
 
79
    multiple_output_files = False
39
80
 
40
81
    def __init__(self, revision_id, testament_sha1, time, timezone,
41
82
                 target_branch, patch=None, source_branch=None, message=None,
61
102
        self.source_branch = source_branch
62
103
        self.message = message
63
104
 
 
105
    def to_lines(self):
 
106
        """Serialize as a list of lines
 
107
 
 
108
        :return: a list of lines
 
109
        """
 
110
        raise NotImplementedError(self.to_lines)
 
111
 
 
112
    def to_files(self):
 
113
        """Serialize as a set of files.
 
114
 
 
115
        :return: List of tuples with filename and contents as lines
 
116
        """
 
117
        raise NotImplementedError(self.to_files)
 
118
 
 
119
    def get_raw_bundle(self):
 
120
        """Return the bundle for this merge directive.
 
121
 
 
122
        :return: bundle text or None if there is no bundle
 
123
        """
 
124
        return None
 
125
 
64
126
    def _to_lines(self, base_revision=False):
65
127
        """Serialize as a list of lines
66
128
 
80
142
        lines.append('# \n')
81
143
        return lines
82
144
 
 
145
    def write_to_directory(self, path):
 
146
        """Write this merge directive to a series of files in a directory.
 
147
 
 
148
        :param path: Filesystem path to write to
 
149
        """
 
150
        raise NotImplementedError(self.write_to_directory)
 
151
 
83
152
    @classmethod
84
153
    def from_objects(klass, repository, revision_id, time, timezone,
85
154
                 target_branch, patch_type='bundle',
136
205
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
137
206
            patch, patch_type, public_branch, message)
138
207
 
 
208
    def get_disk_name(self, branch):
 
209
        """Generate a suitable basename for storing this directive on disk
 
210
 
 
211
        :param branch: The Branch this merge directive was generated fro
 
212
        :return: A string
 
213
        """
 
214
        revno, revision_id = branch.last_revision_info()
 
215
        if self.revision_id == revision_id:
 
216
            revno = [revno]
 
217
        else:
 
218
            revno = branch.get_revision_id_to_revno_map().get(self.revision_id,
 
219
                ['merge'])
 
220
        nick = re.sub('(\W+)', '-', branch.nick).strip('-')
 
221
        return '%s-%s' % (nick, '.'.join(str(n) for n in revno))
 
222
 
139
223
    @staticmethod
140
224
    def _generate_diff(repository, revision_id, ancestor_id):
141
225
        tree_1 = repository.revision_tree(ancestor_id)
190
274
                    StringIO(self.get_raw_bundle()))
191
275
                # We don't use the bundle's target revision, because
192
276
                # MergeDirective.revision_id is authoritative.
193
 
                info.install_revisions(target_repo, stream_input=False)
 
277
                try:
 
278
                    info.install_revisions(target_repo, stream_input=False)
 
279
                except errors.RevisionNotPresent:
 
280
                    # At least one dependency isn't present.  Try installing
 
281
                    # missing revisions from the submit branch
 
282
                    try:
 
283
                        submit_branch = \
 
284
                            _mod_branch.Branch.open(self.target_branch)
 
285
                    except errors.NotBranchError:
 
286
                        raise errors.TargetNotBranch(self.target_branch)
 
287
                    missing_revisions = []
 
288
                    bundle_revisions = set(r.revision_id for r in
 
289
                                           info.real_revisions)
 
290
                    for revision in info.real_revisions:
 
291
                        for parent_id in revision.parent_ids:
 
292
                            if (parent_id not in bundle_revisions and
 
293
                                not target_repo.has_revision(parent_id)):
 
294
                                missing_revisions.append(parent_id)
 
295
                    # reverse missing revisions to try to get heads first
 
296
                    unique_missing = []
 
297
                    unique_missing_set = set()
 
298
                    for revision in reversed(missing_revisions):
 
299
                        if revision in unique_missing_set:
 
300
                            continue
 
301
                        unique_missing.append(revision)
 
302
                        unique_missing_set.add(revision)
 
303
                    for missing_revision in unique_missing:
 
304
                        target_repo.fetch(submit_branch.repository,
 
305
                                          missing_revision)
 
306
                    info.install_revisions(target_repo, stream_input=False)
194
307
            else:
195
308
                source_branch = _mod_branch.Branch.open(self.source_branch)
196
309
                target_repo.fetch(source_branch.repository, self.revision_id)
197
310
        return self.revision_id
198
311
 
199
 
 
200
 
class MergeDirective(_BaseMergeDirective):
 
312
    def compose_merge_request(self, mail_client, to, body, branch, tree=None):
 
313
        """Compose a request to merge this directive.
 
314
 
 
315
        :param mail_client: The mail client to use for composing this request.
 
316
        :param to: The address to compose the request to.
 
317
        :param branch: The Branch that was used to produce this directive.
 
318
        :param tree: The Tree (if any) for the Branch used to produce this
 
319
            directive.
 
320
        """
 
321
        basename = self.get_disk_name(branch)
 
322
        subject = '[MERGE] '
 
323
        if self.message is not None:
 
324
            subject += self.message
 
325
        else:
 
326
            revision = branch.repository.get_revision(self.revision_id)
 
327
            subject += revision.get_summary()
 
328
        if getattr(mail_client, 'supports_body', False):
 
329
            orig_body = body
 
330
            for hook in self.hooks['merge_request_body']:
 
331
                params = MergeRequestBodyParams(body, orig_body, self,
 
332
                                                to, basename, subject, branch,
 
333
                                                tree)
 
334
                body = hook(params)
 
335
        elif len(self.hooks['merge_request_body']) > 0:
 
336
            trace.warning('Cannot run merge_request_body hooks because mail'
 
337
                          ' client %s does not support message bodies.',
 
338
                        mail_client.__class__.__name__)
 
339
        mail_client.compose_merge_request(to, subject,
 
340
                                          ''.join(self.to_lines()),
 
341
                                          basename, body)
 
342
 
 
343
 
 
344
class MergeDirective(BaseMergeDirective):
201
345
 
202
346
    """A request to perform a merge into a branch.
203
347
 
232
376
        :param source_branch: A public location to merge the revision from
233
377
        :param message: The message to use when committing this merge
234
378
        """
235
 
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
 
379
        BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
236
380
            timezone, target_branch, patch, source_branch, message)
237
 
        assert patch_type in (None, 'diff', 'bundle'), patch_type
 
381
        if patch_type not in (None, 'diff', 'bundle'):
 
382
            raise ValueError(patch_type)
238
383
        if patch_type != 'bundle' and source_branch is None:
239
384
            raise errors.NoMergeSource()
240
385
        if patch_type is not None and patch is None:
264
409
        :return: a MergeRequest
265
410
        """
266
411
        line_iter = iter(lines)
 
412
        firstline = ""
267
413
        for line in line_iter:
268
414
            if line.startswith('# Bazaar merge directive format '):
269
 
                break
270
 
        else:
271
 
            if len(lines) > 0:
272
 
                raise errors.NotAMergeDirective(lines[0])
273
 
            else:
274
 
                raise errors.NotAMergeDirective('')
275
 
        return _format_registry.get(line[2:].rstrip())._from_lines(line_iter)
 
415
                return _format_registry.get(line[2:].rstrip())._from_lines(
 
416
                    line_iter)
 
417
            firstline = firstline or line.strip()
 
418
        raise errors.NotAMergeDirective(firstline)
276
419
 
277
420
    @classmethod
278
421
    def _from_lines(klass, line_iter):
323
466
        return None, self.revision_id, 'inapplicable'
324
467
 
325
468
 
326
 
class MergeDirective2(_BaseMergeDirective):
 
469
class MergeDirective2(BaseMergeDirective):
327
470
 
328
471
    _format_string = 'Bazaar merge directive format 2 (Bazaar 0.90)'
329
472
 
332
475
                 bundle=None, base_revision_id=None):
333
476
        if source_branch is None and bundle is None:
334
477
            raise errors.NoMergeSource()
335
 
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
 
478
        BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
336
479
            timezone, target_branch, patch, source_branch, message)
337
480
        self.bundle = bundle
338
481
        self.base_revision_id = base_revision_id
475
618
                    revision_id):
476
619
                    raise errors.PublicBranchOutOfDate(public_branch,
477
620
                                                       revision_id)
 
621
            testament_sha1 = t.as_sha1()
478
622
        finally:
479
623
            for entry in reversed(locked):
480
624
                entry.unlock()
481
 
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
482
 
            patch, public_branch, message, bundle, base_revision_id)
 
625
        return klass(revision_id, testament_sha1, time, timezone,
 
626
            target_branch, patch, public_branch, message, bundle,
 
627
            base_revision_id)
483
628
 
484
629
    def _verify_patch(self, repository):
485
630
        calculated_patch = self._generate_diff(repository, self.revision_id,
521
666
_format_registry = MergeDirectiveFormatRegistry()
522
667
_format_registry.register(MergeDirective)
523
668
_format_registry.register(MergeDirective2)
 
669
# 0.19 never existed.  It got renamed to 0.90.  But by that point, there were
 
670
# already merge directives in the wild that used 0.19. Registering with the old
 
671
# format string to retain compatibility with those merge directives.
524
672
_format_registry.register(MergeDirective2,
525
673
                          'Bazaar merge directive format 2 (Bazaar 0.19)')