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
17
from __future__ import absolute_import
19
18
from StringIO import StringIO
22
from bzrlib import lazy_import
23
lazy_import.lazy_import(globals(), """
24
21
from bzrlib import (
25
22
branch as _mod_branch,
32
27
revision as _mod_revision,
38
32
from bzrlib.bundle import (
39
33
serializer as bundle_serializer,
44
class MergeRequestBodyParams(object):
45
"""Parameter object for the merge_request_body hook."""
47
def __init__(self, body, orig_body, directive, to, basename, subject,
50
self.orig_body = orig_body
51
self.directive = directive
55
self.basename = basename
56
self.subject = subject
59
class MergeDirectiveHooks(hooks.Hooks):
60
"""Hooks for MergeDirective classes."""
63
hooks.Hooks.__init__(self, "bzrlib.merge_directive", "BaseMergeDirective.hooks")
64
self.add_hook('merge_request_body',
65
"Called with a MergeRequestBodyParams when a body is needed for"
66
" a merge request. Callbacks must return a body. If more"
67
" than one callback is registered, the output of one callback is"
68
" provided to the next.", (1, 15, 0))
71
class BaseMergeDirective(object):
72
"""A request to perform a merge into a branch.
74
This is the base class that all merge directive implementations
77
:cvar multiple_output_files: Whether or not this merge directive
78
stores a set of revisions in more than one file
81
hooks = MergeDirectiveHooks()
83
multiple_output_files = False
35
from bzrlib.email_message import EmailMessage
38
class _BaseMergeDirective(object):
85
40
def __init__(self, revision_id, testament_sha1, time, timezone,
86
target_branch, patch=None, source_branch=None,
87
message=None, bundle=None):
41
target_branch, patch=None, source_branch=None, message=None,
90
45
:param revision_id: The revision to merge
106
61
self.source_branch = source_branch
107
62
self.message = message
110
"""Serialize as a list of lines
112
:return: a list of lines
114
raise NotImplementedError(self.to_lines)
117
"""Serialize as a set of files.
119
:return: List of tuples with filename and contents as lines
121
raise NotImplementedError(self.to_files)
123
def get_raw_bundle(self):
124
"""Return the bundle for this merge directive.
126
:return: bundle text or None if there is no bundle
130
64
def _to_lines(self, base_revision=False):
131
65
"""Serialize as a list of lines
146
80
lines.append('# \n')
149
def write_to_directory(self, path):
150
"""Write this merge directive to a series of files in a directory.
152
:param path: Filesystem path to write to
154
raise NotImplementedError(self.write_to_directory)
157
84
def from_objects(klass, repository, revision_id, time, timezone,
158
85
target_branch, patch_type='bundle',
166
93
:param target_branch: The url of the branch to merge into
167
94
:param patch_type: 'bundle', 'diff' or None, depending on the type of
169
:param local_target_branch: the submit branch, either itself or a local copy
170
:param public_branch: location of a public branch containing
96
:param local_target_branch: a local copy of the target branch
97
:param public_branch: location of a public branch containing the target
172
99
:param message: Message to use when committing the merge
173
100
:return: The merge directive
182
109
if revision_id == _mod_revision.NULL_REVISION:
183
110
t_revision_id = None
184
111
t = testament.StrictTestament3.from_revision(repository, t_revision_id)
185
if local_target_branch is None:
186
submit_branch = _mod_branch.Branch.open(target_branch)
188
submit_branch = local_target_branch
112
submit_branch = _mod_branch.Branch.open(target_branch)
189
113
if submit_branch.get_public_branch() is not None:
190
114
target_branch = submit_branch.get_public_branch()
191
115
if patch_type is None:
270
194
body = self.to_signed(branch)
272
196
body = ''.join(self.to_lines())
273
message = email_message.EmailMessage(mail_from, mail_to, subject,
197
message = EmailMessage(mail_from, mail_to, subject, body)
277
200
def install_revisions(self, target_repo):
317
240
target_repo.fetch(source_branch.repository, self.revision_id)
318
241
return self.revision_id
320
def compose_merge_request(self, mail_client, to, body, branch, tree=None):
321
"""Compose a request to merge this directive.
323
:param mail_client: The mail client to use for composing this request.
324
:param to: The address to compose the request to.
325
:param branch: The Branch that was used to produce this directive.
326
:param tree: The Tree (if any) for the Branch used to produce this
329
basename = self.get_disk_name(branch)
331
if self.message is not None:
332
subject += self.message
334
revision = branch.repository.get_revision(self.revision_id)
335
subject += revision.get_summary()
336
if getattr(mail_client, 'supports_body', False):
338
for hook in self.hooks['merge_request_body']:
339
params = MergeRequestBodyParams(body, orig_body, self,
340
to, basename, subject, branch,
343
elif len(self.hooks['merge_request_body']) > 0:
344
trace.warning('Cannot run merge_request_body hooks because mail'
345
' client %s does not support message bodies.',
346
mail_client.__class__.__name__)
347
mail_client.compose_merge_request(to, subject,
348
''.join(self.to_lines()),
352
class MergeDirective(BaseMergeDirective):
244
class MergeDirective(_BaseMergeDirective):
354
246
"""A request to perform a merge into a branch.
378
270
:param time: The current POSIX timestamp time
379
271
:param timezone: The timezone offset
380
:param target_branch: Location of the branch to apply the merge to
272
:param target_branch: The branch to apply the merge to
381
273
:param patch: The text of a diff or bundle
382
274
:param patch_type: None, "diff" or "bundle", depending on the contents
384
276
:param source_branch: A public location to merge the revision from
385
277
:param message: The message to use when committing this merge
387
BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
279
_BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
388
280
timezone, target_branch, patch, source_branch, message)
389
281
if patch_type not in (None, 'diff', 'bundle'):
390
282
raise ValueError(patch_type)
417
309
:return: a MergeRequest
419
311
line_iter = iter(lines)
421
312
for line in line_iter:
422
313
if line.startswith('# Bazaar merge directive format '):
423
return _format_registry.get(line[2:].rstrip())._from_lines(
425
firstline = firstline or line.strip()
426
raise errors.NotAMergeDirective(firstline)
317
raise errors.NotAMergeDirective(lines[0])
319
raise errors.NotAMergeDirective('')
320
return _format_registry.get(line[2:].rstrip())._from_lines(line_iter)
429
323
def _from_lines(klass, line_iter):
483
377
bundle=None, base_revision_id=None):
484
378
if source_branch is None and bundle is None:
485
379
raise errors.NoMergeSource()
486
BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
380
_BaseMergeDirective.__init__(self, revision_id, testament_sha1, time,
487
381
timezone, target_branch, patch, source_branch, message)
488
382
self.bundle = bundle
489
383
self.base_revision_id = base_revision_id
571
465
:param target_branch: The url of the branch to merge into
572
466
:param include_patch: If true, include a preview patch
573
467
:param include_bundle: If true, include a bundle
574
:param local_target_branch: the target branch, either itself or a local copy
575
:param public_branch: location of a public branch containing
468
:param local_target_branch: a local copy of the target branch
469
:param public_branch: location of a public branch containing the target
577
471
:param message: Message to use when committing the merge
578
472
:return: The merge directive
592
486
t_revision_id = None
593
487
t = testament.StrictTestament3.from_revision(repository,
595
if local_target_branch is None:
596
submit_branch = _mod_branch.Branch.open(target_branch)
598
submit_branch = local_target_branch
489
submit_branch = _mod_branch.Branch.open(target_branch)
599
490
submit_branch.lock_read()
600
491
locked.append(submit_branch)
601
492
if submit_branch.get_public_branch() is not None:
630
521
raise errors.PublicBranchOutOfDate(public_branch,
632
testament_sha1 = t.as_sha1()
634
524
for entry in reversed(locked):
636
return klass(revision_id, testament_sha1, time, timezone,
637
target_branch, patch, public_branch, message, bundle,
526
return klass(revision_id, t.as_sha1(), time, timezone, target_branch,
527
patch, public_branch, message, bundle, base_revision_id)
640
529
def _verify_patch(self, repository):
641
530
calculated_patch = self._generate_diff(repository, self.revision_id,
677
566
_format_registry = MergeDirectiveFormatRegistry()
678
567
_format_registry.register(MergeDirective)
679
568
_format_registry.register(MergeDirective2)
680
# 0.19 never existed. It got renamed to 0.90. But by that point, there were
681
# already merge directives in the wild that used 0.19. Registering with the old
682
# format string to retain compatibility with those merge directives.
683
569
_format_registry.register(MergeDirective2,
684
570
'Bazaar merge directive format 2 (Bazaar 0.19)')