/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: James Westby
  • Date: 2007-09-18 18:55:00 UTC
  • mto: (2866.1.1 james.westby)
  • mto: This revision was merged to the branch mainline in revision 2867.
  • Revision ID: jw+debian@jameswestby.net-20070918185500-91alkjx8zolds1v8
Fix log against smart server branches that don't support tags. (#140615)

Add get_reverse_tag_dict to DisabledTags for branches that falsely
claim that they support tags (namely smart server branches). When the
remote branch was an old format without tags this caused log to fail.

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',
205
136
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
206
137
            patch, patch_type, public_branch, message)
207
138
 
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
 
 
223
139
    @staticmethod
224
140
    def _generate_diff(repository, revision_id, ancestor_id):
225
141
        tree_1 = repository.revision_tree(ancestor_id)
274
190
                    StringIO(self.get_raw_bundle()))
275
191
                # We don't use the bundle's target revision, because
276
192
                # MergeDirective.revision_id is authoritative.
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)
 
193
                info.install_revisions(target_repo, stream_input=False)
307
194
            else:
308
195
                source_branch = _mod_branch.Branch.open(self.source_branch)
309
196
                target_repo.fetch(source_branch.repository, self.revision_id)
310
197
        return self.revision_id
311
198
 
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):
 
199
 
 
200
class MergeDirective(_BaseMergeDirective):
345
201
 
346
202
    """A request to perform a merge into a branch.
347
203
 
376
232
        :param source_branch: A public location to merge the revision from
377
233
        :param message: The message to use when committing this merge
378
234
        """
379
 
        BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
 
235
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
380
236
            timezone, target_branch, patch, source_branch, message)
381
 
        if patch_type not in (None, 'diff', 'bundle'):
382
 
            raise ValueError(patch_type)
 
237
        assert patch_type in (None, 'diff', 'bundle'), patch_type
383
238
        if patch_type != 'bundle' and source_branch is None:
384
239
            raise errors.NoMergeSource()
385
240
        if patch_type is not None and patch is None:
409
264
        :return: a MergeRequest
410
265
        """
411
266
        line_iter = iter(lines)
412
 
        firstline = ""
413
267
        for line in line_iter:
414
268
            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)
 
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)
419
276
 
420
277
    @classmethod
421
278
    def _from_lines(klass, line_iter):
466
323
        return None, self.revision_id, 'inapplicable'
467
324
 
468
325
 
469
 
class MergeDirective2(BaseMergeDirective):
 
326
class MergeDirective2(_BaseMergeDirective):
470
327
 
471
328
    _format_string = 'Bazaar merge directive format 2 (Bazaar 0.90)'
472
329
 
475
332
                 bundle=None, base_revision_id=None):
476
333
        if source_branch is None and bundle is None:
477
334
            raise errors.NoMergeSource()
478
 
        BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
 
335
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
479
336
            timezone, target_branch, patch, source_branch, message)
480
337
        self.bundle = bundle
481
338
        self.base_revision_id = base_revision_id
618
475
                    revision_id):
619
476
                    raise errors.PublicBranchOutOfDate(public_branch,
620
477
                                                       revision_id)
621
 
            testament_sha1 = t.as_sha1()
622
478
        finally:
623
479
            for entry in reversed(locked):
624
480
                entry.unlock()
625
 
        return klass(revision_id, testament_sha1, time, timezone,
626
 
            target_branch, patch, public_branch, message, bundle,
627
 
            base_revision_id)
 
481
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
 
482
            patch, public_branch, message, bundle, base_revision_id)
628
483
 
629
484
    def _verify_patch(self, repository):
630
485
        calculated_patch = self._generate_diff(repository, self.revision_id,
666
521
_format_registry = MergeDirectiveFormatRegistry()
667
522
_format_registry.register(MergeDirective)
668
523
_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
524
_format_registry.register(MergeDirective2,
673
525
                          'Bazaar merge directive format 2 (Bazaar 0.19)')