« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1666.1.6
- compare with another revision
- download diff
- download tarball
- view history from revision 1666.1.6
- Committer: Robert Collins
- Date: 2006-04-19 23:32:08 UTC
- mto: (1711.1.1 integration)
- mto: This revision was merged to the branch mainline in revision 1674.
- Revision ID: robertc@robertcollins.net-20060419233208-2ed6906796994316
Make knit the default format.
Adjust affect tests to either have knit specific values or to be more generic,
as appropriate.
Disable all SFTP prefetching for known paramikos - direct readv support is now
a TODO.
Adjust affect tests to either have knit specific values or to be more generic,
as appropriate.
Disable all SFTP prefetching for known paramikos - direct readv support is now
a TODO.
- files added:
- BRANCH.TODO
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/store
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/blackbox
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport
- bzrlib/transport/http
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- tools/doc_generate
- files removed:
- bzrlib/changeset.py
- patches
- files renamed:
- bzrlib/store.py => bzrlib/store/__init__.py
- bzrlib/weavestore.py => bzrlib/store/versioned/__init__.py
- bzrlib/selftest/ => bzrlib/tests/
- bzrlib/selftest/teststatus.py => bzrlib/tests/blackbox/test_status.py
- bzrlib/selftest/blackbox.py => bzrlib/tests/blackbox/test_too_much.py
- bzrlib/selftest/versioning.py => bzrlib/tests/blackbox/test_versioning.py
- bzrlib/selftest/testbranch.py => bzrlib/tests/branch_implementations/test_branch.py
- bzrlib/selftest/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/selftest/testdiff.py => bzrlib/tests/test_diff.py
- bzrlib/selftest/testfetch.py => bzrlib/tests/test_fetch.py
- bzrlib/selftest/testhashcache.py => bzrlib/tests/test_hashcache.py
- bzrlib/selftest/testinv.py => bzrlib/tests/test_inv.py
- bzrlib/selftest/testlog.py => bzrlib/tests/test_log.py
- bzrlib/selftest/testmerge3.py => bzrlib/tests/test_merge3.py
- bzrlib/selftest/plugins.py => bzrlib/tests/test_plugins.py
- bzrlib/selftest/testrevision.py => bzrlib/tests/test_revision.py
- bzrlib/selftest/testrevisionnamespaces.py => bzrlib/tests/test_revisionnamespaces.py
- bzrlib/selftest/teststore.py => bzrlib/tests/test_store.py
- tools/testweave.py => bzrlib/tests/test_weave.py
- bzrlib/selftest/whitebox.py => bzrlib/tests/test_whitebox.py
- bzrlib/ui.py => bzrlib/ui/__init__.py
- tools/history2weaves.py => bzrlib/upgrade.py
- bzrlib/xml.py => bzrlib/xml_serializer.py
- bzr-man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
1
# Copyright (C) 2004, 2005, 2006 by 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
16
17
17
"""builtin bzr commands"""
18
19
20
import errno
21
import os
22
from shutil import rmtree
18
23
import sys
19
import os
20
24
21
25
import bzrlib
26
import bzrlib.branch
27
from bzrlib.branch import Branch
28
import bzrlib.bzrdir as bzrdir
29
from bzrlib.commands import Command, display_command
30
from bzrlib.revision import common_ancestor
31
import bzrlib.errors as errors
32
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
33
NotBranchError, DivergedBranches, NotConflicted,
34
NoSuchFile, NoWorkingTree, FileInWrongBranch,
35
NotVersionedError)
36
from bzrlib.log import show_one_log
37
from bzrlib.merge import Merge3Merger
38
from bzrlib.option import Option
39
from bzrlib.progress import DummyProgress, ProgressPhase
40
from bzrlib.revisionspec import RevisionSpec
22
41
import bzrlib.trace
23
from bzrlib.trace import mutter, note, log_error, warning
24
from bzrlib.errors import BzrError, BzrCheckError, BzrCommandError
25
from bzrlib.branch import find_branch
26
from bzrlib import BZRDIR
27
from bzrlib.commands import Command
28
42
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
43
from bzrlib.transport.local import LocalTransport
44
import bzrlib.ui
45
from bzrlib.workingtree import WorkingTree
46
47
48
def tree_files(file_list, default_branch=u'.'):
49
try:
50
return internal_tree_files(file_list, default_branch)
51
except FileInWrongBranch, e:
52
raise BzrCommandError("%s is not in the same branch as %s" %
53
(e.path, file_list[0]))
54
55
56
# XXX: Bad function name; should possibly also be a class method of
57
# WorkingTree rather than a function.
58
def internal_tree_files(file_list, default_branch=u'.'):
59
"""Convert command-line paths to a WorkingTree and relative paths.
60
61
This is typically used for command-line processors that take one or
62
more filenames, and infer the workingtree that contains them.
63
64
The filenames given are not required to exist.
65
66
:param file_list: Filenames to convert.
67
68
:param default_branch: Fallback tree path to use if file_list is empty or None.
69
70
:return: workingtree, [relative_paths]
71
"""
72
if file_list is None or len(file_list) == 0:
73
return WorkingTree.open_containing(default_branch)[0], file_list
74
tree = WorkingTree.open_containing(file_list[0])[0]
75
new_list = []
76
for filename in file_list:
77
try:
78
new_list.append(tree.relpath(filename))
79
except errors.PathNotChild:
80
raise FileInWrongBranch(tree.branch, filename)
81
return tree, new_list
82
83
84
def get_format_type(typestring):
85
"""Parse and return a format specifier."""
86
if typestring == "weave":
87
return bzrdir.BzrDirFormat6()
88
if typestring == "metadir":
89
return bzrdir.BzrDirMetaFormat1()
90
if typestring == "knit":
91
format = bzrdir.BzrDirMetaFormat1()
92
format.repository_format = bzrlib.repository.RepositoryFormatKnit1()
93
return format
94
msg = "No known bzr-dir format %s. Supported types are: weave, metadir\n" %\
95
(typestring)
96
raise BzrCommandError(msg)
97
98
99
# TODO: Make sure no commands unconditionally use the working directory as a
100
# branch. If a filename argument is used, the first of them should be used to
101
# specify the branch. (Perhaps this can be factored out into some kind of
102
# Argument class, representing a file in a branch, where the first occurrence
103
# opens the branch?)
29
104
30
105
class cmd_status(Command):
31
106
"""Display status summary.
63
138
files or directories is reported. If a directory is given, status
64
139
is reported for everything inside that directory.
65
140
66
If a revision is specified, the changes since that revision are shown.
141
If a revision argument is given, the status is calculated against
142
that revision, or between two revisions if two are provided.
67
143
"""
144
145
# TODO: --no-recurse, --recurse options
146
68
147
takes_args = ['file*']
69
148
takes_options = ['all', 'show-ids', 'revision']
70
149
aliases = ['st', 'stat']
71
150
72
def run(self, all=False, show_ids=False, file_list=None):
73
if file_list:
74
b = find_branch(file_list[0])
75
file_list = [b.relpath(x) for x in file_list]
76
# special case: only one path was given and it's the root
77
# of the branch
78
if file_list == ['']:
79
file_list = None
80
else:
81
b = find_branch('.')
151
@display_command
152
def run(self, all=False, show_ids=False, file_list=None, revision=None):
153
tree, file_list = tree_files(file_list)
82
154
83
from bzrlib.status import show_status
84
show_status(b, show_unchanged=all, show_ids=show_ids,
85
specific_files=file_list)
155
from bzrlib.status import show_tree_status
156
show_tree_status(tree, show_unchanged=all, show_ids=show_ids,
157
specific_files=file_list, revision=revision)
86
158
87
159
88
160
class cmd_cat_revision(Command):
89
"""Write out metadata for a revision."""
161
"""Write out metadata for a revision.
162
163
The revision to print can either be specified by a specific
164
revision identifier, or you can use --revision.
165
"""
90
166
91
167
hidden = True
92
takes_args = ['revision_id']
168
takes_args = ['revision_id?']
169
takes_options = ['revision']
93
170
94
def run(self, revision_id):
95
b = find_branch('.')
96
sys.stdout.write(b.get_revision_xml_file(revision_id).read())
171
@display_command
172
def run(self, revision_id=None, revision=None):
97
173
174
if revision_id is not None and revision is not None:
175
raise BzrCommandError('You can only supply one of revision_id or --revision')
176
if revision_id is None and revision is None:
177
raise BzrCommandError('You must supply either --revision or a revision_id')
178
b = WorkingTree.open_containing(u'.')[0].branch
179
if revision_id is not None:
180
sys.stdout.write(b.repository.get_revision_xml(revision_id))
181
elif revision is not None:
182
for rev in revision:
183
if rev is None:
184
raise BzrCommandError('You cannot specify a NULL revision.')
185
revno, rev_id = rev.in_history(b)
186
sys.stdout.write(b.repository.get_revision_xml(rev_id))
187
98
188
99
189
class cmd_revno(Command):
100
190
"""Show current revision number.
101
191
102
192
This is equal to the number of revisions on this branch."""
103
def run(self):
104
print find_branch('.').revno()
193
takes_args = ['location?']
194
@display_command
195
def run(self, location=u'.'):
196
print Branch.open_containing(location)[0].revno()
105
197
106
198
107
199
class cmd_revision_info(Command):
110
202
hidden = True
111
203
takes_args = ['revision_info*']
112
204
takes_options = ['revision']
113
def run(self, revision=None, revision_info_list=None):
114
from bzrlib.branch import find_branch
205
@display_command
206
def run(self, revision=None, revision_info_list=[]):
115
207
116
208
revs = []
117
209
if revision is not None:
118
210
revs.extend(revision)
119
211
if revision_info_list is not None:
120
revs.extend(revision_info_list)
212
for rev in revision_info_list:
213
revs.append(RevisionSpec(rev))
121
214
if len(revs) == 0:
122
215
raise BzrCommandError('You must supply a revision identifier')
123
216
124
b = find_branch('.')
217
b = WorkingTree.open_containing(u'.')[0].branch
125
218
126
219
for rev in revs:
127
print '%4d %s' % b.get_revision_info(rev)
220
revinfo = rev.in_history(b)
221
if revinfo.revno is None:
222
print ' %s' % revinfo.rev_id
223
else:
224
print '%4d %s' % (revinfo.revno, revinfo.rev_id)
128
225
129
226
130
227
class cmd_add(Command):
145
242
Therefore simply saying 'bzr add' will version all files that
146
243
are currently unknown.
147
244
148
TODO: Perhaps adding a file whose directly is not versioned should
149
recursively add that parent, rather than giving an error?
245
Adding a file whose parent directory is not versioned will
246
implicitly add the parent, and so on up to the root. This means
247
you should never need to explictly add a directory, they'll just
248
get added when you add a file in the directory.
249
250
--dry-run will show which files would be added, but not actually
251
add them.
150
252
"""
151
253
takes_args = ['file*']
152
takes_options = ['verbose', 'no-recurse']
153
154
def run(self, file_list, verbose=False, no_recurse=False):
155
# verbose currently has no effect
156
from bzrlib.add import smart_add, add_reporter_print
157
smart_add(file_list, not no_recurse, add_reporter_print)
158
254
takes_options = ['no-recurse', 'dry-run', 'verbose']
255
256
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
257
import bzrlib.add
258
259
if dry_run:
260
if is_quiet():
261
# This is pointless, but I'd rather not raise an error
262
action = bzrlib.add.add_action_null
263
else:
264
action = bzrlib.add.add_action_print
265
elif is_quiet():
266
action = bzrlib.add.add_action_add
267
else:
268
action = bzrlib.add.add_action_add_and_print
269
270
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
271
action)
272
if len(ignored) > 0:
273
for glob in sorted(ignored.keys()):
274
match_len = len(ignored[glob])
275
if verbose:
276
for path in ignored[glob]:
277
print "ignored %s matching \"%s\"" % (path, glob)
278
else:
279
print "ignored %d file(s) matching \"%s\"" % (match_len,
280
glob)
281
print "If you wish to add some of these files, please add them"\
282
" by name."
159
283
160
284
161
285
class cmd_mkdir(Command):
166
290
takes_args = ['dir+']
167
291
168
292
def run(self, dir_list):
169
b = None
170
171
293
for d in dir_list:
172
294
os.mkdir(d)
173
if not b:
174
b = find_branch(d)
175
b.add([d])
295
wt, dd = WorkingTree.open_containing(d)
296
wt.add([dd])
176
297
print 'added', d
177
298
178
299
181
302
takes_args = ['filename']
182
303
hidden = True
183
304
305
@display_command
184
306
def run(self, filename):
185
print find_branch(filename).relpath(filename)
186
307
tree, relpath = WorkingTree.open_containing(filename)
308
print relpath
187
309
188
310
189
311
class cmd_inventory(Command):
190
"""Show inventory of the current working copy or a revision."""
191
takes_options = ['revision', 'show-ids']
312
"""Show inventory of the current working copy or a revision.
313
314
It is possible to limit the output to a particular entry
315
type using the --kind option. For example; --kind file.
316
"""
317
takes_options = ['revision', 'show-ids', 'kind']
192
318
193
def run(self, revision=None, show_ids=False):
194
b = find_branch('.')
195
if revision == None:
196
inv = b.read_working_inventory()
319
@display_command
320
def run(self, revision=None, show_ids=False, kind=None):
321
if kind and kind not in ['file', 'directory', 'symlink']:
322
raise BzrCommandError('invalid kind specified')
323
tree = WorkingTree.open_containing(u'.')[0]
324
if revision is None:
325
inv = tree.read_working_inventory()
197
326
else:
198
327
if len(revision) > 1:
199
328
raise BzrCommandError('bzr inventory --revision takes'
200
329
' exactly one revision identifier')
201
inv = b.get_revision_inventory(b.lookup_revision(revision[0]))
330
inv = tree.branch.repository.get_revision_inventory(
331
revision[0].in_history(tree.branch).rev_id)
202
332
203
333
for path, entry in inv.entries():
334
if kind and kind != entry.kind:
335
continue
204
336
if show_ids:
205
337
print '%-50s %s' % (path, entry.file_id)
206
338
else:
207
339
print path
208
340
209
341
210
class cmd_move(Command):
211
"""Move files to a different directory.
212
213
examples:
214
bzr move *.txt doc
215
216
The destination must be a versioned directory in the same branch.
217
"""
218
takes_args = ['source$', 'dest']
219
def run(self, source_list, dest):
220
b = find_branch('.')
221
222
# TODO: glob expansion on windows?
223
b.move([b.relpath(s) for s in source_list], b.relpath(dest))
224
225
226
class cmd_rename(Command):
227
"""Change the name of an entry.
228
229
examples:
230
bzr rename frob.c frobber.c
231
bzr rename src/frob.c lib/frob.c
232
233
It is an error if the destination name exists.
234
235
See also the 'move' command, which moves files into a different
236
directory without changing their name.
237
238
TODO: Some way to rename multiple files without invoking bzr for each
239
one?"""
240
takes_args = ['from_name', 'to_name']
241
242
def run(self, from_name, to_name):
243
b = find_branch('.')
244
b.rename_one(b.relpath(from_name), b.relpath(to_name))
245
246
247
248
342
class cmd_mv(Command):
249
343
"""Move or rename a file.
250
344
259
353
Files cannot be moved between branches.
260
354
"""
261
355
takes_args = ['names*']
356
aliases = ['move', 'rename']
357
262
358
def run(self, names_list):
263
359
if len(names_list) < 2:
264
360
raise BzrCommandError("missing file argument")
265
b = find_branch(names_list[0])
266
267
rel_names = [b.relpath(x) for x in names_list]
361
tree, rel_names = tree_files(names_list)
268
362
269
363
if os.path.isdir(names_list[-1]):
270
364
# move into existing directory
271
for pair in b.move(rel_names[:-1], rel_names[-1]):
365
for pair in tree.move(rel_names[:-1], rel_names[-1]):
272
366
print "%s => %s" % pair
273
367
else:
274
368
if len(names_list) != 2:
275
369
raise BzrCommandError('to mv multiple files the destination '
276
370
'must be a versioned directory')
277
for pair in b.move(rel_names[0], rel_names[1]):
278
print "%s => %s" % pair
371
tree.rename_one(rel_names[0], rel_names[1])
372
print "%s => %s" % (rel_names[0], rel_names[1])
279
373
280
374
281
282
283
375
class cmd_pull(Command):
284
"""Pull any changes from another branch into the current one.
285
286
If the location is omitted, the last-used location will be used.
287
Both the revision history and the working directory will be
288
updated.
376
"""Turn this branch into a mirror of another branch.
289
377
290
378
This command only works on branches that have not diverged. Branches are
291
considered diverged if both branches have had commits without first
292
pulling from the other.
379
considered diverged if the destination branch's most recent commit is one
380
that has not been merged (directly or indirectly) into the parent.
381
382
If branches have diverged, you can use 'bzr merge' to integrate the changes
383
from one into the other. Once one branch has merged, the other should
384
be able to pull it again.
293
385
294
386
If branches have diverged, you can use 'bzr merge' to pull the text changes
295
from one into the other.
387
from one into the other. Once one branch has merged, the other should
388
be able to pull it again.
389
390
If you want to forget your local changes and just update your branch to
391
match the remote one, use pull --overwrite.
392
393
If there is no default location set, the first pull will set it. After
394
that, you can omit the location to use the default. To change the
395
default, use --remember.
296
396
"""
397
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
297
398
takes_args = ['location?']
298
399
299
def run(self, location=None):
300
from bzrlib.merge import merge
301
import tempfile
302
from shutil import rmtree
303
import errno
304
from bzrlib.branch import pull_loc
305
306
br_to = find_branch('.')
307
stored_loc = None
400
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
401
# FIXME: too much stuff is in the command class
308
402
try:
309
stored_loc = br_to.controlfile("x-pull", "rb").read().rstrip('\n')
310
except IOError, e:
311
if e.errno != errno.ENOENT:
312
raise
403
tree_to = WorkingTree.open_containing(u'.')[0]
404
branch_to = tree_to.branch
405
except NoWorkingTree:
406
tree_to = None
407
branch_to = Branch.open_containing(u'.')[0]
408
stored_loc = branch_to.get_parent()
313
409
if location is None:
314
410
if stored_loc is None:
315
411
raise BzrCommandError("No pull location known or specified.")
316
412
else:
317
print "Using last location: %s" % stored_loc
318
location = stored_loc
319
cache_root = tempfile.mkdtemp()
320
from bzrlib.branch import DivergedBranches
321
br_from = find_branch(location)
322
location = pull_loc(br_from)
323
old_revno = br_to.revno()
324
try:
325
from branch import find_cached_branch, DivergedBranches
326
br_from = find_cached_branch(location, cache_root)
327
location = pull_loc(br_from)
328
old_revno = br_to.revno()
413
print "Using saved location: %s" % stored_loc
414
location = stored_loc
415
416
if branch_to.get_parent() is None or remember:
417
branch_to.set_parent(location)
418
419
branch_from = Branch.open(location)
420
421
if revision is None:
422
rev_id = None
423
elif len(revision) == 1:
424
rev_id = revision[0].in_history(branch_from).rev_id
425
else:
426
raise BzrCommandError('bzr pull --revision takes one value.')
427
428
old_rh = branch_to.revision_history()
429
if tree_to is not None:
430
count = tree_to.pull(branch_from, overwrite, rev_id)
431
else:
432
count = branch_to.pull(branch_from, overwrite, rev_id)
433
note('%d revision(s) pulled.' % (count,))
434
435
if verbose:
436
new_rh = branch_to.revision_history()
437
if old_rh != new_rh:
438
# Something changed
439
from bzrlib.log import show_changed_revisions
440
show_changed_revisions(branch_to, old_rh, new_rh)
441
442
443
class cmd_push(Command):
444
"""Update a mirror of this branch.
445
446
The target branch will not have its working tree populated because this
447
is both expensive, and is not supported on remote file systems.
448
449
Some smart servers or protocols *may* put the working tree in place in
450
the future.
451
452
This command only works on branches that have not diverged. Branches are
453
considered diverged if the destination branch's most recent commit is one
454
that has not been merged (directly or indirectly) by the source branch.
455
456
If branches have diverged, you can use 'bzr push --overwrite' to replace
457
the other branch completely, discarding its unmerged changes.
458
459
If you want to ensure you have the different changes in the other branch,
460
do a merge (see bzr help merge) from the other branch, and commit that.
461
After that you will be able to do a push without '--overwrite'.
462
463
If there is no default push location set, the first push will set it.
464
After that, you can omit the location to use the default. To change the
465
default, use --remember.
466
"""
467
takes_options = ['remember', 'overwrite',
468
Option('create-prefix',
469
help='Create the path leading up to the branch '
470
'if it does not already exist')]
471
takes_args = ['location?']
472
473
def run(self, location=None, remember=False, overwrite=False,
474
create_prefix=False, verbose=False):
475
# FIXME: Way too big! Put this into a function called from the
476
# command.
477
from bzrlib.transport import get_transport
478
479
tree_from = WorkingTree.open_containing(u'.')[0]
480
br_from = tree_from.branch
481
stored_loc = tree_from.branch.get_push_location()
482
if location is None:
483
if stored_loc is None:
484
raise BzrCommandError("No push location known or specified.")
485
else:
486
print "Using saved location: %s" % stored_loc
487
location = stored_loc
488
if br_from.get_push_location() is None or remember:
489
br_from.set_push_location(location)
490
try:
491
dir_to = bzrlib.bzrdir.BzrDir.open(location)
492
br_to = dir_to.open_branch()
493
except NotBranchError:
494
# create a branch.
495
transport = get_transport(location).clone('..')
496
if not create_prefix:
497
try:
498
transport.mkdir(transport.relpath(location))
499
except NoSuchFile:
500
raise BzrCommandError("Parent directory of %s "
501
"does not exist." % location)
502
else:
503
current = transport.base
504
needed = [(transport, transport.relpath(location))]
505
while needed:
506
try:
507
transport, relpath = needed[-1]
508
transport.mkdir(relpath)
509
needed.pop()
510
except NoSuchFile:
511
new_transport = transport.clone('..')
512
needed.append((new_transport,
513
new_transport.relpath(transport.base)))
514
if new_transport.base == transport.base:
515
raise BzrCommandError("Could not create "
516
"path prefix.")
517
dir_to = br_from.bzrdir.clone(location)
518
br_to = dir_to.open_branch()
519
old_rh = br_to.revision_history()
520
try:
329
521
try:
330
br_to.update_revisions(br_from)
331
except DivergedBranches:
332
raise BzrCommandError("These branches have diverged."
333
" Try merge.")
334
335
merge(('.', -1), ('.', old_revno), check_clean=False)
336
if location != stored_loc:
337
br_to.controlfile("x-pull", "wb").write(location + "\n")
338
finally:
339
rmtree(cache_root)
522
tree_to = dir_to.open_workingtree()
523
except errors.NotLocalUrl:
524
# TODO: This should be updated for branches which don't have a
525
# working tree, as opposed to ones where we just couldn't
526
# update the tree.
527
warning('This transport does not update the working '
528
'tree of: %s' % (br_to.base,))
529
count = br_to.pull(br_from, overwrite)
530
except NoWorkingTree:
531
count = br_to.pull(br_from, overwrite)
532
else:
533
count = tree_to.pull(br_from, overwrite)
534
except DivergedBranches:
535
raise BzrCommandError("These branches have diverged."
536
" Try a merge then push with overwrite.")
537
note('%d revision(s) pushed.' % (count,))
340
538
539
if verbose:
540
new_rh = br_to.revision_history()
541
if old_rh != new_rh:
542
# Something changed
543
from bzrlib.log import show_changed_revisions
544
show_changed_revisions(br_to, old_rh, new_rh)
341
545
342
546
343
547
class cmd_branch(Command):
348
552
349
553
To retrieve the branch as of a particular revision, supply the --revision
350
554
parameter, as in "branch foo/bar -r 5".
555
556
--basis is to speed up branching from remote branches. When specified, it
557
copies all the file-contents, inventory and revision data from the basis
558
branch before copying anything from the remote branch.
351
559
"""
352
560
takes_args = ['from_location', 'to_location?']
353
takes_options = ['revision']
561
takes_options = ['revision', 'basis']
354
562
aliases = ['get', 'clone']
355
563
356
def run(self, from_location, to_location=None, revision=None):
357
from bzrlib.branch import copy_branch, find_cached_branch
358
import tempfile
359
import errno
360
from shutil import rmtree
361
cache_root = tempfile.mkdtemp()
362
try:
363
if revision is None:
364
revision = [None]
365
elif len(revision) > 1:
366
raise BzrCommandError(
367
'bzr branch --revision takes exactly 1 revision value')
368
try:
369
br_from = find_cached_branch(from_location, cache_root)
370
except OSError, e:
371
if e.errno == errno.ENOENT:
372
raise BzrCommandError('Source location "%s" does not'
373
' exist.' % to_location)
374
else:
375
raise
564
def run(self, from_location, to_location=None, revision=None, basis=None):
565
if revision is None:
566
revision = [None]
567
elif len(revision) > 1:
568
raise BzrCommandError(
569
'bzr branch --revision takes exactly 1 revision value')
570
try:
571
br_from = Branch.open(from_location)
572
except OSError, e:
573
if e.errno == errno.ENOENT:
574
raise BzrCommandError('Source location "%s" does not'
575
' exist.' % to_location)
576
else:
577
raise
578
br_from.lock_read()
579
try:
580
if basis is not None:
581
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
582
else:
583
basis_dir = None
584
if len(revision) == 1 and revision[0] is not None:
585
revision_id = revision[0].in_history(br_from)[1]
586
else:
587
# FIXME - wt.last_revision, fallback to branch, fall back to
588
# None or perhaps NULL_REVISION to mean copy nothing
589
# RBC 20060209
590
revision_id = br_from.last_revision()
376
591
if to_location is None:
377
592
to_location = os.path.basename(from_location.rstrip("/\\"))
593
name = None
594
else:
595
name = os.path.basename(to_location) + '\n'
378
596
try:
379
597
os.mkdir(to_location)
380
598
except OSError, e:
387
605
else:
388
606
raise
389
607
try:
390
copy_branch(br_from, to_location, revision[0])
608
# preserve whatever source format we have.
609
dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)
610
branch = dir.open_branch()
391
611
except bzrlib.errors.NoSuchRevision:
392
612
rmtree(to_location)
393
msg = "The branch %s has no revision %d." % (from_location, revision[0])
394
raise BzrCommandError(msg)
395
finally:
396
rmtree(cache_root)
613
msg = "The branch %s has no revision %s." % (from_location, revision[0])
614
raise BzrCommandError(msg)
615
except bzrlib.errors.UnlistableBranch:
616
rmtree(to_location)
617
msg = "The branch %s cannot be used as a --basis" % (basis,)
618
raise BzrCommandError(msg)
619
if name:
620
branch.control_files.put_utf8('branch-name', name)
621
622
note('Branched %d revision(s).' % branch.revno())
623
finally:
624
br_from.unlock()
625
626
627
class cmd_checkout(Command):
628
"""Create a new checkout of an existing branch.
629
630
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
631
the branch found in '.'. This is useful if you have removed the working tree
632
or if it was never created - i.e. if you pushed the branch to its current
633
location using SFTP.
634
635
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
636
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
637
638
To retrieve the branch as of a particular revision, supply the --revision
639
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
640
out of date [so you cannot commit] but it may be useful (i.e. to examine old
641
code.)
642
643
--basis is to speed up checking out from remote branches. When specified, it
644
uses the inventory and file contents from the basis branch in preference to the
645
branch being checked out. [Not implemented yet.]
646
"""
647
takes_args = ['branch_location?', 'to_location?']
648
takes_options = ['revision', # , 'basis']
649
Option('lightweight',
650
help="perform a lightweight checkout. Lightweight "
651
"checkouts depend on access to the branch for "
652
"every operation. Normal checkouts can perform "
653
"common operations like diff and status without "
654
"such access, and also support local commits."
655
),
656
]
657
658
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
659
lightweight=False):
660
if revision is None:
661
revision = [None]
662
elif len(revision) > 1:
663
raise BzrCommandError(
664
'bzr checkout --revision takes exactly 1 revision value')
665
if branch_location is None:
666
branch_location = bzrlib.osutils.getcwd()
667
to_location = branch_location
668
source = Branch.open(branch_location)
669
if len(revision) == 1 and revision[0] is not None:
670
revision_id = revision[0].in_history(source)[1]
671
else:
672
revision_id = None
673
if to_location is None:
674
to_location = os.path.basename(branch_location.rstrip("/\\"))
675
# if the source and to_location are the same,
676
# and there is no working tree,
677
# then reconstitute a branch
678
if (bzrlib.osutils.abspath(to_location) ==
679
bzrlib.osutils.abspath(branch_location)):
680
try:
681
source.bzrdir.open_workingtree()
682
except errors.NoWorkingTree:
683
source.bzrdir.create_workingtree()
684
return
685
try:
686
os.mkdir(to_location)
687
except OSError, e:
688
if e.errno == errno.EEXIST:
689
raise BzrCommandError('Target directory "%s" already'
690
' exists.' % to_location)
691
if e.errno == errno.ENOENT:
692
raise BzrCommandError('Parent of "%s" does not exist.' %
693
to_location)
694
else:
695
raise
696
old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
697
bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
698
try:
699
if lightweight:
700
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
701
bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
702
else:
703
checkout_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(
704
to_location, force_new_tree=False)
705
checkout = checkout_branch.bzrdir
706
checkout_branch.bind(source)
707
if revision_id is not None:
708
rh = checkout_branch.revision_history()
709
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
710
checkout.create_workingtree(revision_id)
711
finally:
712
bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
397
713
398
714
399
715
class cmd_renames(Command):
400
716
"""Show list of renamed files.
401
402
TODO: Option to show renames between two historical versions.
403
404
TODO: Only show renames under dir, rather than in the whole branch.
405
717
"""
718
# TODO: Option to show renames between two historical versions.
719
720
# TODO: Only show renames under dir, rather than in the whole branch.
406
721
takes_args = ['dir?']
407
722
408
def run(self, dir='.'):
409
b = find_branch(dir)
410
old_inv = b.basis_tree().inventory
411
new_inv = b.read_working_inventory()
723
@display_command
724
def run(self, dir=u'.'):
725
tree = WorkingTree.open_containing(dir)[0]
726
old_inv = tree.basis_tree().inventory
727
new_inv = tree.read_working_inventory()
412
728
413
729
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
414
730
renames.sort()
416
732
print "%s => %s" % (old_name, new_name)
417
733
418
734
735
class cmd_update(Command):
736
"""Update a tree to have the latest code committed to its branch.
737
738
This will perform a merge into the working tree, and may generate
739
conflicts. If you have any local changes, you will still
740
need to commit them after the update for the update to be complete.
741
742
If you want to discard your local changes, you can just do a
743
'bzr revert' instead of 'bzr commit' after the update.
744
"""
745
takes_args = ['dir?']
746
747
def run(self, dir='.'):
748
tree = WorkingTree.open_containing(dir)[0]
749
tree.lock_write()
750
try:
751
if tree.last_revision() == tree.branch.last_revision():
752
# may be up to date, check master too.
753
master = tree.branch.get_master_branch()
754
if master is None or master.last_revision == tree.last_revision():
755
note("Tree is up to date.")
756
return
757
conflicts = tree.update()
758
note('Updated to revision %d.' %
759
(tree.branch.revision_id_to_revno(tree.last_revision()),))
760
if conflicts != 0:
761
return 1
762
else:
763
return 0
764
finally:
765
tree.unlock()
766
767
419
768
class cmd_info(Command):
420
769
"""Show statistical information about a branch."""
421
770
takes_args = ['branch?']
771
takes_options = ['verbose']
422
772
423
def run(self, branch=None):
424
import info
425
426
b = find_branch(branch)
427
info.show_info(b)
773
@display_command
774
def run(self, branch=None, verbose=False):
775
import bzrlib.info
776
bzrlib.info.show_bzrdir_info(bzrdir.BzrDir.open_containing(branch)[0],
777
verbose=verbose)
428
778
429
779
430
780
class cmd_remove(Command):
435
785
"""
436
786
takes_args = ['file+']
437
787
takes_options = ['verbose']
788
aliases = ['rm']
438
789
439
790
def run(self, file_list, verbose=False):
440
b = find_branch(file_list[0])
441
b.remove([b.relpath(f) for f in file_list], verbose=verbose)
791
tree, file_list = tree_files(file_list)
792
tree.remove(file_list, verbose=verbose)
442
793
443
794
444
795
class cmd_file_id(Command):
450
801
"""
451
802
hidden = True
452
803
takes_args = ['filename']
804
@display_command
453
805
def run(self, filename):
454
b = find_branch(filename)
455
i = b.inventory.path2id(b.relpath(filename))
806
tree, relpath = WorkingTree.open_containing(filename)
807
i = tree.inventory.path2id(relpath)
456
808
if i == None:
457
809
raise BzrError("%r is not a versioned file" % filename)
458
810
else:
466
818
starting at the branch root."""
467
819
hidden = True
468
820
takes_args = ['filename']
821
@display_command
469
822
def run(self, filename):
470
b = find_branch(filename)
471
inv = b.inventory
472
fid = inv.path2id(b.relpath(filename))
823
tree, relpath = WorkingTree.open_containing(filename)
824
inv = tree.inventory
825
fid = inv.path2id(relpath)
473
826
if fid == None:
474
827
raise BzrError("%r is not a versioned file" % filename)
475
828
for fip in inv.get_idpath(fid):
476
829
print fip
477
830
478
831
832
class cmd_reconcile(Command):
833
"""Reconcile bzr metadata in a branch.
834
835
This can correct data mismatches that may have been caused by
836
previous ghost operations or bzr upgrades. You should only
837
need to run this command if 'bzr check' or a bzr developer
838
advises you to run it.
839
840
If a second branch is provided, cross-branch reconciliation is
841
also attempted, which will check that data like the tree root
842
id which was not present in very early bzr versions is represented
843
correctly in both branches.
844
845
At the same time it is run it may recompress data resulting in
846
a potential saving in disk space or performance gain.
847
848
The branch *MUST* be on a listable system such as local disk or sftp.
849
"""
850
takes_args = ['branch?']
851
852
def run(self, branch="."):
853
from bzrlib.reconcile import reconcile
854
dir = bzrlib.bzrdir.BzrDir.open(branch)
855
reconcile(dir)
856
857
479
858
class cmd_revision_history(Command):
480
859
"""Display list of revision ids on this branch."""
481
860
hidden = True
861
@display_command
482
862
def run(self):
483
for patchid in find_branch('.').revision_history():
863
branch = WorkingTree.open_containing(u'.')[0].branch
864
for patchid in branch.revision_history():
484
865
print patchid
485
866
486
867
487
class cmd_directories(Command):
488
"""Display list of versioned directories in this branch."""
868
class cmd_ancestry(Command):
869
"""List all revisions merged into this branch."""
870
hidden = True
871
@display_command
489
872
def run(self):
490
for name, ie in find_branch('.').read_working_inventory().directories():
491
if name == '':
492
print '.'
493
else:
494
print name
873
tree = WorkingTree.open_containing(u'.')[0]
874
b = tree.branch
875
# FIXME. should be tree.last_revision
876
for revision_id in b.repository.get_ancestry(b.last_revision()):
877
print revision_id
495
878
496
879
497
880
class cmd_init(Command):
503
886
Recipe for importing a tree of files:
504
887
cd ~/project
505
888
bzr init
506
bzr add -v .
889
bzr add .
507
890
bzr status
508
891
bzr commit -m 'imported project'
509
892
"""
510
def run(self):
893
takes_args = ['location?']
894
takes_options = [
895
Option('format',
896
help='Create a specific format rather than the'
897
' current default format. Currently this '
898
' option only accepts "metadir"',
899
type=get_format_type),
900
]
901
def run(self, location=None, format=None):
511
902
from bzrlib.branch import Branch
512
Branch('.', init=True)
903
if location is None:
904
location = u'.'
905
else:
906
# The path has to exist to initialize a
907
# branch inside of it.
908
# Just using os.mkdir, since I don't
909
# believe that we want to create a bunch of
910
# locations if the user supplies an extended path
911
if not os.path.exists(location):
912
os.mkdir(location)
913
try:
914
existing = bzrdir.BzrDir.open(location)
915
except NotBranchError:
916
bzrdir.BzrDir.create_branch_convenience(location, format=format)
917
else:
918
try:
919
existing.open_branch()
920
except NotBranchError:
921
existing.create_branch()
922
existing.create_workingtree()
923
else:
924
raise errors.AlreadyBranchError(location)
925
926
927
class cmd_init_repository(Command):
928
"""Create a shared repository to hold branches.
929
930
New branches created under the repository directory will store their revisions
931
in the repository, not in the branch directory, if the branch format supports
932
shared storage.
933
934
example:
935
bzr init-repo repo
936
bzr init --format=metadir repo/trunk
937
cd repo/trunk
938
(add files here)
939
"""
940
takes_args = ["location"]
941
takes_options = [Option('format',
942
help='Use a specific format rather than the'
943
' current default format. Currently this'
944
' option only accepts "metadir" and "knit"'
945
' WARNING: the knit format is currently unstable'
946
' and only for experimental use.',
947
type=get_format_type),
948
Option('trees',
949
help='Allows branches in repository to have'
950
' a working tree')]
951
aliases = ["init-repo"]
952
def run(self, location, format=None, trees=False):
953
from bzrlib.bzrdir import BzrDirMetaFormat1
954
from bzrlib.transport import get_transport
955
if format is None:
956
format = BzrDirMetaFormat1()
957
transport = get_transport(location)
958
if not transport.has('.'):
959
transport.mkdir('')
960
newdir = format.initialize_on_transport(transport)
961
repo = newdir.create_repository(shared=True)
962
repo.set_make_working_trees(trees)
513
963
514
964
515
965
class cmd_diff(Command):
518
968
If files are listed, only the changes in those files are listed.
519
969
Otherwise, all changes for the tree are listed.
520
970
521
TODO: Allow diff across branches.
522
523
TODO: Option to use external diff command; could be GNU diff, wdiff,
524
or a graphical diff.
525
526
TODO: Python difflib is not exactly the same as unidiff; should
527
either fix it up or prefer to use an external diff.
528
529
TODO: If a directory is given, diff everything under that.
530
531
TODO: Selected-file diff is inefficient and doesn't show you
532
deleted files.
533
534
TODO: This probably handles non-Unix newlines poorly.
535
536
971
examples:
537
972
bzr diff
538
973
bzr diff -r1
539
bzr diff -r1:2
974
bzr diff -r1..2
540
975
"""
976
# TODO: Allow diff across branches.
977
# TODO: Option to use external diff command; could be GNU diff, wdiff,
978
# or a graphical diff.
979
980
# TODO: Python difflib is not exactly the same as unidiff; should
981
# either fix it up or prefer to use an external diff.
982
983
# TODO: If a directory is given, diff everything under that.
984
985
# TODO: Selected-file diff is inefficient and doesn't show you
986
# deleted files.
987
988
# TODO: This probably handles non-Unix newlines poorly.
541
989
542
990
takes_args = ['file*']
543
991
takes_options = ['revision', 'diff-options']
544
992
aliases = ['di', 'dif']
545
993
994
@display_command
546
995
def run(self, revision=None, file_list=None, diff_options=None):
547
from bzrlib.diff import show_diff
548
549
if file_list:
550
b = find_branch(file_list[0])
551
file_list = [b.relpath(f) for f in file_list]
552
if file_list == ['']:
553
# just pointing to top-of-tree
554
file_list = None
555
else:
556
b = find_branch('.')
557
996
from bzrlib.diff import diff_cmd_helper, show_diff_trees
997
try:
998
tree1, file_list = internal_tree_files(file_list)
999
tree2 = None
1000
b = None
1001
b2 = None
1002
except FileInWrongBranch:
1003
if len(file_list) != 2:
1004
raise BzrCommandError("Files are in different branches")
1005
1006
tree1, file1 = WorkingTree.open_containing(file_list[0])
1007
tree2, file2 = WorkingTree.open_containing(file_list[1])
1008
if file1 != "" or file2 != "":
1009
# FIXME diff those two files. rbc 20051123
1010
raise BzrCommandError("Files are in different branches")
1011
file_list = None
558
1012
if revision is not None:
559
if len(revision) == 1:
560
show_diff(b, revision[0], specific_files=file_list,
561
external_diff_options=diff_options)
1013
if tree2 is not None:
1014
raise BzrCommandError("Can't specify -r with two branches")
1015
if (len(revision) == 1) or (revision[1].spec is None):
1016
return diff_cmd_helper(tree1, file_list, diff_options,
1017
revision[0])
562
1018
elif len(revision) == 2:
563
show_diff(b, revision[0], specific_files=file_list,
564
external_diff_options=diff_options,
565
revision2=revision[1])
1019
return diff_cmd_helper(tree1, file_list, diff_options,
1020
revision[0], revision[1])
566
1021
else:
567
1022
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
568
1023
else:
569
show_diff(b, None, specific_files=file_list,
570
external_diff_options=diff_options)
571
572
1024
if tree2 is not None:
1025
return show_diff_trees(tree1, tree2, sys.stdout,
1026
specific_files=file_list,
1027
external_diff_options=diff_options)
1028
else:
1029
return diff_cmd_helper(tree1, file_list, diff_options)
573
1030
574
1031
575
1032
class cmd_deleted(Command):
576
1033
"""List files deleted in the working tree.
577
578
TODO: Show files deleted since a previous revision, or between two revisions.
579
1034
"""
1035
# TODO: Show files deleted since a previous revision, or
1036
# between two revisions.
1037
# TODO: Much more efficient way to do this: read in new
1038
# directories with readdir, rather than stating each one. Same
1039
# level of effort but possibly much less IO. (Or possibly not,
1040
# if the directories are very large...)
1041
@display_command
580
1042
def run(self, show_ids=False):
581
b = find_branch('.')
582
old = b.basis_tree()
583
new = b.working_tree()
584
585
## TODO: Much more efficient way to do this: read in new
586
## directories with readdir, rather than stating each one. Same
587
## level of effort but possibly much less IO. (Or possibly not,
588
## if the directories are very large...)
589
1043
tree = WorkingTree.open_containing(u'.')[0]
1044
old = tree.basis_tree()
590
1045
for path, ie in old.inventory.iter_entries():
591
if not new.has_id(ie.file_id):
1046
if not tree.has_id(ie.file_id):
592
1047
if show_ids:
593
1048
print '%-50s %s' % (path, ie.file_id)
594
1049
else:
598
1053
class cmd_modified(Command):
599
1054
"""List files modified in working tree."""
600
1055
hidden = True
1056
@display_command
601
1057
def run(self):
602
1058
from bzrlib.delta import compare_trees
603
1059
604
b = find_branch('.')
605
td = compare_trees(b.basis_tree(), b.working_tree())
1060
tree = WorkingTree.open_containing(u'.')[0]
1061
td = compare_trees(tree.basis_tree(), tree)
606
1062
607
for path, id, kind in td.modified:
1063
for path, id, kind, text_modified, meta_modified in td.modified:
608
1064
print path
609
1065
610
1066
612
1068
class cmd_added(Command):
613
1069
"""List files added in working tree."""
614
1070
hidden = True
1071
@display_command
615
1072
def run(self):
616
b = find_branch('.')
617
wt = b.working_tree()
618
basis_inv = b.basis_tree().inventory
1073
wt = WorkingTree.open_containing(u'.')[0]
1074
basis_inv = wt.basis_tree().inventory
619
1075
inv = wt.inventory
620
1076
for file_id in inv:
621
1077
if file_id in basis_inv:
622
1078
continue
623
1079
path = inv.id2path(file_id)
624
if not os.access(b.abspath(path), os.F_OK):
1080
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
625
1081
continue
626
1082
print path
627
1083
633
1089
The root is the nearest enclosing directory with a .bzr control
634
1090
directory."""
635
1091
takes_args = ['filename?']
1092
@display_command
636
1093
def run(self, filename=None):
637
1094
"""Print the branch root."""
638
b = find_branch(filename)
639
print getattr(b, 'base', None) or getattr(b, 'baseurl')
1095
tree = WorkingTree.open_containing(filename)[0]
1096
print tree.basedir
640
1097
641
1098
642
1099
class cmd_log(Command):
643
"""Show log of this branch.
644
645
To request a range of logs, you can use the command -r begin:end
646
-r revision requests a specific revision, -r :end or -r begin: are
1100
"""Show log of a branch, file, or directory.
1101
1102
By default show the log of the branch containing the working directory.
1103
1104
To request a range of logs, you can use the command -r begin..end
1105
-r revision requests a specific revision, -r ..end or -r begin.. are
647
1106
also valid.
648
1107
649
--message allows you to give a regular expression, which will be evaluated
650
so that only matching entries will be displayed.
651
652
TODO: Make --revision support uuid: and hash: [future tag:] notation.
653
1108
examples:
1109
bzr log
1110
bzr log foo.c
1111
bzr log -r -10.. http://server/branch
654
1112
"""
655
1113
656
takes_args = ['filename?']
657
takes_options = ['forward', 'timezone', 'verbose', 'show-ids', 'revision',
658
'long', 'message', 'short',]
659
660
def run(self, filename=None, timezone='original',
1114
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
1115
1116
takes_args = ['location?']
1117
takes_options = [Option('forward',
1118
help='show from oldest to newest'),
1119
'timezone',
1120
Option('verbose',
1121
help='show files changed in each revision'),
1122
'show-ids', 'revision',
1123
'log-format',
1124
'line', 'long',
1125
Option('message',
1126
help='show revisions whose message matches this regexp',
1127
type=str),
1128
'short',
1129
]
1130
@display_command
1131
def run(self, location=None, timezone='original',
661
1132
verbose=False,
662
1133
show_ids=False,
663
1134
forward=False,
664
1135
revision=None,
1136
log_format=None,
665
1137
message=None,
666
1138
long=False,
667
short=False):
1139
short=False,
1140
line=False):
668
1141
from bzrlib.log import log_formatter, show_log
669
1142
import codecs
670
1143
assert message is None or isinstance(message, basestring), \
1144
"invalid message argument %r" % message
671
1145
direction = (forward and 'forward') or 'reverse'
672
1146
673
if filename:
674
b = find_branch(filename)
675
fp = b.relpath(filename)
676
if fp:
677
file_id = b.read_working_inventory().path2id(fp)
678
else:
679
file_id = None # points to branch root
1147
# log everything
1148
file_id = None
1149
if location:
1150
# find the file id to log:
1151
1152
dir, fp = bzrdir.BzrDir.open_containing(location)
1153
b = dir.open_branch()
1154
if fp != '':
1155
try:
1156
# might be a tree:
1157
inv = dir.open_workingtree().inventory
1158
except (errors.NotBranchError, errors.NotLocalUrl):
1159
# either no tree, or is remote.
1160
inv = b.basis_tree().inventory
1161
file_id = inv.path2id(fp)
680
1162
else:
681
b = find_branch('.')
682
file_id = None
1163
# local dir only
1164
# FIXME ? log the current subdir only RBC 20060203
1165
dir, relpath = bzrdir.BzrDir.open_containing('.')
1166
b = dir.open_branch()
683
1167
684
1168
if revision is None:
685
1169
rev1 = None
686
1170
rev2 = None
687
1171
elif len(revision) == 1:
688
rev1 = rev2 = b.get_revision_info(revision[0])[0]
1172
rev1 = rev2 = revision[0].in_history(b).revno
689
1173
elif len(revision) == 2:
690
rev1 = b.get_revision_info(revision[0])[0]
691
rev2 = b.get_revision_info(revision[1])[0]
1174
if revision[0].spec is None:
1175
# missing begin-range means first revision
1176
rev1 = 1
1177
else:
1178
rev1 = revision[0].in_history(b).revno
1179
1180
if revision[1].spec is None:
1181
# missing end-range means last known revision
1182
rev2 = b.revno()
1183
else:
1184
rev2 = revision[1].in_history(b).revno
692
1185
else:
693
1186
raise BzrCommandError('bzr log --revision takes one or two values.')
694
1187
695
if rev1 == 0:
696
rev1 = None
697
if rev2 == 0:
698
rev2 = None
1188
# By this point, the revision numbers are converted to the +ve
1189
# form if they were supplied in the -ve form, so we can do
1190
# this comparison in relative safety
1191
if rev1 > rev2:
1192
(rev2, rev1) = (rev1, rev2)
699
1193
700
mutter('encoding log as %r' % bzrlib.user_encoding)
1194
mutter('encoding log as %r', bzrlib.user_encoding)
701
1195
702
1196
# use 'replace' so that we don't abort if trying to write out
703
1197
# in e.g. the default C locale.
704
1198
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
705
1199
706
if not short:
707
log_format = 'long'
708
else:
709
log_format = 'short'
1200
if (log_format == None):
1201
default = bzrlib.config.BranchConfig(b).log_format()
1202
log_format = get_log_format(long=long, short=short, line=line, default=default)
1203
710
1204
lf = log_formatter(log_format,
711
1205
show_ids=show_ids,
712
1206
to_file=outf,
722
1216
search=message)
723
1217
724
1218
1219
def get_log_format(long=False, short=False, line=False, default='long'):
1220
log_format = default
1221
if long:
1222
log_format = 'long'
1223
if short:
1224
log_format = 'short'
1225
if line:
1226
log_format = 'line'
1227
return log_format
1228
725
1229
726
1230
class cmd_touching_revisions(Command):
727
1231
"""Return revision-ids which affected a particular file.
729
1233
A more user-friendly interface is "bzr log FILE"."""
730
1234
hidden = True
731
1235
takes_args = ["filename"]
1236
@display_command
732
1237
def run(self, filename):
733
b = find_branch(filename)
734
inv = b.read_working_inventory()
735
file_id = inv.path2id(b.relpath(filename))
1238
tree, relpath = WorkingTree.open_containing(filename)
1239
b = tree.branch
1240
inv = tree.read_working_inventory()
1241
file_id = inv.path2id(relpath)
736
1242
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
737
1243
print "%6d %s" % (revno, what)
738
1244
739
1245
740
1246
class cmd_ls(Command):
741
1247
"""List files in a tree.
742
743
TODO: Take a revision or remote path and list that tree instead.
744
1248
"""
1249
# TODO: Take a revision or remote path and list that tree instead.
745
1250
hidden = True
746
def run(self, revision=None, verbose=False):
747
b = find_branch('.')
748
if revision == None:
749
tree = b.working_tree()
750
else:
751
tree = b.revision_tree(b.lookup_revision(revision))
752
753
for fp, fc, kind, fid in tree.list_files():
754
if verbose:
755
if kind == 'directory':
756
kindch = '/'
757
elif kind == 'file':
758
kindch = ''
1251
takes_options = ['verbose', 'revision',
1252
Option('non-recursive',
1253
help='don\'t recurse into sub-directories'),
1254
Option('from-root',
1255
help='Print all paths from the root of the branch.'),
1256
Option('unknown', help='Print unknown files'),
1257
Option('versioned', help='Print versioned files'),
1258
Option('ignored', help='Print ignored files'),
1259
1260
Option('null', help='Null separate the files'),
1261
]
1262
@display_command
1263
def run(self, revision=None, verbose=False,
1264
non_recursive=False, from_root=False,
1265
unknown=False, versioned=False, ignored=False,
1266
null=False):
1267
1268
if verbose and null:
1269
raise BzrCommandError('Cannot set both --verbose and --null')
1270
all = not (unknown or versioned or ignored)
1271
1272
selection = {'I':ignored, '?':unknown, 'V':versioned}
1273
1274
tree, relpath = WorkingTree.open_containing(u'.')
1275
if from_root:
1276
relpath = u''
1277
elif relpath:
1278
relpath += '/'
1279
if revision is not None:
1280
tree = tree.branch.repository.revision_tree(
1281
revision[0].in_history(tree.branch).rev_id)
1282
for fp, fc, kind, fid, entry in tree.list_files():
1283
if fp.startswith(relpath):
1284
fp = fp[len(relpath):]
1285
if non_recursive and '/' in fp:
1286
continue
1287
if not all and not selection[fc]:
1288
continue
1289
if verbose:
1290
kindch = entry.kind_character()
1291
print '%-8s %s%s' % (fc, fp, kindch)
1292
elif null:
1293
sys.stdout.write(fp)
1294
sys.stdout.write('\0')
1295
sys.stdout.flush()
759
1296
else:
760
kindch = '???'
761
762
print '%-8s %s%s' % (fc, fp, kindch)
763
else:
764
print fp
765
1297
print fp
766
1298
767
1299
768
1300
class cmd_unknowns(Command):
769
1301
"""List unknown files."""
1302
@display_command
770
1303
def run(self):
771
1304
from bzrlib.osutils import quotefn
772
for f in find_branch('.').unknowns():
1305
for f in WorkingTree.open_containing(u'.')[0].unknowns():
773
1306
print quotefn(f)
774
1307
775
1308
776
777
1309
class cmd_ignore(Command):
778
1310
"""Ignore a command or pattern.
779
1311
780
1312
To remove patterns from the ignore list, edit the .bzrignore file.
781
1313
782
1314
If the pattern contains a slash, it is compared to the whole path
783
from the branch root. Otherwise, it is comapred to only the last
784
component of the path.
1315
from the branch root. Otherwise, it is compared to only the last
1316
component of the path. To match a file only in the root directory,
1317
prepend './'.
785
1318
786
1319
Ignore patterns are case-insensitive on case-insensitive systems.
787
1320
791
1324
bzr ignore ./Makefile
792
1325
bzr ignore '*.class'
793
1326
"""
1327
# TODO: Complain if the filename is absolute
794
1328
takes_args = ['name_pattern']
795
1329
796
1330
def run(self, name_pattern):
797
1331
from bzrlib.atomicfile import AtomicFile
798
1332
import os.path
799
1333
800
b = find_branch('.')
801
ifn = b.abspath('.bzrignore')
1334
tree, relpath = WorkingTree.open_containing(u'.')
1335
ifn = tree.abspath('.bzrignore')
802
1336
803
1337
if os.path.exists(ifn):
804
1338
f = open(ifn, 'rt')
823
1357
finally:
824
1358
f.close()
825
1359
826
inv = b.working_tree().inventory
1360
inv = tree.inventory
827
1361
if inv.path2id('.bzrignore'):
828
1362
mutter('.bzrignore is already versioned')
829
1363
else:
830
1364
mutter('need to make new .bzrignore file versioned')
831
b.add(['.bzrignore'])
832
1365
tree.add(['.bzrignore'])
833
1366
834
1367
835
1368
class cmd_ignored(Command):
836
1369
"""List ignored files and the patterns that matched them.
837
1370
838
1371
See also: bzr ignore"""
1372
@display_command
839
1373
def run(self):
840
tree = find_branch('.').working_tree()
841
for path, file_class, kind, file_id in tree.list_files():
1374
tree = WorkingTree.open_containing(u'.')[0]
1375
for path, file_class, kind, file_id, entry in tree.list_files():
842
1376
if file_class != 'I':
843
1377
continue
844
1378
## XXX: Slightly inefficient since this was already calculated
855
1389
hidden = True
856
1390
takes_args = ['revno']
857
1391
1392
@display_command
858
1393
def run(self, revno):
859
1394
try:
860
1395
revno = int(revno)
861
1396
except ValueError:
862
1397
raise BzrCommandError("not a valid revision-number: %r" % revno)
863
1398
864
print find_branch('.').lookup_revision(revno)
1399
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
865
1400
866
1401
867
1402
class cmd_export(Command):
874
1409
is found exports to a directory (equivalent to --format=dir).
875
1410
876
1411
Root may be the top directory for tar, tgz and tbz2 formats. If none
877
is given, the top directory will be the root name of the file."""
878
# TODO: list known exporters
1412
is given, the top directory will be the root name of the file.
1413
1414
Note: export of tree with non-ascii filenames to zip is not supported.
1415
1416
Supported formats Autodetected by extension
1417
----------------- -------------------------
1418
dir -
1419
tar .tar
1420
tbz2 .tar.bz2, .tbz2
1421
tgz .tar.gz, .tgz
1422
zip .zip
1423
"""
879
1424
takes_args = ['dest']
880
1425
takes_options = ['revision', 'format', 'root']
881
1426
def run(self, dest, revision=None, format=None, root=None):
882
1427
import os.path
883
b = find_branch('.')
1428
from bzrlib.export import export
1429
tree = WorkingTree.open_containing(u'.')[0]
1430
b = tree.branch
884
1431
if revision is None:
885
rev_id = b.last_patch()
1432
# should be tree.last_revision FIXME
1433
rev_id = b.last_revision()
886
1434
else:
887
1435
if len(revision) != 1:
888
1436
raise BzrError('bzr export --revision takes exactly 1 argument')
889
revno, rev_id = b.get_revision_info(revision[0])
890
t = b.revision_tree(rev_id)
891
root, ext = os.path.splitext(dest)
892
if not format:
893
if ext in (".tar",):
894
format = "tar"
895
elif ext in (".gz", ".tgz"):
896
format = "tgz"
897
elif ext in (".bz2", ".tbz2"):
898
format = "tbz2"
899
else:
900
format = "dir"
901
t.export(dest, format, root)
1437
rev_id = revision[0].in_history(b).rev_id
1438
t = b.repository.revision_tree(rev_id)
1439
try:
1440
export(t, dest, format, root)
1441
except errors.NoSuchExportFormat, e:
1442
raise BzrCommandError('Unsupported export format: %s' % e.format)
902
1443
903
1444
904
1445
class cmd_cat(Command):
907
1448
takes_options = ['revision']
908
1449
takes_args = ['filename']
909
1450
1451
@display_command
910
1452
def run(self, filename, revision=None):
911
if revision == None:
912
raise BzrCommandError("bzr cat requires a revision number")
913
elif len(revision) != 1:
1453
if revision is not None and len(revision) != 1:
914
1454
raise BzrCommandError("bzr cat --revision takes exactly one number")
915
b = find_branch('.')
916
b.print_file(b.relpath(filename), revision[0])
1455
tree = None
1456
try:
1457
tree, relpath = WorkingTree.open_containing(filename)
1458
b = tree.branch
1459
except NotBranchError:
1460
pass
1461
1462
if tree is None:
1463
b, relpath = Branch.open_containing(filename)
1464
if revision is None:
1465
revision_id = b.last_revision()
1466
else:
1467
revision_id = revision[0].in_history(b).rev_id
1468
b.print_file(relpath, revision_id)
917
1469
918
1470
919
1471
class cmd_local_time_offset(Command):
920
1472
"""Show the offset in seconds from GMT to local time."""
921
1473
hidden = True
1474
@display_command
922
1475
def run(self):
923
1476
print bzrlib.osutils.local_time_offset()
924
1477
936
1489
A selected-file commit may fail in some cases where the committed
937
1490
tree would be invalid, such as trying to commit a file in a
938
1491
newly-added directory that is not itself committed.
939
940
TODO: Run hooks on tree to-be-committed, and after commit.
941
942
TODO: Strict commit that fails if there are unknown or deleted files.
943
1492
"""
1493
# TODO: Run hooks on tree to-be-committed, and after commit.
1494
1495
# TODO: Strict commit that fails if there are deleted files.
1496
# (what does "deleted files" mean ??)
1497
1498
# TODO: Give better message for -s, --summary, used by tla people
1499
1500
# XXX: verbose currently does nothing
1501
944
1502
takes_args = ['selected*']
945
takes_options = ['message', 'file', 'verbose', 'unchanged']
1503
takes_options = ['message', 'verbose',
1504
Option('unchanged',
1505
help='commit even if nothing has changed'),
1506
Option('file', type=str,
1507
argname='msgfile',
1508
help='file containing commit message'),
1509
Option('strict',
1510
help="refuse to commit if there are unknown "
1511
"files in the working tree."),
1512
Option('local',
1513
help="perform a local only commit in a bound "
1514
"branch. Such commits are not pushed to "
1515
"the master branch until a normal commit "
1516
"is performed."
1517
),
1518
]
946
1519
aliases = ['ci', 'checkin']
947
1520
948
# TODO: Give better message for -s, --summary, used by tla people
949
950
# XXX: verbose currently does nothing
951
952
1521
def run(self, message=None, file=None, verbose=True, selected_list=None,
953
unchanged=False):
954
from bzrlib.errors import PointlessCommit
955
from bzrlib.msgeditor import edit_commit_message
956
from bzrlib.status import show_status
957
from cStringIO import StringIO
958
959
b = find_branch('.')
960
if selected_list:
961
selected_list = [b.relpath(s) for s in selected_list]
962
963
if not message and not file:
964
catcher = StringIO()
965
show_status(b, specific_files=selected_list,
966
to_file=catcher)
967
message = edit_commit_message(catcher.getvalue())
968
1522
unchanged=False, strict=False, local=False):
1523
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1524
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1525
StrictCommitFailed)
1526
from bzrlib.msgeditor import edit_commit_message, \
1527
make_commit_message_template
1528
from tempfile import TemporaryFile
1529
import codecs
1530
1531
# TODO: Need a blackbox test for invoking the external editor; may be
1532
# slightly problematic to run this cross-platform.
1533
1534
# TODO: do more checks that the commit will succeed before
1535
# spending the user's valuable time typing a commit message.
1536
#
1537
# TODO: if the commit *does* happen to fail, then save the commit
1538
# message to a temporary file where it can be recovered
1539
tree, selected_list = tree_files(selected_list)
1540
if local and not tree.branch.get_bound_location():
1541
raise errors.LocalRequiresBoundBranch()
1542
if message is None and not file:
1543
template = make_commit_message_template(tree, selected_list)
1544
message = edit_commit_message(template)
969
1545
if message is None:
970
1546
raise BzrCommandError("please specify a commit message"
971
1547
" with either --message or --file")
976
1552
import codecs
977
1553
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
978
1554
1555
if message == "":
1556
raise BzrCommandError("empty commit message specified")
1557
1558
if verbose:
1559
reporter = ReportCommitToLog()
1560
else:
1561
reporter = NullCommitReporter()
1562
979
1563
try:
980
b.commit(message,
981
specific_files=selected_list,
982
allow_pointless=unchanged)
1564
tree.commit(message, specific_files=selected_list,
1565
allow_pointless=unchanged, strict=strict, local=local,
1566
reporter=reporter)
983
1567
except PointlessCommit:
984
1568
# FIXME: This should really happen before the file is read in;
985
1569
# perhaps prepare the commit; get the message; then actually commit
986
1570
raise BzrCommandError("no changes to commit",
987
1571
["use --unchanged to commit anyhow"])
1572
except ConflictsInTree:
1573
raise BzrCommandError("Conflicts detected in working tree. "
1574
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1575
except StrictCommitFailed:
1576
raise BzrCommandError("Commit refused because there are unknown "
1577
"files in the working tree.")
1578
except errors.BoundBranchOutOfDate, e:
1579
raise BzrCommandError(str(e)
1580
+ ' Either unbind, update, or'
1581
' pass --local to commit.')
988
1582
989
1583
990
1584
class cmd_check(Command):
992
1586
993
1587
This command checks various invariants about the branch storage to
994
1588
detect data corruption or bzr bugs.
995
996
If given the --update flag, it will update some optional fields
997
to help ensure data consistency.
998
1589
"""
999
takes_args = ['dir?']
1590
takes_args = ['branch?']
1591
takes_options = ['verbose']
1000
1592
1001
def run(self, dir='.'):
1593
def run(self, branch=None, verbose=False):
1002
1594
from bzrlib.check import check
1003
1004
check(find_branch(dir))
1595
if branch is None:
1596
tree = WorkingTree.open_containing()[0]
1597
branch = tree.branch
1598
else:
1599
branch = Branch.open(branch)
1600
check(branch, verbose)
1005
1601
1006
1602
1007
1603
class cmd_scan_cache(Command):
1009
1605
def run(self):
1010
1606
from bzrlib.hashcache import HashCache
1011
1607
1012
c = HashCache('.')
1608
c = HashCache(u'.')
1013
1609
c.read()
1014
1610
c.scan()
1015
1611
1021
1617
1022
1618
if c.needs_write:
1023
1619
c.write()
1024
1025
1620
1026
1621
1027
1622
class cmd_upgrade(Command):
1028
1623
"""Upgrade branch storage to current format.
1029
1624
1030
1625
The check command or bzr developers may sometimes advise you to run
1031
this command.
1626
this command. When the default format has changed you may also be warned
1627
during other operations to upgrade.
1032
1628
"""
1033
takes_args = ['dir?']
1034
1035
def run(self, dir='.'):
1629
takes_args = ['url?']
1630
takes_options = [
1631
Option('format',
1632
help='Upgrade to a specific format rather than the'
1633
' current default format. Currently this'
1634
' option only accepts "metadir" and "knit".'
1635
' WARNING: the knit format is currently'
1636
' unstable and only for experimental use.',
1637
type=get_format_type),
1638
]
1639
1640
1641
def run(self, url='.', format=None):
1036
1642
from bzrlib.upgrade import upgrade
1037
upgrade(find_branch(dir))
1038
1643
upgrade(url, format)
1039
1644
1040
1645
1041
1646
class cmd_whoami(Command):
1042
1647
"""Show bzr user id."""
1043
1648
takes_options = ['email']
1044
1649
1650
@display_command
1045
1651
def run(self, email=False):
1046
1652
try:
1047
b = bzrlib.branch.find_branch('.')
1048
except:
1049
b = None
1653
b = WorkingTree.open_containing(u'.')[0].branch
1654
config = bzrlib.config.BranchConfig(b)
1655
except NotBranchError:
1656
config = bzrlib.config.GlobalConfig()
1050
1657
1051
1658
if email:
1052
print bzrlib.osutils.user_email(b)
1053
else:
1054
print bzrlib.osutils.username(b)
1659
print config.user_email()
1660
else:
1661
print config.username()
1662
1663
1664
class cmd_nick(Command):
1665
"""Print or set the branch nickname.
1666
1667
If unset, the tree root directory name is used as the nickname
1668
To print the current nickname, execute with no argument.
1669
"""
1670
takes_args = ['nickname?']
1671
def run(self, nickname=None):
1672
branch = Branch.open_containing(u'.')[0]
1673
if nickname is None:
1674
self.printme(branch)
1675
else:
1676
branch.nick = nickname
1677
1678
@display_command
1679
def printme(self, branch):
1680
print branch.nick
1055
1681
1056
1682
1057
1683
class cmd_selftest(Command):
1058
"""Run internal test suite"""
1684
"""Run internal test suite.
1685
1686
This creates temporary test directories in the working directory,
1687
but not existing data is affected. These directories are deleted
1688
if the tests pass, or left behind to help in debugging if they
1689
fail and --keep-output is specified.
1690
1691
If arguments are given, they are regular expressions that say
1692
which tests should run.
1693
1694
If the global option '--no-plugins' is given, plugins are not loaded
1695
before running the selftests. This has two effects: features provided or
1696
modified by plugins will not be tested, and tests provided by plugins will
1697
not be run.
1698
1699
examples:
1700
bzr selftest ignore
1701
bzr --no-plugins selftest -v
1702
"""
1703
# TODO: --list should give a list of all available tests
1704
1705
# NB: this is used from the class without creating an instance, which is
1706
# why it does not have a self parameter.
1707
def get_transport_type(typestring):
1708
"""Parse and return a transport specifier."""
1709
if typestring == "sftp":
1710
from bzrlib.transport.sftp import SFTPAbsoluteServer
1711
return SFTPAbsoluteServer
1712
if typestring == "memory":
1713
from bzrlib.transport.memory import MemoryServer
1714
return MemoryServer
1715
if typestring == "fakenfs":
1716
from bzrlib.transport.fakenfs import FakeNFSServer
1717
return FakeNFSServer
1718
msg = "No known transport type %s. Supported types are: sftp\n" %\
1719
(typestring)
1720
raise BzrCommandError(msg)
1721
1059
1722
hidden = True
1060
takes_options = ['verbose', 'pattern']
1061
def run(self, verbose=False, pattern=".*"):
1723
takes_args = ['testspecs*']
1724
takes_options = ['verbose',
1725
Option('one', help='stop when one test fails'),
1726
Option('keep-output',
1727
help='keep output directories when tests fail'),
1728
Option('transport',
1729
help='Use a different transport by default '
1730
'throughout the test suite.',
1731
type=get_transport_type),
1732
]
1733
1734
def run(self, testspecs_list=None, verbose=False, one=False,
1735
keep_output=False, transport=None):
1062
1736
import bzrlib.ui
1063
from bzrlib.selftest import selftest
1737
from bzrlib.tests import selftest
1064
1738
# we don't want progress meters from the tests to go to the
1065
1739
# real output; and we don't want log messages cluttering up
1066
1740
# the real logs.
1068
1742
bzrlib.trace.info('running tests...')
1069
1743
try:
1070
1744
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1071
result = selftest(verbose=verbose, pattern=pattern)
1745
if testspecs_list is not None:
1746
pattern = '|'.join(testspecs_list)
1747
else:
1748
pattern = ".*"
1749
result = selftest(verbose=verbose,
1750
pattern=pattern,
1751
stop_on_failure=one,
1752
keep_output=keep_output,
1753
transport=transport)
1072
1754
if result:
1073
1755
bzrlib.trace.info('tests passed')
1074
1756
else:
1078
1760
bzrlib.ui.ui_factory = save_ui
1079
1761
1080
1762
1763
def _get_bzr_branch():
1764
"""If bzr is run from a branch, return Branch or None"""
1765
import bzrlib.errors
1766
from bzrlib.branch import Branch
1767
from bzrlib.osutils import abspath
1768
from os.path import dirname
1769
1770
try:
1771
branch = Branch.open(dirname(abspath(dirname(__file__))))
1772
return branch
1773
except bzrlib.errors.BzrError:
1774
return None
1775
1776
1081
1777
def show_version():
1082
1778
print "bzr (bazaar-ng) %s" % bzrlib.__version__
1083
1779
# is bzrlib itself in a branch?
1084
bzrrev = bzrlib.get_bzr_revision()
1085
if bzrrev:
1086
print " (bzr checkout, revision %d {%s})" % bzrrev
1780
branch = _get_bzr_branch()
1781
if branch:
1782
rh = branch.revision_history()
1783
revno = len(rh)
1784
print " bzr checkout, revision %d" % (revno,)
1785
print " nick: %s" % (branch.nick,)
1786
if rh:
1787
print " revid: %s" % (rh[-1],)
1087
1788
print bzrlib.__copyright__
1088
1789
print "http://bazaar-ng.org/"
1089
1790
print
1094
1795
1095
1796
class cmd_version(Command):
1096
1797
"""Show version of bzr."""
1798
@display_command
1097
1799
def run(self):
1098
1800
show_version()
1099
1801
1100
1802
class cmd_rocks(Command):
1101
1803
"""Statement of optimism."""
1102
1804
hidden = True
1805
@display_command
1103
1806
def run(self):
1104
1807
print "it sure does!"
1105
1808
1106
1809
1107
1810
class cmd_find_merge_base(Command):
1108
1811
"""Find and print a base revision for merging two branches.
1109
1110
TODO: Options to specify revisions on either side, as if
1111
merging only part of the history.
1112
1812
"""
1813
# TODO: Options to specify revisions on either side, as if
1814
# merging only part of the history.
1113
1815
takes_args = ['branch', 'other']
1114
1816
hidden = True
1115
1817
1818
@display_command
1116
1819
def run(self, branch, other):
1117
1820
from bzrlib.revision import common_ancestor, MultipleRevisionSources
1118
1821
1119
branch1 = find_branch(branch)
1120
branch2 = find_branch(other)
1822
branch1 = Branch.open_containing(branch)[0]
1823
branch2 = Branch.open_containing(other)[0]
1121
1824
1122
1825
history_1 = branch1.revision_history()
1123
1826
history_2 = branch2.revision_history()
1124
1827
1125
last1 = branch1.last_patch()
1126
last2 = branch2.last_patch()
1828
last1 = branch1.last_revision()
1829
last2 = branch2.last_revision()
1127
1830
1128
source = MultipleRevisionSources(branch1, branch2)
1831
source = MultipleRevisionSources(branch1.repository,
1832
branch2.repository)
1129
1833
1130
1834
base_rev_id = common_ancestor(last1, last2, source)
1131
1835
1153
1857
will be used as a BASE, and the second one as OTHER. Revision
1154
1858
numbers are always relative to the specified branch.
1155
1859
1156
By default bzr will try to merge in all new work from the other
1860
By default, bzr will try to merge in all new work from the other
1157
1861
branch, automatically determining an appropriate base. If this
1158
1862
fails, you may need to give an explicit base.
1159
1863
1864
Merge will do its best to combine the changes in two branches, but there
1865
are some kinds of problems only a human can fix. When it encounters those,
1866
it will mark a conflict. A conflict means that you need to fix something,
1867
before you should commit.
1868
1869
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
1870
1871
If there is no default branch set, the first merge will set it. After
1872
that, you can omit the branch to use the default. To change the
1873
default, use --remember.
1874
1160
1875
Examples:
1161
1876
1162
1877
To merge the latest revision from bzr.dev
1172
1887
--force is given.
1173
1888
"""
1174
1889
takes_args = ['branch?']
1175
takes_options = ['revision', 'force', 'merge-type']
1890
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
1891
Option('show-base', help="Show base revision text in "
1892
"conflicts")]
1176
1893
1177
def run(self, branch='.', revision=None, force=False,
1178
merge_type=None):
1179
from bzrlib.merge import merge
1180
from bzrlib.merge_core import ApplyMerge3
1894
def run(self, branch=None, revision=None, force=False, merge_type=None,
1895
show_base=False, reprocess=False, remember=False):
1181
1896
if merge_type is None:
1182
merge_type = ApplyMerge3
1897
merge_type = Merge3Merger
1898
1899
tree = WorkingTree.open_containing(u'.')[0]
1900
stored_loc = tree.branch.get_parent()
1901
if branch is None:
1902
if stored_loc is None:
1903
raise BzrCommandError("No merge branch known or specified.")
1904
else:
1905
print "Using saved branch: %s" % stored_loc
1906
branch = stored_loc
1907
1908
if tree.branch.get_parent() is None or remember:
1909
tree.branch.set_parent(branch)
1183
1910
1184
1911
if revision is None or len(revision) < 1:
1185
1912
base = [None, None]
1186
1913
other = [branch, -1]
1914
other_branch, path = Branch.open_containing(branch)
1187
1915
else:
1188
1916
if len(revision) == 1:
1189
other = [branch, revision[0]]
1190
1917
base = [None, None]
1918
other_branch, path = Branch.open_containing(branch)
1919
revno = revision[0].in_history(other_branch).revno
1920
other = [branch, revno]
1191
1921
else:
1192
1922
assert len(revision) == 2
1193
1923
if None in revision:
1194
1924
raise BzrCommandError(
1195
1925
"Merge doesn't permit that revision specifier.")
1196
base = [branch, revision[0]]
1197
other = [branch, revision[1]]
1926
b, path = Branch.open_containing(branch)
1198
1927
1928
base = [branch, revision[0].in_history(b).revno]
1929
other = [branch, revision[1].in_history(b).revno]
1930
if path != "":
1931
interesting_files = [path]
1932
else:
1933
interesting_files = None
1934
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1199
1935
try:
1200
merge(other, base, check_clean=(not force), merge_type=merge_type)
1936
try:
1937
conflict_count = merge(other, base, check_clean=(not force),
1938
merge_type=merge_type,
1939
reprocess=reprocess,
1940
show_base=show_base,
1941
pb=pb, file_list=interesting_files)
1942
finally:
1943
pb.finished()
1944
if conflict_count != 0:
1945
return 1
1946
else:
1947
return 0
1201
1948
except bzrlib.errors.AmbiguousBase, e:
1202
1949
m = ("sorry, bzr can't determine the right merge base yet\n"
1203
1950
"candidates are:\n "
1208
1955
log_error(m)
1209
1956
1210
1957
1958
class cmd_remerge(Command):
1959
"""Redo a merge.
1960
"""
1961
takes_args = ['file*']
1962
takes_options = ['merge-type', 'reprocess',
1963
Option('show-base', help="Show base revision text in "
1964
"conflicts")]
1965
1966
def run(self, file_list=None, merge_type=None, show_base=False,
1967
reprocess=False):
1968
from bzrlib.merge import merge_inner, transform_tree
1969
if merge_type is None:
1970
merge_type = Merge3Merger
1971
tree, file_list = tree_files(file_list)
1972
tree.lock_write()
1973
try:
1974
pending_merges = tree.pending_merges()
1975
if len(pending_merges) != 1:
1976
raise BzrCommandError("Sorry, remerge only works after normal"
1977
+ " merges. Not cherrypicking or"
1978
+ "multi-merges.")
1979
repository = tree.branch.repository
1980
base_revision = common_ancestor(tree.branch.last_revision(),
1981
pending_merges[0], repository)
1982
base_tree = repository.revision_tree(base_revision)
1983
other_tree = repository.revision_tree(pending_merges[0])
1984
interesting_ids = None
1985
if file_list is not None:
1986
interesting_ids = set()
1987
for filename in file_list:
1988
file_id = tree.path2id(filename)
1989
if file_id is None:
1990
raise NotVersionedError(filename)
1991
interesting_ids.add(file_id)
1992
if tree.kind(file_id) != "directory":
1993
continue
1994
1995
for name, ie in tree.inventory.iter_entries(file_id):
1996
interesting_ids.add(ie.file_id)
1997
transform_tree(tree, tree.basis_tree(), interesting_ids)
1998
if file_list is None:
1999
restore_files = list(tree.iter_conflicts())
2000
else:
2001
restore_files = file_list
2002
for filename in restore_files:
2003
try:
2004
restore(tree.abspath(filename))
2005
except NotConflicted:
2006
pass
2007
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2008
this_tree=tree,
2009
interesting_ids = interesting_ids,
2010
other_rev_id=pending_merges[0],
2011
merge_type=merge_type,
2012
show_base=show_base,
2013
reprocess=reprocess)
2014
finally:
2015
tree.unlock()
2016
if conflicts > 0:
2017
return 1
2018
else:
2019
return 0
2020
1211
2021
class cmd_revert(Command):
1212
2022
"""Reverse all changes since the last commit.
1213
2023
1220
2030
aliases = ['merge-revert']
1221
2031
1222
2032
def run(self, revision=None, no_backup=False, file_list=None):
1223
from bzrlib.merge import merge
1224
from bzrlib.branch import Branch
1225
2033
from bzrlib.commands import parse_spec
1226
1227
2034
if file_list is not None:
1228
2035
if len(file_list) == 0:
1229
2036
raise BzrCommandError("No files specified")
2037
else:
2038
file_list = []
2039
2040
tree, file_list = tree_files(file_list)
1230
2041
if revision is None:
1231
revision = [-1]
2042
# FIXME should be tree.last_revision
2043
rev_id = tree.last_revision()
1232
2044
elif len(revision) != 1:
1233
2045
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1234
merge(('.', revision[0]), parse_spec('.'),
1235
check_clean=False,
1236
ignore_zero=True,
1237
backup_files=not no_backup,
1238
file_list=file_list)
1239
if not file_list:
1240
Branch('.').set_pending_merges([])
2046
else:
2047
rev_id = revision[0].in_history(tree.branch).rev_id
2048
pb = bzrlib.ui.ui_factory.nested_progress_bar()
2049
try:
2050
tree.revert(file_list,
2051
tree.branch.repository.revision_tree(rev_id),
2052
not no_backup, pb)
2053
finally:
2054
pb.finished()
1241
2055
1242
2056
1243
2057
class cmd_assert_fail(Command):
1251
2065
"""Show help on a command or other topic.
1252
2066
1253
2067
For a list of all available commands, say 'bzr help commands'."""
1254
takes_options = ['long']
2068
takes_options = [Option('long', 'show help on all commands')]
1255
2069
takes_args = ['topic?']
1256
aliases = ['?']
2070
aliases = ['?', '--help', '-?', '-h']
1257
2071
2072
@display_command
1258
2073
def run(self, topic=None, long=False):
1259
2074
import help
1260
2075
if topic is None and long:
1270
2085
aliases = ['s-c']
1271
2086
hidden = True
1272
2087
2088
@display_command
1273
2089
def run(self, context=None):
1274
2090
import shellcomplete
1275
2091
shellcomplete.shellcomplete(context)
1276
2092
1277
2093
2094
class cmd_fetch(Command):
2095
"""Copy in history from another branch but don't merge it.
2096
2097
This is an internal method used for pull and merge."""
2098
hidden = True
2099
takes_args = ['from_branch', 'to_branch']
2100
def run(self, from_branch, to_branch):
2101
from bzrlib.fetch import Fetcher
2102
from bzrlib.branch import Branch
2103
from_b = Branch.open(from_branch)
2104
to_b = Branch.open(to_branch)
2105
Fetcher(to_b, from_b)
2106
2107
1278
2108
class cmd_missing(Command):
1279
"""What is missing in this branch relative to other branch.
1280
"""
1281
takes_args = ['remote?']
1282
aliases = ['mis', 'miss']
1283
# We don't have to add quiet to the list, because
1284
# unknown options are parsed as booleans
1285
takes_options = ['verbose', 'quiet']
1286
1287
def run(self, remote=None, verbose=False, quiet=False):
1288
from bzrlib.errors import BzrCommandError
1289
from bzrlib.missing import show_missing
1290
1291
if verbose and quiet:
1292
raise BzrCommandError('Cannot pass both quiet and verbose')
1293
1294
b = find_branch('.')
1295
parent = b.get_parent()
1296
if remote is None:
1297
if parent is None:
2109
"""Show unmerged/unpulled revisions between two branches.
2110
2111
OTHER_BRANCH may be local or remote."""
2112
takes_args = ['other_branch?']
2113
takes_options = [Option('reverse', 'Reverse the order of revisions'),
2114
Option('mine-only',
2115
'Display changes in the local branch only'),
2116
Option('theirs-only',
2117
'Display changes in the remote branch only'),
2118
'log-format',
2119
'line',
2120
'long',
2121
'short',
2122
'show-ids',
2123
'verbose'
2124
]
2125
2126
def run(self, other_branch=None, reverse=False, mine_only=False,
2127
theirs_only=False, log_format=None, long=False, short=False, line=False,
2128
show_ids=False, verbose=False):
2129
from bzrlib.missing import find_unmerged, iter_log_data
2130
from bzrlib.log import log_formatter
2131
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2132
parent = local_branch.get_parent()
2133
if other_branch is None:
2134
other_branch = parent
2135
if other_branch is None:
1298
2136
raise BzrCommandError("No missing location known or specified.")
1299
else:
1300
if not quiet:
1301
print "Using last location: %s" % parent
1302
remote = parent
1303
elif parent is None:
1304
# We only update x-pull if it did not exist, missing should not change the parent
1305
b.controlfile('x-pull', 'wb').write(remote + '\n')
1306
br_remote = find_branch(remote)
1307
1308
return show_missing(b, br_remote, verbose=verbose, quiet=quiet)
1309
2137
print "Using last location: " + local_branch.get_parent()
2138
remote_branch = bzrlib.branch.Branch.open(other_branch)
2139
if remote_branch.base == local_branch.base:
2140
remote_branch = local_branch
2141
local_branch.lock_read()
2142
try:
2143
remote_branch.lock_read()
2144
try:
2145
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2146
if (log_format == None):
2147
default = bzrlib.config.BranchConfig(local_branch).log_format()
2148
log_format = get_log_format(long=long, short=short, line=line, default=default)
2149
lf = log_formatter(log_format, sys.stdout,
2150
show_ids=show_ids,
2151
show_timezone='original')
2152
if reverse is False:
2153
local_extra.reverse()
2154
remote_extra.reverse()
2155
if local_extra and not theirs_only:
2156
print "You have %d extra revision(s):" % len(local_extra)
2157
for data in iter_log_data(local_extra, local_branch.repository,
2158
verbose):
2159
lf.show(*data)
2160
printed_local = True
2161
else:
2162
printed_local = False
2163
if remote_extra and not mine_only:
2164
if printed_local is True:
2165
print "\n\n"
2166
print "You are missing %d revision(s):" % len(remote_extra)
2167
for data in iter_log_data(remote_extra, remote_branch.repository,
2168
verbose):
2169
lf.show(*data)
2170
if not remote_extra and not local_extra:
2171
status_code = 0
2172
print "Branches are up to date."
2173
else:
2174
status_code = 1
2175
finally:
2176
remote_branch.unlock()
2177
finally:
2178
local_branch.unlock()
2179
if not status_code and parent is None and other_branch is not None:
2180
local_branch.lock_write()
2181
try:
2182
# handle race conditions - a parent might be set while we run.
2183
if local_branch.get_parent() is None:
2184
local_branch.set_parent(other_branch)
2185
finally:
2186
local_branch.unlock()
2187
return status_code
1310
2188
1311
2189
1312
2190
class cmd_plugins(Command):
1313
2191
"""List plugins"""
1314
2192
hidden = True
2193
@display_command
1315
2194
def run(self):
1316
2195
import bzrlib.plugin
1317
2196
from inspect import getdoc
1318
for plugin in bzrlib.plugin.all_plugins:
2197
for name, plugin in bzrlib.plugin.all_plugins().items():
1319
2198
if hasattr(plugin, '__path__'):
1320
2199
print plugin.__path__[0]
1321
2200
elif hasattr(plugin, '__file__'):
1328
2207
print '\t', d.split('\n')[0]
1329
2208
1330
2209
2210
class cmd_testament(Command):
2211
"""Show testament (signing-form) of a revision."""
2212
takes_options = ['revision', 'long']
2213
takes_args = ['branch?']
2214
@display_command
2215
def run(self, branch=u'.', revision=None, long=False):
2216
from bzrlib.testament import Testament
2217
b = WorkingTree.open_containing(branch)[0].branch
2218
b.lock_read()
2219
try:
2220
if revision is None:
2221
rev_id = b.last_revision()
2222
else:
2223
rev_id = revision[0].in_history(b).rev_id
2224
t = Testament.from_revision(b.repository, rev_id)
2225
if long:
2226
sys.stdout.writelines(t.as_text_lines())
2227
else:
2228
sys.stdout.write(t.as_short_text())
2229
finally:
2230
b.unlock()
2231
2232
2233
class cmd_annotate(Command):
2234
"""Show the origin of each line in a file.
2235
2236
This prints out the given file with an annotation on the left side
2237
indicating which revision, author and date introduced the change.
2238
2239
If the origin is the same for a run of consecutive lines, it is
2240
shown only at the top, unless the --all option is given.
2241
"""
2242
# TODO: annotate directories; showing when each file was last changed
2243
# TODO: annotate a previous version of a file
2244
# TODO: if the working copy is modified, show annotations on that
2245
# with new uncommitted lines marked
2246
aliases = ['blame', 'praise']
2247
takes_args = ['filename']
2248
takes_options = [Option('all', help='show annotations on all lines'),
2249
Option('long', help='show date in annotations'),
2250
]
2251
2252
@display_command
2253
def run(self, filename, all=False, long=False):
2254
from bzrlib.annotate import annotate_file
2255
tree, relpath = WorkingTree.open_containing(filename)
2256
branch = tree.branch
2257
branch.lock_read()
2258
try:
2259
file_id = tree.inventory.path2id(relpath)
2260
tree = branch.repository.revision_tree(branch.last_revision())
2261
file_version = tree.inventory[file_id].revision
2262
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
2263
finally:
2264
branch.unlock()
2265
2266
2267
class cmd_re_sign(Command):
2268
"""Create a digital signature for an existing revision."""
2269
# TODO be able to replace existing ones.
2270
2271
hidden = True # is this right ?
2272
takes_args = ['revision_id*']
2273
takes_options = ['revision']
2274
2275
def run(self, revision_id_list=None, revision=None):
2276
import bzrlib.config as config
2277
import bzrlib.gpg as gpg
2278
if revision_id_list is not None and revision is not None:
2279
raise BzrCommandError('You can only supply one of revision_id or --revision')
2280
if revision_id_list is None and revision is None:
2281
raise BzrCommandError('You must supply either --revision or a revision_id')
2282
b = WorkingTree.open_containing(u'.')[0].branch
2283
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
2284
if revision_id_list is not None:
2285
for revision_id in revision_id_list:
2286
b.repository.sign_revision(revision_id, gpg_strategy)
2287
elif revision is not None:
2288
if len(revision) == 1:
2289
revno, rev_id = revision[0].in_history(b)
2290
b.repository.sign_revision(rev_id, gpg_strategy)
2291
elif len(revision) == 2:
2292
# are they both on rh- if so we can walk between them
2293
# might be nice to have a range helper for arbitrary
2294
# revision paths. hmm.
2295
from_revno, from_revid = revision[0].in_history(b)
2296
to_revno, to_revid = revision[1].in_history(b)
2297
if to_revid is None:
2298
to_revno = b.revno()
2299
if from_revno is None or to_revno is None:
2300
raise BzrCommandError('Cannot sign a range of non-revision-history revisions')
2301
for revno in range(from_revno, to_revno + 1):
2302
b.repository.sign_revision(b.get_rev_id(revno),
2303
gpg_strategy)
2304
else:
2305
raise BzrCommandError('Please supply either one revision, or a range.')
2306
2307
2308
class cmd_bind(Command):
2309
"""Bind the current branch to a master branch.
2310
2311
After binding, commits must succeed on the master branch
2312
before they are executed on the local one.
2313
"""
2314
2315
takes_args = ['location']
2316
takes_options = []
2317
2318
def run(self, location=None):
2319
b, relpath = Branch.open_containing(u'.')
2320
b_other = Branch.open(location)
2321
try:
2322
b.bind(b_other)
2323
except DivergedBranches:
2324
raise BzrCommandError('These branches have diverged.'
2325
' Try merging, and then bind again.')
2326
2327
2328
class cmd_unbind(Command):
2329
"""Bind the current branch to its parent.
2330
2331
After unbinding, the local branch is considered independent.
2332
"""
2333
2334
takes_args = []
2335
takes_options = []
2336
2337
def run(self):
2338
b, relpath = Branch.open_containing(u'.')
2339
if not b.unbind():
2340
raise BzrCommandError('Local branch is not bound')
2341
2342
2343
class cmd_uncommit(bzrlib.commands.Command):
2344
"""Remove the last committed revision.
2345
2346
By supplying the --all flag, it will not only remove the entry
2347
from revision_history, but also remove all of the entries in the
2348
stores.
2349
2350
--verbose will print out what is being removed.
2351
--dry-run will go through all the motions, but not actually
2352
remove anything.
2353
2354
In the future, uncommit will create a changeset, which can then
2355
be re-applied.
2356
"""
2357
2358
# TODO: jam 20060108 Add an option to allow uncommit to remove
2359
# unreferenced information in 'branch-as-repostory' branches.
2360
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2361
# information in shared branches as well.
2362
takes_options = ['verbose', 'revision',
2363
Option('dry-run', help='Don\'t actually make changes'),
2364
Option('force', help='Say yes to all questions.')]
2365
takes_args = ['location?']
2366
aliases = []
2367
2368
def run(self, location=None,
2369
dry_run=False, verbose=False,
2370
revision=None, force=False):
2371
from bzrlib.branch import Branch
2372
from bzrlib.log import log_formatter
2373
import sys
2374
from bzrlib.uncommit import uncommit
2375
2376
if location is None:
2377
location = u'.'
2378
control, relpath = bzrdir.BzrDir.open_containing(location)
2379
try:
2380
tree = control.open_workingtree()
2381
b = tree.branch
2382
except (errors.NoWorkingTree, errors.NotLocalUrl):
2383
tree = None
2384
b = control.open_branch()
2385
2386
if revision is None:
2387
revno = b.revno()
2388
rev_id = b.last_revision()
2389
else:
2390
revno, rev_id = revision[0].in_history(b)
2391
if rev_id is None:
2392
print 'No revisions to uncommit.'
2393
2394
for r in range(revno, b.revno()+1):
2395
rev_id = b.get_rev_id(r)
2396
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
2397
lf.show(r, b.repository.get_revision(rev_id), None)
2398
2399
if dry_run:
2400
print 'Dry-run, pretending to remove the above revisions.'
2401
if not force:
2402
val = raw_input('Press <enter> to continue')
2403
else:
2404
print 'The above revision(s) will be removed.'
2405
if not force:
2406
val = raw_input('Are you sure [y/N]? ')
2407
if val.lower() not in ('y', 'yes'):
2408
print 'Canceled'
2409
return 0
2410
2411
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2412
revno=revno)
2413
2414
2415
class cmd_break_lock(Command):
2416
"""Break a dead lock on a repository, branch or working directory.
2417
2418
CAUTION: Locks should only be broken when you are sure that the process
2419
holding the lock has been stopped.
2420
2421
example:
2422
bzr break-lock .
2423
"""
2424
takes_args = ['location']
2425
takes_options = [Option('show',
2426
help="just show information on the lock, " \
2427
"don't break it"),
2428
]
2429
def run(self, location, show=False):
2430
raise NotImplementedError("sorry, break-lock is not complete yet; "
2431
"you can remove the 'held' directory manually to break the lock")
2432
2433
2434
# command-line interpretation helper for merge-related commands
2435
def merge(other_revision, base_revision,
2436
check_clean=True, ignore_zero=False,
2437
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2438
file_list=None, show_base=False, reprocess=False,
2439
pb=DummyProgress()):
2440
"""Merge changes into a tree.
2441
2442
base_revision
2443
list(path, revno) Base for three-way merge.
2444
If [None, None] then a base will be automatically determined.
2445
other_revision
2446
list(path, revno) Other revision for three-way merge.
2447
this_dir
2448
Directory to merge changes into; '.' by default.
2449
check_clean
2450
If true, this_dir must have no uncommitted changes before the
2451
merge begins.
2452
ignore_zero - If true, suppress the "zero conflicts" message when
2453
there are no conflicts; should be set when doing something we expect
2454
to complete perfectly.
2455
file_list - If supplied, merge only changes to selected files.
2456
2457
All available ancestors of other_revision and base_revision are
2458
automatically pulled into the branch.
2459
2460
The revno may be -1 to indicate the last revision on the branch, which is
2461
the typical case.
2462
2463
This function is intended for use from the command line; programmatic
2464
clients might prefer to call merge.merge_inner(), which has less magic
2465
behavior.
2466
"""
2467
from bzrlib.merge import Merger
2468
if this_dir is None:
2469
this_dir = u'.'
2470
this_tree = WorkingTree.open_containing(this_dir)[0]
2471
if show_base and not merge_type is Merge3Merger:
2472
raise BzrCommandError("Show-base is not supported for this merge"
2473
" type. %s" % merge_type)
2474
if reprocess and not merge_type is Merge3Merger:
2475
raise BzrCommandError("Reprocess is not supported for this merge"
2476
" type. %s" % merge_type)
2477
if reprocess and show_base:
2478
raise BzrCommandError("Cannot reprocess and show base.")
2479
try:
2480
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2481
merger.pp = ProgressPhase("Merge phase", 5, pb)
2482
merger.pp.next_phase()
2483
merger.check_basis(check_clean)
2484
merger.set_other(other_revision)
2485
merger.pp.next_phase()
2486
merger.set_base(base_revision)
2487
if merger.base_rev_id == merger.other_rev_id:
2488
note('Nothing to do.')
2489
return 0
2490
merger.backup_files = backup_files
2491
merger.merge_type = merge_type
2492
merger.set_interesting_files(file_list)
2493
merger.show_base = show_base
2494
merger.reprocess = reprocess
2495
conflicts = merger.do_merge()
2496
if file_list is None:
2497
merger.set_pending()
2498
finally:
2499
pb.clear()
2500
return conflicts
2501
2502
2503
# these get imported and then picked up by the scan for cmd_*
2504
# TODO: Some more consistent way to split command definitions across files;
2505
# we do need to load at least some information about them to know of
2506
# aliases. ideally we would avoid loading the implementation until the
2507
# details were needed.
2508
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2509
from bzrlib.sign_my_commits import cmd_sign_my_commits
2510
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2511
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1