/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/merge_directive.py

  • Committer: John Arbash Meinel
  • Date: 2008-07-09 21:42:24 UTC
  • mto: This revision was merged to the branch mainline in revision 3543.
  • Revision ID: john@arbash-meinel.com-20080709214224-r75k87r6a01pfc3h
Restore a real weave merge to 'bzr merge --weave'.

To do so efficiently, we only add the simple LCAs to the final weave
object, unless we run into complexities with the merge graph.
This gives the same effective result as adding all the texts,
with the advantage of not having to extract all of them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge_directive.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
from StringIO import StringIO
23
23
    diff,
24
24
    errors,
25
25
    gpg,
26
 
    hooks,
27
26
    registry,
28
27
    revision as _mod_revision,
29
28
    rio,
30
29
    testament,
31
30
    timestamp,
32
 
    trace,
33
31
    )
34
32
from bzrlib.bundle import (
35
33
    serializer as bundle_serializer,
37
35
from bzrlib.email_message import EmailMessage
38
36
 
39
37
 
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
 
38
class _BaseMergeDirective(object):
80
39
 
81
40
    def __init__(self, revision_id, testament_sha1, time, timezone,
82
41
                 target_branch, patch=None, source_branch=None, message=None,
102
61
        self.source_branch = source_branch
103
62
        self.message = message
104
63
 
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
 
 
126
64
    def _to_lines(self, base_revision=False):
127
65
        """Serialize as a list of lines
128
66
 
142
80
        lines.append('# \n')
143
81
        return lines
144
82
 
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
 
 
152
83
    @classmethod
153
84
    def from_objects(klass, repository, revision_id, time, timezone,
154
85
                 target_branch, patch_type='bundle',
279
210
                except errors.RevisionNotPresent:
280
211
                    # At least one dependency isn't present.  Try installing
281
212
                    # 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)
 
213
                    submit_branch = _mod_branch.Branch.open(self.target_branch)
287
214
                    missing_revisions = []
288
215
                    bundle_revisions = set(r.revision_id for r in
289
216
                                           info.real_revisions)
309
236
                target_repo.fetch(source_branch.repository, self.revision_id)
310
237
        return self.revision_id
311
238
 
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):
 
239
 
 
240
class MergeDirective(_BaseMergeDirective):
345
241
 
346
242
    """A request to perform a merge into a branch.
347
243
 
376
272
        :param source_branch: A public location to merge the revision from
377
273
        :param message: The message to use when committing this merge
378
274
        """
379
 
        BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
 
275
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
380
276
            timezone, target_branch, patch, source_branch, message)
381
277
        if patch_type not in (None, 'diff', 'bundle'):
382
278
            raise ValueError(patch_type)
409
305
        :return: a MergeRequest
410
306
        """
411
307
        line_iter = iter(lines)
412
 
        firstline = ""
413
308
        for line in line_iter:
414
309
            if line.startswith('# Bazaar merge directive format '):
415
 
                return _format_registry.get(line[2:].rstrip())._from_lines(
416
 
                    line_iter)
417
 
            firstline = firstline or line.strip()
418
 
        raise errors.NotAMergeDirective(firstline)
 
310
                break
 
311
        else:
 
312
            if len(lines) > 0:
 
313
                raise errors.NotAMergeDirective(lines[0])
 
314
            else:
 
315
                raise errors.NotAMergeDirective('')
 
316
        return _format_registry.get(line[2:].rstrip())._from_lines(line_iter)
419
317
 
420
318
    @classmethod
421
319
    def _from_lines(klass, line_iter):
466
364
        return None, self.revision_id, 'inapplicable'
467
365
 
468
366
 
469
 
class MergeDirective2(BaseMergeDirective):
 
367
class MergeDirective2(_BaseMergeDirective):
470
368
 
471
369
    _format_string = 'Bazaar merge directive format 2 (Bazaar 0.90)'
472
370
 
475
373
                 bundle=None, base_revision_id=None):
476
374
        if source_branch is None and bundle is None:
477
375
            raise errors.NoMergeSource()
478
 
        BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
 
376
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
479
377
            timezone, target_branch, patch, source_branch, message)
480
378
        self.bundle = bundle
481
379
        self.base_revision_id = base_revision_id
618
516
                    revision_id):
619
517
                    raise errors.PublicBranchOutOfDate(public_branch,
620
518
                                                       revision_id)
621
 
            testament_sha1 = t.as_sha1()
622
519
        finally:
623
520
            for entry in reversed(locked):
624
521
                entry.unlock()
625
 
        return klass(revision_id, testament_sha1, time, timezone,
626
 
            target_branch, patch, public_branch, message, bundle,
627
 
            base_revision_id)
 
522
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
 
523
            patch, public_branch, message, bundle, base_revision_id)
628
524
 
629
525
    def _verify_patch(self, repository):
630
526
        calculated_patch = self._generate_diff(repository, self.revision_id,
666
562
_format_registry = MergeDirectiveFormatRegistry()
667
563
_format_registry.register(MergeDirective)
668
564
_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.
672
565
_format_registry.register(MergeDirective2,
673
566
                          'Bazaar merge directive format 2 (Bazaar 0.19)')