← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge_directive.py

  • Committer: Martin Pool
  • Date: 2007-04-04 06:17:31 UTC
  • mto: This revision was merged to the branch mainline in revision 2397.
  • Revision ID: mbp@sourcefrog.net-20070404061731-tt2xrzllqhbodn83
Contents of TODO file moved into bug tracker

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge_directive.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
from email import Message
18
19
from StringIO import StringIO
19
 
import re
20
20
 
21
21
from bzrlib import (
22
22
    branch as _mod_branch,
23
23
    diff,
24
24
    errors,
25
25
    gpg,
26
 
    registry,
27
26
    revision as _mod_revision,
28
27
    rio,
29
28
    testament,
32
31
from bzrlib.bundle import (
33
32
    serializer as bundle_serializer,
34
33
    )
35
 
from bzrlib.email_message import EmailMessage
36
 
 
37
 
 
38
 
class _BaseMergeDirective(object):
 
34
 
 
35
 
 
36
class MergeDirective(object):
 
37
 
 
38
    """A request to perform a merge into a branch.
 
39
 
 
40
    Designed to be serialized and mailed.  It provides all the information
 
41
    needed to perform a merge automatically, by providing at minimum a revision
 
42
    bundle or the location of a branch.
 
43
 
 
44
    The serialization format is robust against certain common forms of
 
45
    deterioration caused by mailing.
 
46
 
 
47
    The format is also designed to be patch-compatible.  If the directive
 
48
    includes a diff or revision bundle, it should be possible to apply it
 
49
    directly using the standard patch program.
 
50
    """
 
51
 
 
52
    _format_string = 'Bazaar merge directive format 1'
39
53
 
40
54
    def __init__(self, revision_id, testament_sha1, time, timezone,
41
 
                 target_branch, patch=None, source_branch=None, message=None,
42
 
                 bundle=None):
 
55
                 target_branch, patch=None, patch_type=None,
 
56
                 source_branch=None, message=None):
43
57
        """Constructor.
44
58
 
45
59
        :param revision_id: The revision to merge
49
63
        :param timezone: The timezone offset
50
64
        :param target_branch: The branch to apply the merge to
51
65
        :param patch: The text of a diff or bundle
 
66
        :param patch_type: None, "diff" or "bundle", depending on the contents
 
67
            of patch
52
68
        :param source_branch: A public location to merge the revision from
53
69
        :param message: The message to use when committing this merge
54
70
        """
 
71
        assert patch_type in (None, 'diff', 'bundle')
 
72
        if patch_type != 'bundle' and source_branch is None:
 
73
            raise errors.NoMergeSource()
 
74
        if patch_type is not None and patch is None:
 
75
            raise errors.PatchMissing(patch_type)
55
76
        self.revision_id = revision_id
56
77
        self.testament_sha1 = testament_sha1
57
78
        self.time = time
58
79
        self.timezone = timezone
59
80
        self.target_branch = target_branch
60
81
        self.patch = patch
 
82
        self.patch_type = patch_type
61
83
        self.source_branch = source_branch
62
84
        self.message = message
63
85
 
64
 
    def _to_lines(self, base_revision=False):
 
86
    @classmethod
 
87
    def from_lines(klass, lines):
 
88
        """Deserialize a MergeRequest from an iterable of lines
 
89
 
 
90
        :param lines: An iterable of lines
 
91
        :return: a MergeRequest
 
92
        """
 
93
        line_iter = iter(lines)
 
94
        for line in line_iter:
 
95
            if line.startswith('# ' + klass._format_string):
 
96
                break
 
97
        else:
 
98
            if len(lines) > 0:
 
99
                raise errors.NotAMergeDirective(lines[0])
 
100
            else:
 
101
                raise errors.NotAMergeDirective('')
 
102
        stanza = rio.read_patch_stanza(line_iter)
 
103
        patch_lines = list(line_iter)
 
104
        if len(patch_lines) == 0:
 
105
            patch = None
 
106
            patch_type = None
 
107
        else:
 
108
            patch = ''.join(patch_lines)
 
109
            try:
 
110
                bundle_serializer.read_bundle(StringIO(patch))
 
111
            except errors.NotABundle:
 
112
                patch_type = 'diff'
 
113
            else:
 
114
                patch_type = 'bundle'
 
115
        time, timezone = timestamp.parse_patch_date(stanza.get('timestamp'))
 
116
        kwargs = {}
 
117
        for key in ('revision_id', 'testament_sha1', 'target_branch',
 
118
                    'source_branch', 'message'):
 
119
            try:
 
120
                kwargs[key] = stanza.get(key)
 
121
            except KeyError:
 
122
                pass
 
123
        kwargs['revision_id'] = kwargs['revision_id'].encode('utf-8')
 
124
        return MergeDirective(time=time, timezone=timezone,
 
125
                              patch_type=patch_type, patch=patch, **kwargs)
 
126
 
 
127
    def to_lines(self):
65
128
        """Serialize as a list of lines
66
129
 
67
130
        :return: a list of lines
73
136
        for key in ('source_branch', 'message'):
74
137
            if self.__dict__[key] is not None:
75
138
                stanza.add(key, self.__dict__[key])
76
 
        if base_revision:
77
 
            stanza.add('base_revision_id', self.base_revision_id)
78
139
        lines = ['# ' + self._format_string + '\n']
79
140
        lines.extend(rio.to_patch_lines(stanza))
80
141
        lines.append('# \n')
 
142
        if self.patch is not None:
 
143
            lines.extend(self.patch.splitlines(True))
81
144
        return lines
82
145
 
 
146
    def to_signed(self, branch):
 
147
        """Serialize as a signed string.
 
148
 
 
149
        :param branch: The source branch, to get the signing strategy
 
150
        :return: a string
 
151
        """
 
152
        my_gpg = gpg.GPGStrategy(branch.get_config())
 
153
        return my_gpg.sign(''.join(self.to_lines()))
 
154
 
 
155
    def to_email(self, mail_to, branch, sign=False):
 
156
        """Serialize as an email message.
 
157
 
 
158
        :param mail_to: The address to mail the message to
 
159
        :param branch: The source branch, to get the signing strategy and
 
160
            source email address
 
161
        :param sign: If True, gpg-sign the email
 
162
        :return: an email message
 
163
        """
 
164
        mail_from = branch.get_config().username()
 
165
        message = Message.Message()
 
166
        message['To'] = mail_to
 
167
        message['From'] = mail_from
 
168
        if self.message is not None:
 
169
            message['Subject'] = self.message
 
170
        else:
 
171
            revision = branch.repository.get_revision(self.revision_id)
 
172
            message['Subject'] = revision.message
 
173
        if sign:
 
174
            body = self.to_signed(branch)
 
175
        else:
 
176
            body = ''.join(self.to_lines())
 
177
        message.set_payload(body)
 
178
        return message
 
179
 
83
180
    @classmethod
84
181
    def from_objects(klass, repository, revision_id, time, timezone,
85
182
                 target_branch, patch_type='bundle',
105
202
        If the message is not supplied, the message from revision_id will be
106
203
        used for the commit.
107
204
        """
108
 
        t_revision_id = revision_id
109
 
        if revision_id == _mod_revision.NULL_REVISION:
110
 
            t_revision_id = None
111
 
        t = testament.StrictTestament3.from_revision(repository, t_revision_id)
 
205
        t = testament.StrictTestament3.from_revision(repository, revision_id)
112
206
        submit_branch = _mod_branch.Branch.open(target_branch)
113
207
        if submit_branch.get_public_branch() is not None:
114
208
            target_branch = submit_branch.get_public_branch()
116
210
            patch = None
117
211
        else:
118
212
            submit_revision_id = submit_branch.last_revision()
119
 
            submit_revision_id = _mod_revision.ensure_null(submit_revision_id)
120
213
            repository.fetch(submit_branch.repository, submit_revision_id)
121
 
            graph = repository.get_graph()
122
 
            ancestor_id = graph.find_unique_lca(revision_id,
123
 
                                                submit_revision_id)
 
214
            ancestor_id = _mod_revision.common_ancestor(revision_id,
 
215
                                                        submit_revision_id,
 
216
                                                        repository)
124
217
            type_handler = {'bundle': klass._generate_bundle,
125
218
                            'diff': klass._generate_diff,
126
219
                            None: lambda x, y, z: None }
127
220
            patch = type_handler[patch_type](repository, revision_id,
128
221
                                             ancestor_id)
129
 
 
130
 
        if public_branch is not None and patch_type != 'bundle':
131
 
            public_branch_obj = _mod_branch.Branch.open(public_branch)
132
 
            if not public_branch_obj.repository.has_revision(revision_id):
133
 
                raise errors.PublicBranchOutOfDate(public_branch,
134
 
                                                   revision_id)
135
 
 
136
 
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
137
 
            patch, patch_type, public_branch, message)
138
 
 
139
 
    def get_disk_name(self, branch):
140
 
        """Generate a suitable basename for storing this directive on disk
141
 
 
142
 
        :param branch: The Branch this merge directive was generated fro
143
 
        :return: A string
144
 
        """
145
 
        revno, revision_id = branch.last_revision_info()
146
 
        if self.revision_id == revision_id:
147
 
            revno = [revno]
148
 
        else:
149
 
            revno = branch.get_revision_id_to_revno_map().get(self.revision_id,
150
 
                ['merge'])
151
 
        nick = re.sub('(\W+)', '-', branch.nick).strip('-')
152
 
        return '%s-%s' % (nick, '.'.join(str(n) for n in revno))
 
222
            if patch_type == 'bundle':
 
223
                s = StringIO()
 
224
                bundle_serializer.write_bundle(repository, revision_id,
 
225
                                               ancestor_id, s)
 
226
                patch = s.getvalue()
 
227
            elif patch_type == 'diff':
 
228
                patch = klass._generate_diff(repository, revision_id,
 
229
                                             ancestor_id)
 
230
 
 
231
            if public_branch is not None and patch_type != 'bundle':
 
232
                public_branch_obj = _mod_branch.Branch.open(public_branch)
 
233
                if not public_branch_obj.repository.has_revision(revision_id):
 
234
                    raise errors.PublicBranchOutOfDate(public_branch,
 
235
                                                       revision_id)
 
236
 
 
237
        return MergeDirective(revision_id, t.as_sha1(), time, timezone,
 
238
                              target_branch, patch, patch_type, public_branch,
 
239
                              message)
153
240
 
154
241
    @staticmethod
155
242
    def _generate_diff(repository, revision_id, ancestor_id):
166
253
                                       ancestor_id, s)
167
254
        return s.getvalue()
168
255
 
169
 
    def to_signed(self, branch):
170
 
        """Serialize as a signed string.
171
 
 
172
 
        :param branch: The source branch, to get the signing strategy
173
 
        :return: a string
174
 
        """
175
 
        my_gpg = gpg.GPGStrategy(branch.get_config())
176
 
        return my_gpg.sign(''.join(self.to_lines()))
177
 
 
178
 
    def to_email(self, mail_to, branch, sign=False):
179
 
        """Serialize as an email message.
180
 
 
181
 
        :param mail_to: The address to mail the message to
182
 
        :param branch: The source branch, to get the signing strategy and
183
 
            source email address
184
 
        :param sign: If True, gpg-sign the email
185
 
        :return: an email message
186
 
        """
187
 
        mail_from = branch.get_config().username()
188
 
        if self.message is not None:
189
 
            subject = self.message
190
 
        else:
191
 
            revision = branch.repository.get_revision(self.revision_id)
192
 
            subject = revision.message
193
 
        if sign:
194
 
            body = self.to_signed(branch)
195
 
        else:
196
 
            body = ''.join(self.to_lines())
197
 
        message = EmailMessage(mail_from, mail_to, subject, body)
198
 
        return message
199
 
 
200
256
    def install_revisions(self, target_repo):
201
257
        """Install revisions and return the target revision"""
202
258
        if not target_repo.has_revision(self.revision_id):
203
259
            if self.patch_type == 'bundle':
204
 
                info = bundle_serializer.read_bundle(
205
 
                    StringIO(self.get_raw_bundle()))
 
260
                info = bundle_serializer.read_bundle(StringIO(self.patch))
206
261
                # We don't use the bundle's target revision, because
207
262
                # MergeDirective.revision_id is authoritative.
208
 
                try:
209
 
                    info.install_revisions(target_repo, stream_input=False)
210
 
                except errors.RevisionNotPresent:
211
 
                    # At least one dependency isn't present.  Try installing
212
 
                    # missing revisions from the submit branch
213
 
                    try:
214
 
                        submit_branch = \
215
 
                            _mod_branch.Branch.open(self.target_branch)
216
 
                    except errors.NotBranchError:
217
 
                        raise errors.TargetNotBranch(self.target_branch)
218
 
                    missing_revisions = []
219
 
                    bundle_revisions = set(r.revision_id for r in
220
 
                                           info.real_revisions)
221
 
                    for revision in info.real_revisions:
222
 
                        for parent_id in revision.parent_ids:
223
 
                            if (parent_id not in bundle_revisions and
224
 
                                not target_repo.has_revision(parent_id)):
225
 
                                missing_revisions.append(parent_id)
226
 
                    # reverse missing revisions to try to get heads first
227
 
                    unique_missing = []
228
 
                    unique_missing_set = set()
229
 
                    for revision in reversed(missing_revisions):
230
 
                        if revision in unique_missing_set:
231
 
                            continue
232
 
                        unique_missing.append(revision)
233
 
                        unique_missing_set.add(revision)
234
 
                    for missing_revision in unique_missing:
235
 
                        target_repo.fetch(submit_branch.repository,
236
 
                                          missing_revision)
237
 
                    info.install_revisions(target_repo, stream_input=False)
 
263
                info.install_revisions(target_repo)
238
264
            else:
239
265
                source_branch = _mod_branch.Branch.open(self.source_branch)
240
266
                target_repo.fetch(source_branch.repository, self.revision_id)
241
267
        return self.revision_id
242
 
 
243
 
 
244
 
class MergeDirective(_BaseMergeDirective):
245
 
 
246
 
    """A request to perform a merge into a branch.
247
 
 
248
 
    Designed to be serialized and mailed.  It provides all the information
249
 
    needed to perform a merge automatically, by providing at minimum a revision
250
 
    bundle or the location of a branch.
251
 
 
252
 
    The serialization format is robust against certain common forms of
253
 
    deterioration caused by mailing.
254
 
 
255
 
    The format is also designed to be patch-compatible.  If the directive
256
 
    includes a diff or revision bundle, it should be possible to apply it
257
 
    directly using the standard patch program.
258
 
    """
259
 
 
260
 
    _format_string = 'Bazaar merge directive format 1'
261
 
 
262
 
    def __init__(self, revision_id, testament_sha1, time, timezone,
263
 
                 target_branch, patch=None, patch_type=None,
264
 
                 source_branch=None, message=None, bundle=None):
265
 
        """Constructor.
266
 
 
267
 
        :param revision_id: The revision to merge
268
 
        :param testament_sha1: The sha1 of the testament of the revision to
269
 
            merge.
270
 
        :param time: The current POSIX timestamp time
271
 
        :param timezone: The timezone offset
272
 
        :param target_branch: The branch to apply the merge to
273
 
        :param patch: The text of a diff or bundle
274
 
        :param patch_type: None, "diff" or "bundle", depending on the contents
275
 
            of patch
276
 
        :param source_branch: A public location to merge the revision from
277
 
        :param message: The message to use when committing this merge
278
 
        """
279
 
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
280
 
            timezone, target_branch, patch, source_branch, message)
281
 
        if patch_type not in (None, 'diff', 'bundle'):
282
 
            raise ValueError(patch_type)
283
 
        if patch_type != 'bundle' and source_branch is None:
284
 
            raise errors.NoMergeSource()
285
 
        if patch_type is not None and patch is None:
286
 
            raise errors.PatchMissing(patch_type)
287
 
        self.patch_type = patch_type
288
 
 
289
 
    def clear_payload(self):
290
 
        self.patch = None
291
 
        self.patch_type = None
292
 
 
293
 
    def get_raw_bundle(self):
294
 
        return self.bundle
295
 
 
296
 
    def _bundle(self):
297
 
        if self.patch_type == 'bundle':
298
 
            return self.patch
299
 
        else:
300
 
            return None
301
 
 
302
 
    bundle = property(_bundle)
303
 
 
304
 
    @classmethod
305
 
    def from_lines(klass, lines):
306
 
        """Deserialize a MergeRequest from an iterable of lines
307
 
 
308
 
        :param lines: An iterable of lines
309
 
        :return: a MergeRequest
310
 
        """
311
 
        line_iter = iter(lines)
312
 
        for line in line_iter:
313
 
            if line.startswith('# Bazaar merge directive format '):
314
 
                break
315
 
        else:
316
 
            if len(lines) > 0:
317
 
                raise errors.NotAMergeDirective(lines[0])
318
 
            else:
319
 
                raise errors.NotAMergeDirective('')
320
 
        return _format_registry.get(line[2:].rstrip())._from_lines(line_iter)
321
 
 
322
 
    @classmethod
323
 
    def _from_lines(klass, line_iter):
324
 
        stanza = rio.read_patch_stanza(line_iter)
325
 
        patch_lines = list(line_iter)
326
 
        if len(patch_lines) == 0:
327
 
            patch = None
328
 
            patch_type = None
329
 
        else:
330
 
            patch = ''.join(patch_lines)
331
 
            try:
332
 
                bundle_serializer.read_bundle(StringIO(patch))
333
 
            except (errors.NotABundle, errors.BundleNotSupported,
334
 
                    errors.BadBundle):
335
 
                patch_type = 'diff'
336
 
            else:
337
 
                patch_type = 'bundle'
338
 
        time, timezone = timestamp.parse_patch_date(stanza.get('timestamp'))
339
 
        kwargs = {}
340
 
        for key in ('revision_id', 'testament_sha1', 'target_branch',
341
 
                    'source_branch', 'message'):
342
 
            try:
343
 
                kwargs[key] = stanza.get(key)
344
 
            except KeyError:
345
 
                pass
346
 
        kwargs['revision_id'] = kwargs['revision_id'].encode('utf-8')
347
 
        return MergeDirective(time=time, timezone=timezone,
348
 
                              patch_type=patch_type, patch=patch, **kwargs)
349
 
 
350
 
    def to_lines(self):
351
 
        lines = self._to_lines()
352
 
        if self.patch is not None:
353
 
            lines.extend(self.patch.splitlines(True))
354
 
        return lines
355
 
 
356
 
    @staticmethod
357
 
    def _generate_bundle(repository, revision_id, ancestor_id):
358
 
        s = StringIO()
359
 
        bundle_serializer.write_bundle(repository, revision_id,
360
 
                                       ancestor_id, s, '0.9')
361
 
        return s.getvalue()
362
 
 
363
 
    def get_merge_request(self, repository):
364
 
        """Provide data for performing a merge
365
 
 
366
 
        Returns suggested base, suggested target, and patch verification status
367
 
        """
368
 
        return None, self.revision_id, 'inapplicable'
369
 
 
370
 
 
371
 
class MergeDirective2(_BaseMergeDirective):
372
 
 
373
 
    _format_string = 'Bazaar merge directive format 2 (Bazaar 0.90)'
374
 
 
375
 
    def __init__(self, revision_id, testament_sha1, time, timezone,
376
 
                 target_branch, patch=None, source_branch=None, message=None,
377
 
                 bundle=None, base_revision_id=None):
378
 
        if source_branch is None and bundle is None:
379
 
            raise errors.NoMergeSource()
380
 
        _BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
381
 
            timezone, target_branch, patch, source_branch, message)
382
 
        self.bundle = bundle
383
 
        self.base_revision_id = base_revision_id
384
 
 
385
 
    def _patch_type(self):
386
 
        if self.bundle is not None:
387
 
            return 'bundle'
388
 
        elif self.patch is not None:
389
 
            return 'diff'
390
 
        else:
391
 
            return None
392
 
 
393
 
    patch_type = property(_patch_type)
394
 
 
395
 
    def clear_payload(self):
396
 
        self.patch = None
397
 
        self.bundle = None
398
 
 
399
 
    def get_raw_bundle(self):
400
 
        if self.bundle is None:
401
 
            return None
402
 
        else:
403
 
            return self.bundle.decode('base-64')
404
 
 
405
 
    @classmethod
406
 
    def _from_lines(klass, line_iter):
407
 
        stanza = rio.read_patch_stanza(line_iter)
408
 
        patch = None
409
 
        bundle = None
410
 
        try:
411
 
            start = line_iter.next()
412
 
        except StopIteration:
413
 
            pass
414
 
        else:
415
 
            if start.startswith('# Begin patch'):
416
 
                patch_lines = []
417
 
                for line in line_iter:
418
 
                    if line.startswith('# Begin bundle'):
419
 
                        start = line
420
 
                        break
421
 
                    patch_lines.append(line)
422
 
                else:
423
 
                    start = None
424
 
                patch = ''.join(patch_lines)
425
 
            if start is not None:
426
 
                if start.startswith('# Begin bundle'):
427
 
                    bundle = ''.join(line_iter)
428
 
                else:
429
 
                    raise errors.IllegalMergeDirectivePayload(start)
430
 
        time, timezone = timestamp.parse_patch_date(stanza.get('timestamp'))
431
 
        kwargs = {}
432
 
        for key in ('revision_id', 'testament_sha1', 'target_branch',
433
 
                    'source_branch', 'message', 'base_revision_id'):
434
 
            try:
435
 
                kwargs[key] = stanza.get(key)
436
 
            except KeyError:
437
 
                pass
438
 
        kwargs['revision_id'] = kwargs['revision_id'].encode('utf-8')
439
 
        kwargs['base_revision_id'] =\
440
 
            kwargs['base_revision_id'].encode('utf-8')
441
 
        return klass(time=time, timezone=timezone, patch=patch, bundle=bundle,
442
 
                     **kwargs)
443
 
 
444
 
    def to_lines(self):
445
 
        lines = self._to_lines(base_revision=True)
446
 
        if self.patch is not None:
447
 
            lines.append('# Begin patch\n')
448
 
            lines.extend(self.patch.splitlines(True))
449
 
        if self.bundle is not None:
450
 
            lines.append('# Begin bundle\n')
451
 
            lines.extend(self.bundle.splitlines(True))
452
 
        return lines
453
 
 
454
 
    @classmethod
455
 
    def from_objects(klass, repository, revision_id, time, timezone,
456
 
                 target_branch, include_patch=True, include_bundle=True,
457
 
                 local_target_branch=None, public_branch=None, message=None,
458
 
                 base_revision_id=None):
459
 
        """Generate a merge directive from various objects
460
 
 
461
 
        :param repository: The repository containing the revision
462
 
        :param revision_id: The revision to merge
463
 
        :param time: The POSIX timestamp of the date the request was issued.
464
 
        :param timezone: The timezone of the request
465
 
        :param target_branch: The url of the branch to merge into
466
 
        :param include_patch: If true, include a preview patch
467
 
        :param include_bundle: If true, include a bundle
468
 
        :param local_target_branch: a local copy of the target branch
469
 
        :param public_branch: location of a public branch containing the target
470
 
            revision.
471
 
        :param message: Message to use when committing the merge
472
 
        :return: The merge directive
473
 
 
474
 
        The public branch is always used if supplied.  If no bundle is
475
 
        included, the public branch must be supplied, and will be verified.
476
 
 
477
 
        If the message is not supplied, the message from revision_id will be
478
 
        used for the commit.
479
 
        """
480
 
        locked = []
481
 
        try:
482
 
            repository.lock_write()
483
 
            locked.append(repository)
484
 
            t_revision_id = revision_id
485
 
            if revision_id == 'null:':
486
 
                t_revision_id = None
487
 
            t = testament.StrictTestament3.from_revision(repository,
488
 
                t_revision_id)
489
 
            submit_branch = _mod_branch.Branch.open(target_branch)
490
 
            submit_branch.lock_read()
491
 
            locked.append(submit_branch)
492
 
            if submit_branch.get_public_branch() is not None:
493
 
                target_branch = submit_branch.get_public_branch()
494
 
            submit_revision_id = submit_branch.last_revision()
495
 
            submit_revision_id = _mod_revision.ensure_null(submit_revision_id)
496
 
            graph = repository.get_graph(submit_branch.repository)
497
 
            ancestor_id = graph.find_unique_lca(revision_id,
498
 
                                                submit_revision_id)
499
 
            if base_revision_id is None:
500
 
                base_revision_id = ancestor_id
501
 
            if (include_patch, include_bundle) != (False, False):
502
 
                repository.fetch(submit_branch.repository, submit_revision_id)
503
 
            if include_patch:
504
 
                patch = klass._generate_diff(repository, revision_id,
505
 
                                             base_revision_id)
506
 
            else:
507
 
                patch = None
508
 
 
509
 
            if include_bundle:
510
 
                bundle = klass._generate_bundle(repository, revision_id,
511
 
                    ancestor_id).encode('base-64')
512
 
            else:
513
 
                bundle = None
514
 
 
515
 
            if public_branch is not None and not include_bundle:
516
 
                public_branch_obj = _mod_branch.Branch.open(public_branch)
517
 
                public_branch_obj.lock_read()
518
 
                locked.append(public_branch_obj)
519
 
                if not public_branch_obj.repository.has_revision(
520
 
                    revision_id):
521
 
                    raise errors.PublicBranchOutOfDate(public_branch,
522
 
                                                       revision_id)
523
 
        finally:
524
 
            for entry in reversed(locked):
525
 
                entry.unlock()
526
 
        return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
527
 
            patch, public_branch, message, bundle, base_revision_id)
528
 
 
529
 
    def _verify_patch(self, repository):
530
 
        calculated_patch = self._generate_diff(repository, self.revision_id,
531
 
                                               self.base_revision_id)
532
 
        # Convert line-endings to UNIX
533
 
        stored_patch = re.sub('\r\n?', '\n', self.patch)
534
 
        calculated_patch = re.sub('\r\n?', '\n', calculated_patch)
535
 
        # Strip trailing whitespace
536
 
        calculated_patch = re.sub(' *\n', '\n', calculated_patch)
537
 
        stored_patch = re.sub(' *\n', '\n', stored_patch)
538
 
        return (calculated_patch == stored_patch)
539
 
 
540
 
    def get_merge_request(self, repository):
541
 
        """Provide data for performing a merge
542
 
 
543
 
        Returns suggested base, suggested target, and patch verification status
544
 
        """
545
 
        verified = self._maybe_verify(repository)
546
 
        return self.base_revision_id, self.revision_id, verified
547
 
 
548
 
    def _maybe_verify(self, repository):
549
 
        if self.patch is not None:
550
 
            if self._verify_patch(repository):
551
 
                return 'verified'
552
 
            else:
553
 
                return 'failed'
554
 
        else:
555
 
            return 'inapplicable'
556
 
 
557
 
 
558
 
class MergeDirectiveFormatRegistry(registry.Registry):
559
 
 
560
 
    def register(self, directive, format_string=None):
561
 
        if format_string is None:
562
 
            format_string = directive._format_string
563
 
        registry.Registry.register(self, format_string, directive)
564
 
 
565
 
 
566
 
_format_registry = MergeDirectiveFormatRegistry()
567
 
_format_registry.register(MergeDirective)
568
 
_format_registry.register(MergeDirective2)
569
 
# 0.19 never existed.  It got renamed to 0.90.  But by that point, there were
570
 
# already merge directives in the wild that used 0.19. Registering with the old
571
 
# format string to retain compatibility with those merge directives.
572
 
_format_registry.register(MergeDirective2,
573
 
                          'Bazaar merge directive format 2 (Bazaar 0.19)')