« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 1861.2.8
- compare with another revision
- download diff
- download tarball
- view history from revision 1861.2.8
- Committer: Alexander Belchenko
- Date: 2006-07-30 07:23:36 UTC
- mto: (1711.2.111 jam-integration)
- mto: This revision was merged to the branch mainline in revision 1906.
- Revision ID: bialix@ukr.net-20060730072336-3e9fd7ddb67b5f47
More branding: bazaar-ng -> Bazaar; bazaar-ng.org -> bazaar-vcs.org
- files added:
- bzr.ico
- bzrlib/benchmarks
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/plugins/launchpad
- bzrlib/store/revision
- bzrlib/store/versioned
- bzrlib/tests/branch_implementations
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/intertree_implementations
- bzrlib/tests/interversionedfile_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/revisionstore_implementations
- bzrlib/tests/test_patches_data
- bzrlib/tests/tree_implementations
- bzrlib/tests/workingtree_implementations
- bzrlib/transport/http
- tools/doc_generate
- tools/win32
- files removed:
- bzrlib/_merge_core.py
- notes
- patches
- files renamed:
- bzrlib/_changeset.py => bzrlib/bundle/__init__.py
- bzrlib/store/weave.py => bzrlib/store/versioned/__init__.py
- bzrlib/tests/test_annotate.py => bzrlib/tests/blackbox/test_annotate.py
- bzrlib/tests/test_status.py => bzrlib/tests/blackbox/test_status.py
- bzrlib/tests/test_uncommit.py => bzrlib/tests/blackbox/test_uncommit.py
- bzrlib/tests/test_branch.py => bzrlib/tests/branch_implementations/test_branch.py
- bzrlib/tests/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/tests/test_fileid_involved.py => bzrlib/tests/repository_implementations/test_fileid_involved.py
- bzrlib/tests/test_basis_inventory.py => bzrlib/tests/workingtree_implementations/test_basis_inventory.py
- bzrlib/transport/http.py => bzrlib/transport/http/__init__.py
- tutorial.txt => doc/tutorial.txt
- bzr_man.py => tools/doc_generate/autodoc_man.py
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005 by Canonical Ltd
2
1
# Copyright (C) 2004, 2005, 2006 by Canonical Ltd
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""builtin bzr commands"""
18
18
19
19
20
import codecs
21
import errno
20
22
import os
23
import os.path
21
24
import sys
22
25
23
26
import bzrlib
24
from bzrlib import BZRDIR
25
from bzrlib._merge_core import ApplyMerge3
27
from bzrlib import (
28
branch,
29
bundle,
30
bzrdir,
31
config,
32
errors,
33
ignores,
34
log,
35
osutils,
36
repository,
37
transport,
38
ui,
39
urlutils,
40
)
41
from bzrlib.branch import Branch, BranchReferenceFormat
42
from bzrlib.bundle import read_bundle_from_url
43
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
44
from bzrlib.conflicts import ConflictList
26
45
from bzrlib.commands import Command, display_command
27
from bzrlib.branch import Branch
28
from bzrlib.revision import common_ancestor
29
import bzrlib.errors as errors
30
46
from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError,
31
47
NotBranchError, DivergedBranches, NotConflicted,
32
NoSuchFile, NoWorkingTree, FileInWrongBranch)
48
NoSuchFile, NoWorkingTree, FileInWrongBranch,
49
NotVersionedError, NotABundle)
50
from bzrlib.merge import Merge3Merger
33
51
from bzrlib.option import Option
52
from bzrlib.progress import DummyProgress, ProgressPhase
53
from bzrlib.revision import common_ancestor
34
54
from bzrlib.revisionspec import RevisionSpec
35
import bzrlib.trace
36
from bzrlib.trace import mutter, note, log_error, warning, is_quiet
55
from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info
56
from bzrlib.transport.local import LocalTransport
37
57
from bzrlib.workingtree import WorkingTree
38
from bzrlib.log import show_one_log
39
58
40
59
41
60
def tree_files(file_list, default_branch=u'.'):
45
64
raise BzrCommandError("%s is not in the same branch as %s" %
46
65
(e.path, file_list[0]))
47
66
67
68
# XXX: Bad function name; should possibly also be a class method of
69
# WorkingTree rather than a function.
48
70
def internal_tree_files(file_list, default_branch=u'.'):
49
"""\
50
Return a branch and list of branch-relative paths.
51
If supplied file_list is empty or None, the branch default will be used,
52
and returned file_list will match the original.
71
"""Convert command-line paths to a WorkingTree and relative paths.
72
73
This is typically used for command-line processors that take one or
74
more filenames, and infer the workingtree that contains them.
75
76
The filenames given are not required to exist.
77
78
:param file_list: Filenames to convert.
79
80
:param default_branch: Fallback tree path to use if file_list is empty or None.
81
82
:return: workingtree, [relative_paths]
53
83
"""
54
84
if file_list is None or len(file_list) == 0:
55
85
return WorkingTree.open_containing(default_branch)[0], file_list
63
93
return tree, new_list
64
94
65
95
96
def get_format_type(typestring):
97
"""Parse and return a format specifier."""
98
if typestring == "weave":
99
return bzrdir.BzrDirFormat6()
100
if typestring == "default":
101
return bzrdir.BzrDirMetaFormat1()
102
if typestring == "metaweave":
103
format = bzrdir.BzrDirMetaFormat1()
104
format.repository_format = repository.RepositoryFormat7()
105
return format
106
if typestring == "knit":
107
format = bzrdir.BzrDirMetaFormat1()
108
format.repository_format = repository.RepositoryFormatKnit1()
109
return format
110
msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \
111
"metaweave and weave" % typestring
112
raise BzrCommandError(msg)
113
114
66
115
# TODO: Make sure no commands unconditionally use the working directory as a
67
116
# branch. If a filename argument is used, the first of them should be used to
68
117
# specify the branch. (Perhaps this can be factored out into some kind of
90
139
modified
91
140
Text has changed since the previous revision.
92
141
93
unchanged
94
Nothing about this file has changed since the previous revision.
95
Only shown with --all.
96
97
142
unknown
98
143
Not versioned and not matching an ignore pattern.
99
144
112
157
# TODO: --no-recurse, --recurse options
113
158
114
159
takes_args = ['file*']
115
takes_options = ['all', 'show-ids', 'revision']
160
takes_options = ['show-ids', 'revision']
116
161
aliases = ['st', 'stat']
162
163
encoding_type = 'replace'
117
164
118
165
@display_command
119
def run(self, all=False, show_ids=False, file_list=None, revision=None):
166
def run(self, show_ids=False, file_list=None, revision=None):
167
from bzrlib.status import show_tree_status
168
120
169
tree, file_list = tree_files(file_list)
121
170
122
from bzrlib.status import show_status
123
show_status(tree.branch, show_unchanged=all, show_ids=show_ids,
124
specific_files=file_list, revision=revision)
171
show_tree_status(tree, show_ids=show_ids,
172
specific_files=file_list, revision=revision,
173
to_file=self.outf)
125
174
126
175
127
176
class cmd_cat_revision(Command):
134
183
hidden = True
135
184
takes_args = ['revision_id?']
136
185
takes_options = ['revision']
186
# cat-revision is more for frontends so should be exact
187
encoding = 'strict'
137
188
138
189
@display_command
139
190
def run(self, revision_id=None, revision=None):
143
194
if revision_id is None and revision is None:
144
195
raise BzrCommandError('You must supply either --revision or a revision_id')
145
196
b = WorkingTree.open_containing(u'.')[0].branch
197
198
# TODO: jam 20060112 should cat-revision always output utf-8?
146
199
if revision_id is not None:
147
sys.stdout.write(b.repository.get_revision_xml(revision_id))
200
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
148
201
elif revision is not None:
149
202
for rev in revision:
150
203
if rev is None:
151
204
raise BzrCommandError('You cannot specify a NULL revision.')
152
205
revno, rev_id = rev.in_history(b)
153
sys.stdout.write(b.repository.get_revision_xml(rev_id))
206
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
154
207
155
208
156
209
class cmd_revno(Command):
157
210
"""Show current revision number.
158
211
159
This is equal to the number of revisions on this branch."""
212
This is equal to the number of revisions on this branch.
213
"""
214
160
215
takes_args = ['location?']
216
161
217
@display_command
162
218
def run(self, location=u'.'):
163
print Branch.open_containing(location)[0].revno()
219
self.outf.write(str(Branch.open_containing(location)[0].revno()))
220
self.outf.write('\n')
164
221
165
222
166
223
class cmd_revision_info(Command):
169
226
hidden = True
170
227
takes_args = ['revision_info*']
171
228
takes_options = ['revision']
229
172
230
@display_command
173
231
def run(self, revision=None, revision_info_list=[]):
174
232
211
269
212
270
Adding a file whose parent directory is not versioned will
213
271
implicitly add the parent, and so on up to the root. This means
214
you should never need to explictly add a directory, they'll just
272
you should never need to explicitly add a directory, they'll just
215
273
get added when you add a file in the directory.
216
274
217
275
--dry-run will show which files would be added, but not actually
219
277
"""
220
278
takes_args = ['file*']
221
279
takes_options = ['no-recurse', 'dry-run', 'verbose']
280
encoding_type = 'replace'
222
281
223
282
def run(self, file_list, no_recurse=False, dry_run=False, verbose=False):
224
283
import bzrlib.add
225
284
226
if dry_run:
227
if is_quiet():
228
# This is pointless, but I'd rather not raise an error
229
action = bzrlib.add.add_action_null
230
else:
231
action = bzrlib.add.add_action_print
232
elif is_quiet():
233
action = bzrlib.add.add_action_add
234
else:
235
action = bzrlib.add.add_action_add_and_print
285
action = bzrlib.add.AddAction(to_file=self.outf,
286
should_print=(not is_quiet()))
236
287
237
288
added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,
238
action)
289
action=action, save=not dry_run)
239
290
if len(ignored) > 0:
240
for glob in sorted(ignored.keys()):
241
match_len = len(ignored[glob])
242
if verbose:
291
if verbose:
292
for glob in sorted(ignored.keys()):
243
293
for path in ignored[glob]:
244
print "ignored %s matching \"%s\"" % (path, glob)
245
else:
246
print "ignored %d file(s) matching \"%s\"" % (match_len,
247
glob)
248
print "If you wish to add some of these files, please add them"\
249
" by name."
294
self.outf.write("ignored %s matching \"%s\"\n"
295
% (path, glob))
296
else:
297
match_len = 0
298
for glob, paths in ignored.items():
299
match_len += len(paths)
300
self.outf.write("ignored %d file(s).\n" % match_len)
301
self.outf.write("If you wish to add some of these files,"
302
" please add them by name.\n")
250
303
251
304
252
305
class cmd_mkdir(Command):
254
307
255
308
This is equivalent to creating the directory and then adding it.
256
309
"""
310
257
311
takes_args = ['dir+']
312
encoding_type = 'replace'
258
313
259
314
def run(self, dir_list):
260
315
for d in dir_list:
261
316
os.mkdir(d)
262
317
wt, dd = WorkingTree.open_containing(d)
263
318
wt.add([dd])
264
print 'added', d
319
self.outf.write('added %s\n' % d)
265
320
266
321
267
322
class cmd_relpath(Command):
268
323
"""Show path of a file relative to root"""
324
269
325
takes_args = ['filename']
270
326
hidden = True
271
327
272
328
@display_command
273
329
def run(self, filename):
330
# TODO: jam 20050106 Can relpath return a munged path if
331
# sys.stdout encoding cannot represent it?
274
332
tree, relpath = WorkingTree.open_containing(filename)
275
print relpath
333
self.outf.write(relpath)
334
self.outf.write('\n')
276
335
277
336
278
337
class cmd_inventory(Command):
281
340
It is possible to limit the output to a particular entry
282
341
type using the --kind option. For example; --kind file.
283
342
"""
343
284
344
takes_options = ['revision', 'show-ids', 'kind']
285
345
286
346
@display_command
301
361
if kind and kind != entry.kind:
302
362
continue
303
363
if show_ids:
304
print '%-50s %s' % (path, entry.file_id)
364
self.outf.write('%-50s %s\n' % (path, entry.file_id))
305
365
else:
306
print path
307
308
309
class cmd_move(Command):
310
"""Move files to a different directory.
311
312
examples:
313
bzr move *.txt doc
314
315
The destination must be a versioned directory in the same branch.
316
"""
317
takes_args = ['source$', 'dest']
318
def run(self, source_list, dest):
319
tree, source_list = tree_files(source_list)
320
# TODO: glob expansion on windows?
321
tree.move(source_list, tree.relpath(dest))
322
323
324
class cmd_rename(Command):
325
"""Change the name of an entry.
326
327
examples:
328
bzr rename frob.c frobber.c
329
bzr rename src/frob.c lib/frob.c
330
331
It is an error if the destination name exists.
332
333
See also the 'move' command, which moves files into a different
334
directory without changing their name.
335
"""
336
# TODO: Some way to rename multiple files without invoking
337
# bzr for each one?"""
338
takes_args = ['from_name', 'to_name']
339
340
def run(self, from_name, to_name):
341
tree, (from_name, to_name) = tree_files((from_name, to_name))
342
tree.rename_one(from_name, to_name)
366
self.outf.write(path)
367
self.outf.write('\n')
343
368
344
369
345
370
class cmd_mv(Command):
355
380
356
381
Files cannot be moved between branches.
357
382
"""
383
358
384
takes_args = ['names*']
385
aliases = ['move', 'rename']
386
encoding_type = 'replace'
387
359
388
def run(self, names_list):
389
if names_list is None:
390
names_list = []
391
360
392
if len(names_list) < 2:
361
393
raise BzrCommandError("missing file argument")
362
394
tree, rel_names = tree_files(names_list)
364
396
if os.path.isdir(names_list[-1]):
365
397
# move into existing directory
366
398
for pair in tree.move(rel_names[:-1], rel_names[-1]):
367
print "%s => %s" % pair
399
self.outf.write("%s => %s\n" % pair)
368
400
else:
369
401
if len(names_list) != 2:
370
402
raise BzrCommandError('to mv multiple files the destination '
371
403
'must be a versioned directory')
372
404
tree.rename_one(rel_names[0], rel_names[1])
373
print "%s => %s" % (rel_names[0], rel_names[1])
405
self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))
374
406
375
407
376
408
class cmd_pull(Command):
377
"""Pull any changes from another branch into the current one.
378
379
If there is no default location set, the first pull will set it. After
380
that, you can omit the location to use the default. To change the
381
default, use --remember.
409
"""Turn this branch into a mirror of another branch.
382
410
383
411
This command only works on branches that have not diverged. Branches are
384
considered diverged if both branches have had commits without first
385
pulling from the other.
412
considered diverged if the destination branch's most recent commit is one
413
that has not been merged (directly or indirectly) into the parent.
386
414
387
If branches have diverged, you can use 'bzr merge' to pull the text changes
415
If branches have diverged, you can use 'bzr merge' to integrate the changes
388
416
from one into the other. Once one branch has merged, the other should
389
417
be able to pull it again.
390
418
391
419
If you want to forget your local changes and just update your branch to
392
match the remote one, use --overwrite.
420
match the remote one, use pull --overwrite.
421
422
If there is no default location set, the first pull will set it. After
423
that, you can omit the location to use the default. To change the
424
default, use --remember. The value will only be saved if the remote
425
location can be accessed.
393
426
"""
394
takes_options = ['remember', 'overwrite', 'verbose']
427
428
takes_options = ['remember', 'overwrite', 'revision', 'verbose']
395
429
takes_args = ['location?']
396
397
def run(self, location=None, remember=False, overwrite=False, verbose=False):
398
from shutil import rmtree
399
import errno
400
# FIXME: too much stuff is in the command class
401
tree_to = WorkingTree.open_containing(u'.')[0]
402
stored_loc = tree_to.branch.get_parent()
430
encoding_type = 'replace'
431
432
def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):
433
# FIXME: too much stuff is in the command class
434
try:
435
tree_to = WorkingTree.open_containing(u'.')[0]
436
branch_to = tree_to.branch
437
except NoWorkingTree:
438
tree_to = None
439
branch_to = Branch.open_containing(u'.')[0]
440
441
reader = None
442
if location is not None:
443
try:
444
reader = bundle.read_bundle_from_url(location)
445
except NotABundle:
446
pass # Continue on considering this url a Branch
447
448
stored_loc = branch_to.get_parent()
403
449
if location is None:
404
450
if stored_loc is None:
405
451
raise BzrCommandError("No pull location known or specified.")
406
452
else:
407
print "Using saved location: %s" % stored_loc
453
display_url = urlutils.unescape_for_display(stored_loc,
454
self.outf.encoding)
455
self.outf.write("Using saved location: %s\n" % display_url)
408
456
location = stored_loc
409
457
410
br_from = Branch.open(location)
411
br_to = tree_to.branch
412
413
old_rh = br_to.revision_history()
414
count = tree_to.pull(br_from, overwrite)
415
416
if br_to.get_parent() is None or remember:
417
br_to.set_parent(location)
458
459
if reader is not None:
460
install_bundle(branch_to.repository, reader)
461
branch_from = branch_to
462
else:
463
branch_from = Branch.open(location)
464
465
if branch_to.get_parent() is None or remember:
466
branch_to.set_parent(branch_from.base)
467
468
rev_id = None
469
if revision is None:
470
if reader is not None:
471
rev_id = reader.target
472
elif len(revision) == 1:
473
rev_id = revision[0].in_history(branch_from).rev_id
474
else:
475
raise BzrCommandError('bzr pull --revision takes one value.')
476
477
old_rh = branch_to.revision_history()
478
if tree_to is not None:
479
count = tree_to.pull(branch_from, overwrite, rev_id)
480
else:
481
count = branch_to.pull(branch_from, overwrite, rev_id)
418
482
note('%d revision(s) pulled.' % (count,))
419
483
420
484
if verbose:
421
new_rh = tree_to.branch.revision_history()
485
new_rh = branch_to.revision_history()
422
486
if old_rh != new_rh:
423
487
# Something changed
424
488
from bzrlib.log import show_changed_revisions
425
show_changed_revisions(tree_to.branch, old_rh, new_rh)
489
show_changed_revisions(branch_to, old_rh, new_rh,
490
to_file=self.outf)
426
491
427
492
428
493
class cmd_push(Command):
429
"""Push this branch into another branch.
430
431
The remote branch will not have its working tree populated because this
432
is both expensive, and may not be supported on the remote file system.
433
434
Some smart servers or protocols *may* put the working tree in place.
494
"""Update a mirror of this branch.
495
496
The target branch will not have its working tree populated because this
497
is both expensive, and is not supported on remote file systems.
498
499
Some smart servers or protocols *may* put the working tree in place in
500
the future.
501
502
This command only works on branches that have not diverged. Branches are
503
considered diverged if the destination branch's most recent commit is one
504
that has not been merged (directly or indirectly) by the source branch.
505
506
If branches have diverged, you can use 'bzr push --overwrite' to replace
507
the other branch completely, discarding its unmerged changes.
508
509
If you want to ensure you have the different changes in the other branch,
510
do a merge (see bzr help merge) from the other branch, and commit that.
511
After that you will be able to do a push without '--overwrite'.
435
512
436
513
If there is no default push location set, the first push will set it.
437
514
After that, you can omit the location to use the default. To change the
438
default, use --remember.
439
440
This command only works on branches that have not diverged. Branches are
441
considered diverged if the branch being pushed to is not an older version
442
of this branch.
443
444
If branches have diverged, you can use 'bzr push --overwrite' to replace
445
the other branch completely.
446
447
If you want to ensure you have the different changes in the other branch,
448
do a merge (see bzr help merge) from the other branch, and commit that
449
before doing a 'push --overwrite'.
515
default, use --remember. The value will only be saved if the remote
516
location can be accessed.
450
517
"""
451
takes_options = ['remember', 'overwrite',
518
519
takes_options = ['remember', 'overwrite', 'verbose',
452
520
Option('create-prefix',
453
521
help='Create the path leading up to the branch '
454
522
'if it does not already exist')]
455
523
takes_args = ['location?']
524
encoding_type = 'replace'
456
525
457
526
def run(self, location=None, remember=False, overwrite=False,
458
527
create_prefix=False, verbose=False):
459
528
# FIXME: Way too big! Put this into a function called from the
460
529
# command.
461
import errno
462
from shutil import rmtree
463
from bzrlib.transport import get_transport
464
530
465
tree_from = WorkingTree.open_containing(u'.')[0]
466
br_from = tree_from.branch
467
stored_loc = tree_from.branch.get_push_location()
531
br_from = Branch.open_containing('.')[0]
532
stored_loc = br_from.get_push_location()
468
533
if location is None:
469
534
if stored_loc is None:
470
535
raise BzrCommandError("No push location known or specified.")
471
536
else:
472
print "Using saved location: %s" % stored_loc
537
display_url = urlutils.unescape_for_display(stored_loc,
538
self.outf.encoding)
539
self.outf.write("Using saved location: %s\n" % display_url)
473
540
location = stored_loc
541
542
to_transport = transport.get_transport(location)
543
location_url = to_transport.base
544
545
old_rh = []
474
546
try:
475
br_to = Branch.open(location)
547
dir_to = bzrdir.BzrDir.open(location_url)
548
br_to = dir_to.open_branch()
476
549
except NotBranchError:
477
550
# create a branch.
478
transport = get_transport(location).clone('..')
551
to_transport = to_transport.clone('..')
479
552
if not create_prefix:
480
553
try:
481
transport.mkdir(transport.relpath(location))
554
relurl = to_transport.relpath(location_url)
555
mutter('creating directory %s => %s', location_url, relurl)
556
to_transport.mkdir(relurl)
482
557
except NoSuchFile:
483
558
raise BzrCommandError("Parent directory of %s "
484
559
"does not exist." % location)
485
560
else:
486
current = transport.base
487
needed = [(transport, transport.relpath(location))]
561
current = to_transport.base
562
needed = [(to_transport, to_transport.relpath(location_url))]
488
563
while needed:
489
564
try:
490
transport, relpath = needed[-1]
491
transport.mkdir(relpath)
565
to_transport, relpath = needed[-1]
566
to_transport.mkdir(relpath)
492
567
needed.pop()
493
568
except NoSuchFile:
494
new_transport = transport.clone('..')
569
new_transport = to_transport.clone('..')
495
570
needed.append((new_transport,
496
new_transport.relpath(transport.base)))
497
if new_transport.base == transport.base:
498
raise BzrCommandError("Could not creeate "
571
new_transport.relpath(to_transport.base)))
572
if new_transport.base == to_transport.base:
573
raise BzrCommandError("Could not create "
499
574
"path prefix.")
500
br_to = Branch.initialize(location)
501
old_rh = br_to.revision_history()
502
try:
575
dir_to = br_from.bzrdir.clone(location_url,
576
revision_id=br_from.last_revision())
577
br_to = dir_to.open_branch()
578
count = len(br_to.revision_history())
579
# We successfully created the target, remember it
580
if br_from.get_push_location() is None or remember:
581
br_from.set_push_location(br_to.base)
582
else:
583
# We were able to connect to the remote location, so remember it
584
# we don't need to successfully push because of possible divergence.
585
if br_from.get_push_location() is None or remember:
586
br_from.set_push_location(br_to.base)
587
old_rh = br_to.revision_history()
503
588
try:
504
tree_to = br_to.working_tree()
505
except NoWorkingTree:
506
# TODO: This should be updated for branches which don't have a
507
# working tree, as opposed to ones where we just couldn't
508
# update the tree.
509
warning('Unable to update the working tree of: %s' % (br_to.base,))
510
count = br_to.pull(br_from, overwrite)
511
else:
512
count = tree_to.pull(br_from, overwrite)
513
except DivergedBranches:
514
raise BzrCommandError("These branches have diverged."
515
" Try a merge then push with overwrite.")
516
if br_from.get_push_location() is None or remember:
517
br_from.set_push_location(location)
589
try:
590
tree_to = dir_to.open_workingtree()
591
except errors.NotLocalUrl:
592
warning('This transport does not update the working '
593
'tree of: %s' % (br_to.base,))
594
count = br_to.pull(br_from, overwrite)
595
except NoWorkingTree:
596
count = br_to.pull(br_from, overwrite)
597
else:
598
count = tree_to.pull(br_from, overwrite)
599
except DivergedBranches:
600
raise BzrCommandError("These branches have diverged."
601
" Try a merge then push with overwrite.")
518
602
note('%d revision(s) pushed.' % (count,))
519
603
520
604
if verbose:
522
606
if old_rh != new_rh:
523
607
# Something changed
524
608
from bzrlib.log import show_changed_revisions
525
show_changed_revisions(br_to, old_rh, new_rh)
609
show_changed_revisions(br_to, old_rh, new_rh,
610
to_file=self.outf)
526
611
527
612
528
613
class cmd_branch(Command):
543
628
aliases = ['get', 'clone']
544
629
545
630
def run(self, from_location, to_location=None, revision=None, basis=None):
546
import errno
547
from shutil import rmtree
548
631
if revision is None:
549
632
revision = [None]
550
633
elif len(revision) > 1:
561
644
br_from.lock_read()
562
645
try:
563
646
if basis is not None:
564
basis_branch = WorkingTree.open_containing(basis)[0].branch
647
basis_dir = bzrdir.BzrDir.open_containing(basis)[0]
565
648
else:
566
basis_branch = None
649
basis_dir = None
567
650
if len(revision) == 1 and revision[0] is not None:
568
651
revision_id = revision[0].in_history(br_from)[1]
569
652
else:
570
revision_id = None
653
# FIXME - wt.last_revision, fallback to branch, fall back to
654
# None or perhaps NULL_REVISION to mean copy nothing
655
# RBC 20060209
656
revision_id = br_from.last_revision()
571
657
if to_location is None:
572
658
to_location = os.path.basename(from_location.rstrip("/\\"))
573
659
name = None
574
660
else:
575
661
name = os.path.basename(to_location) + '\n'
576
try:
577
os.mkdir(to_location)
578
except OSError, e:
579
if e.errno == errno.EEXIST:
580
raise BzrCommandError('Target directory "%s" already'
581
' exists.' % to_location)
582
if e.errno == errno.ENOENT:
583
raise BzrCommandError('Parent of "%s" does not exist.' %
584
to_location)
585
else:
586
raise
587
try:
588
br_from.clone(to_location, revision_id, basis_branch)
589
except bzrlib.errors.NoSuchRevision:
590
rmtree(to_location)
662
663
to_transport = transport.get_transport(to_location)
664
try:
665
to_transport.mkdir('.')
666
except errors.FileExists:
667
raise BzrCommandError('Target directory "%s" already'
668
' exists.' % to_location)
669
except errors.NoSuchFile:
670
raise BzrCommandError('Parent of "%s" does not exist.' %
671
to_location)
672
try:
673
# preserve whatever source format we have.
674
dir = br_from.bzrdir.sprout(to_transport.base,
675
revision_id, basis_dir)
676
branch = dir.open_branch()
677
except errors.NoSuchRevision:
678
to_transport.delete_tree('.')
591
679
msg = "The branch %s has no revision %s." % (from_location, revision[0])
592
680
raise BzrCommandError(msg)
593
except bzrlib.errors.UnlistableBranch:
594
rmtree(to_location)
595
msg = "The branch %s cannot be used as a --basis"
681
except errors.UnlistableBranch:
682
osutils.rmtree(to_location)
683
msg = "The branch %s cannot be used as a --basis" % (basis,)
596
684
raise BzrCommandError(msg)
597
branch = Branch.open(to_location)
598
685
if name:
599
686
branch.control_files.put_utf8('branch-name', name)
600
601
687
note('Branched %d revision(s).' % branch.revno())
602
688
finally:
603
689
br_from.unlock()
604
690
605
691
692
class cmd_checkout(Command):
693
"""Create a new checkout of an existing branch.
694
695
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
696
the branch found in '.'. This is useful if you have removed the working tree
697
or if it was never created - i.e. if you pushed the branch to its current
698
location using SFTP.
699
700
If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will
701
be used. In other words, "checkout ../foo/bar" will attempt to create ./bar.
702
703
To retrieve the branch as of a particular revision, supply the --revision
704
parameter, as in "checkout foo/bar -r 5". Note that this will be immediately
705
out of date [so you cannot commit] but it may be useful (i.e. to examine old
706
code.)
707
708
--basis is to speed up checking out from remote branches. When specified, it
709
uses the inventory and file contents from the basis branch in preference to the
710
branch being checked out.
711
"""
712
takes_args = ['branch_location?', 'to_location?']
713
takes_options = ['revision', # , 'basis']
714
Option('lightweight',
715
help="perform a lightweight checkout. Lightweight "
716
"checkouts depend on access to the branch for "
717
"every operation. Normal checkouts can perform "
718
"common operations like diff and status without "
719
"such access, and also support local commits."
720
),
721
]
722
aliases = ['co']
723
724
def run(self, branch_location=None, to_location=None, revision=None, basis=None,
725
lightweight=False):
726
if revision is None:
727
revision = [None]
728
elif len(revision) > 1:
729
raise BzrCommandError(
730
'bzr checkout --revision takes exactly 1 revision value')
731
if branch_location is None:
732
branch_location = osutils.getcwd()
733
to_location = branch_location
734
source = Branch.open(branch_location)
735
if len(revision) == 1 and revision[0] is not None:
736
revision_id = revision[0].in_history(source)[1]
737
else:
738
revision_id = None
739
if to_location is None:
740
to_location = os.path.basename(branch_location.rstrip("/\\"))
741
# if the source and to_location are the same,
742
# and there is no working tree,
743
# then reconstitute a branch
744
if (osutils.abspath(to_location) ==
745
osutils.abspath(branch_location)):
746
try:
747
source.bzrdir.open_workingtree()
748
except errors.NoWorkingTree:
749
source.bzrdir.create_workingtree()
750
return
751
try:
752
os.mkdir(to_location)
753
except OSError, e:
754
if e.errno == errno.EEXIST:
755
raise BzrCommandError('Target directory "%s" already'
756
' exists.' % to_location)
757
if e.errno == errno.ENOENT:
758
raise BzrCommandError('Parent of "%s" does not exist.' %
759
to_location)
760
else:
761
raise
762
old_format = bzrdir.BzrDirFormat.get_default_format()
763
bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())
764
try:
765
if lightweight:
766
checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)
767
branch.BranchReferenceFormat().initialize(checkout, source)
768
else:
769
checkout_branch = bzrdir.BzrDir.create_branch_convenience(
770
to_location, force_new_tree=False)
771
checkout = checkout_branch.bzrdir
772
checkout_branch.bind(source)
773
if revision_id is not None:
774
rh = checkout_branch.revision_history()
775
checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])
776
checkout.create_workingtree(revision_id)
777
finally:
778
bzrdir.BzrDirFormat.set_default_format(old_format)
779
780
606
781
class cmd_renames(Command):
607
782
"""Show list of renamed files.
608
783
"""
613
788
614
789
@display_command
615
790
def run(self, dir=u'.'):
791
from bzrlib.tree import find_renames
616
792
tree = WorkingTree.open_containing(dir)[0]
617
old_inv = tree.branch.basis_tree().inventory
793
old_inv = tree.basis_tree().inventory
618
794
new_inv = tree.read_working_inventory()
619
620
renames = list(bzrlib.tree.find_renames(old_inv, new_inv))
795
renames = list(find_renames(old_inv, new_inv))
621
796
renames.sort()
622
797
for old_name, new_name in renames:
623
print "%s => %s" % (old_name, new_name)
798
self.outf.write("%s => %s\n" % (old_name, new_name))
799
800
801
class cmd_update(Command):
802
"""Update a tree to have the latest code committed to its branch.
803
804
This will perform a merge into the working tree, and may generate
805
conflicts. If you have any local changes, you will still
806
need to commit them after the update for the update to be complete.
807
808
If you want to discard your local changes, you can just do a
809
'bzr revert' instead of 'bzr commit' after the update.
810
"""
811
takes_args = ['dir?']
812
aliases = ['up']
813
814
def run(self, dir='.'):
815
tree = WorkingTree.open_containing(dir)[0]
816
tree.lock_write()
817
try:
818
last_rev = tree.last_revision()
819
if last_rev == tree.branch.last_revision():
820
# may be up to date, check master too.
821
master = tree.branch.get_master_branch()
822
if master is None or last_rev == master.last_revision():
823
revno = tree.branch.revision_id_to_revno(last_rev)
824
note("Tree is up to date at revision %d." % (revno,))
825
return 0
826
conflicts = tree.update()
827
revno = tree.branch.revision_id_to_revno(tree.last_revision())
828
note('Updated to revision %d.' % (revno,))
829
if conflicts != 0:
830
return 1
831
else:
832
return 0
833
finally:
834
tree.unlock()
624
835
625
836
626
837
class cmd_info(Command):
627
"""Show statistical information about a branch."""
628
takes_args = ['branch?']
629
838
"""Show information about a working tree, branch or repository.
839
840
This command will show all known locations and formats associated to the
841
tree, branch or repository. Statistical information is included with
842
each report.
843
844
Branches and working trees will also report any missing revisions.
845
"""
846
takes_args = ['location?']
847
takes_options = ['verbose']
848
630
849
@display_command
631
def run(self, branch=None):
632
import info
633
b = WorkingTree.open_containing(branch)[0].branch
634
info.show_info(b)
850
def run(self, location=None, verbose=False):
851
from bzrlib.info import show_bzrdir_info
852
show_bzrdir_info(bzrdir.BzrDir.open_containing(location)[0],
853
verbose=verbose)
635
854
636
855
637
856
class cmd_remove(Command):
639
858
640
859
This makes bzr stop tracking changes to a versioned file. It does
641
860
not delete the working copy.
861
862
You can specify one or more files, and/or --new. If you specify --new,
863
only 'added' files will be removed. If you specify both, then new files
864
in the specified directories will be removed. If the directories are
865
also new, they will also be removed.
642
866
"""
643
takes_args = ['file+']
644
takes_options = ['verbose']
867
takes_args = ['file*']
868
takes_options = ['verbose', Option('new', help='remove newly-added files')]
645
869
aliases = ['rm']
870
encoding_type = 'replace'
646
871
647
def run(self, file_list, verbose=False):
872
def run(self, file_list, verbose=False, new=False):
648
873
tree, file_list = tree_files(file_list)
649
tree.remove(file_list, verbose=verbose)
874
if new is False:
875
if file_list is None:
876
raise BzrCommandError('Specify one or more files to remove, or'
877
' use --new.')
878
else:
879
added = tree.changes_from(tree.basis_tree(),
880
specific_files=file_list).added
881
file_list = sorted([f[0] for f in added], reverse=True)
882
if len(file_list) == 0:
883
raise BzrCommandError('No matching files.')
884
tree.remove(file_list, verbose=verbose, to_file=self.outf)
650
885
651
886
652
887
class cmd_file_id(Command):
656
891
same through all revisions where the file exists, even when it is
657
892
moved or renamed.
658
893
"""
894
659
895
hidden = True
660
896
takes_args = ['filename']
897
661
898
@display_command
662
899
def run(self, filename):
663
900
tree, relpath = WorkingTree.open_containing(filename)
665
902
if i == None:
666
903
raise BzrError("%r is not a versioned file" % filename)
667
904
else:
668
print i
905
self.outf.write(i + '\n')
669
906
670
907
671
908
class cmd_file_path(Command):
672
909
"""Print path of file_ids to a file or directory.
673
910
674
911
This prints one line for each directory down to the target,
675
starting at the branch root."""
912
starting at the branch root.
913
"""
914
676
915
hidden = True
677
916
takes_args = ['filename']
917
678
918
@display_command
679
919
def run(self, filename):
680
920
tree, relpath = WorkingTree.open_containing(filename)
683
923
if fid == None:
684
924
raise BzrError("%r is not a versioned file" % filename)
685
925
for fip in inv.get_idpath(fid):
686
print fip
926
self.outf.write(fip + '\n')
927
928
929
class cmd_reconcile(Command):
930
"""Reconcile bzr metadata in a branch.
931
932
This can correct data mismatches that may have been caused by
933
previous ghost operations or bzr upgrades. You should only
934
need to run this command if 'bzr check' or a bzr developer
935
advises you to run it.
936
937
If a second branch is provided, cross-branch reconciliation is
938
also attempted, which will check that data like the tree root
939
id which was not present in very early bzr versions is represented
940
correctly in both branches.
941
942
At the same time it is run it may recompress data resulting in
943
a potential saving in disk space or performance gain.
944
945
The branch *MUST* be on a listable system such as local disk or sftp.
946
"""
947
takes_args = ['branch?']
948
949
def run(self, branch="."):
950
from bzrlib.reconcile import reconcile
951
dir = bzrdir.BzrDir.open(branch)
952
reconcile(dir)
687
953
688
954
689
955
class cmd_revision_history(Command):
690
"""Display list of revision ids on this branch."""
956
"""Display the list of revision ids on a branch."""
957
takes_args = ['location?']
958
691
959
hidden = True
960
692
961
@display_command
693
def run(self):
694
branch = WorkingTree.open_containing(u'.')[0].branch
695
for patchid in branch.revision_history():
696
print patchid
962
def run(self, location="."):
963
branch = Branch.open_containing(location)[0]
964
for revid in branch.revision_history():
965
self.outf.write(revid)
966
self.outf.write('\n')
697
967
698
968
699
969
class cmd_ancestry(Command):
700
970
"""List all revisions merged into this branch."""
971
takes_args = ['location?']
972
701
973
hidden = True
974
702
975
@display_command
703
def run(self):
704
tree = WorkingTree.open_containing(u'.')[0]
705
b = tree.branch
706
# FIXME. should be tree.last_revision
707
for revision_id in b.get_ancestry(b.last_revision()):
708
print revision_id
976
def run(self, location="."):
977
try:
978
wt = WorkingTree.open_containing(location)[0]
979
except errors.NoWorkingTree:
980
b = Branch.open(location)
981
last_revision = b.last_revision()
982
else:
983
b = wt.branch
984
last_revision = wt.last_revision()
985
986
revision_ids = b.repository.get_ancestry(last_revision)
987
assert revision_ids[0] == None
988
revision_ids.pop(0)
989
for revision_id in revision_ids:
990
self.outf.write(revision_id + '\n')
709
991
710
992
711
993
class cmd_init(Command):
714
996
Use this to create an empty branch, or before importing an
715
997
existing project.
716
998
999
If there is a repository in a parent directory of the location, then
1000
the history of the branch will be stored in the repository. Otherwise
1001
init creates a standalone branch which carries its own history in
1002
.bzr.
1003
1004
If there is already a branch at the location but it has no working tree,
1005
the tree can be populated with 'bzr checkout'.
1006
717
1007
Recipe for importing a tree of files:
718
1008
cd ~/project
719
1009
bzr init
722
1012
bzr commit -m 'imported project'
723
1013
"""
724
1014
takes_args = ['location?']
725
def run(self, location=None):
726
from bzrlib.branch import Branch
1015
takes_options = [
1016
Option('format',
1017
help='Specify a format for this branch. Current'
1018
' formats are: default, knit, metaweave and'
1019
' weave. Default is knit; metaweave and'
1020
' weave are deprecated',
1021
type=get_format_type),
1022
]
1023
def run(self, location=None, format=None):
1024
if format is None:
1025
format = get_format_type('default')
727
1026
if location is None:
728
1027
location = u'.'
1028
1029
to_transport = transport.get_transport(location)
1030
1031
# The path has to exist to initialize a
1032
# branch inside of it.
1033
# Just using os.mkdir, since I don't
1034
# believe that we want to create a bunch of
1035
# locations if the user supplies an extended path
1036
# TODO: create-prefix
1037
try:
1038
to_transport.mkdir('.')
1039
except errors.FileExists:
1040
pass
1041
1042
try:
1043
existing_bzrdir = bzrdir.BzrDir.open(location)
1044
except NotBranchError:
1045
# really a NotBzrDir error...
1046
bzrdir.BzrDir.create_branch_convenience(location, format=format)
729
1047
else:
730
# The path has to exist to initialize a
731
# branch inside of it.
732
# Just using os.mkdir, since I don't
733
# believe that we want to create a bunch of
734
# locations if the user supplies an extended path
735
if not os.path.exists(location):
736
os.mkdir(location)
737
Branch.initialize(location)
1048
if existing_bzrdir.has_branch():
1049
if (isinstance(to_transport, LocalTransport)
1050
and not existing_bzrdir.has_workingtree()):
1051
raise errors.BranchExistsWithoutWorkingTree(location)
1052
raise errors.AlreadyBranchError(location)
1053
else:
1054
existing_bzrdir.create_branch()
1055
existing_bzrdir.create_workingtree()
1056
1057
1058
class cmd_init_repository(Command):
1059
"""Create a shared repository to hold branches.
1060
1061
New branches created under the repository directory will store their revisions
1062
in the repository, not in the branch directory, if the branch format supports
1063
shared storage.
1064
1065
example:
1066
bzr init-repo repo
1067
bzr init repo/trunk
1068
bzr checkout --lightweight repo/trunk trunk-checkout
1069
cd trunk-checkout
1070
(add files here)
1071
"""
1072
takes_args = ["location"]
1073
takes_options = [Option('format',
1074
help='Specify a format for this repository.'
1075
' Current formats are: default, knit,'
1076
' metaweave and weave. Default is knit;'
1077
' metaweave and weave are deprecated',
1078
type=get_format_type),
1079
Option('trees',
1080
help='Allows branches in repository to have'
1081
' a working tree')]
1082
aliases = ["init-repo"]
1083
def run(self, location, format=None, trees=False):
1084
if format is None:
1085
format = get_format_type('default')
1086
1087
if location is None:
1088
location = '.'
1089
1090
to_transport = transport.get_transport(location)
1091
try:
1092
to_transport.mkdir('.')
1093
except errors.FileExists:
1094
pass
1095
1096
newdir = format.initialize_on_transport(to_transport)
1097
repo = newdir.create_repository(shared=True)
1098
repo.set_make_working_trees(trees)
738
1099
739
1100
740
1101
class cmd_diff(Command):
741
"""Show differences in working tree.
1102
"""Show differences in the working tree or between revisions.
742
1103
743
1104
If files are listed, only the changes in those files are listed.
744
1105
Otherwise, all changes for the tree are listed.
745
1106
1107
"bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1108
produces patches suitable for "patch -p1".
1109
746
1110
examples:
747
1111
bzr diff
1112
Shows the difference in the working tree versus the last commit
748
1113
bzr diff -r1
1114
Difference between the working tree and revision 1
749
1115
bzr diff -r1..2
1116
Difference between revision 2 and revision 1
1117
bzr diff --diff-prefix old/:new/
1118
Same as 'bzr diff' but prefix paths with old/ and new/
1119
bzr diff bzr.mine bzr.dev
1120
Show the differences between the two working trees
1121
bzr diff foo.c
1122
Show just the differences for 'foo.c'
750
1123
"""
751
# TODO: Allow diff across branches.
752
1124
# TODO: Option to use external diff command; could be GNU diff, wdiff,
753
1125
# or a graphical diff.
754
1126
755
1127
# TODO: Python difflib is not exactly the same as unidiff; should
756
1128
# either fix it up or prefer to use an external diff.
757
1129
758
# TODO: If a directory is given, diff everything under that.
759
760
1130
# TODO: Selected-file diff is inefficient and doesn't show you
761
1131
# deleted files.
762
1132
763
1133
# TODO: This probably handles non-Unix newlines poorly.
764
1134
765
1135
takes_args = ['file*']
766
takes_options = ['revision', 'diff-options']
1136
takes_options = ['revision', 'diff-options', 'prefix']
767
1137
aliases = ['di', 'dif']
1138
encoding_type = 'exact'
768
1139
769
1140
@display_command
770
def run(self, revision=None, file_list=None, diff_options=None):
771
from bzrlib.diff import show_diff
1141
def run(self, revision=None, file_list=None, diff_options=None,
1142
prefix=None):
1143
from bzrlib.diff import diff_cmd_helper, show_diff_trees
1144
1145
if (prefix is None) or (prefix == '0'):
1146
# diff -p0 format
1147
old_label = ''
1148
new_label = ''
1149
elif prefix == '1':
1150
old_label = 'old/'
1151
new_label = 'new/'
1152
else:
1153
if not ':' in prefix:
1154
raise BzrError("--diff-prefix expects two values separated by a colon")
1155
old_label, new_label = prefix.split(":")
1156
772
1157
try:
773
tree, file_list = internal_tree_files(file_list)
1158
tree1, file_list = internal_tree_files(file_list)
1159
tree2 = None
774
1160
b = None
775
1161
b2 = None
776
1162
except FileInWrongBranch:
777
1163
if len(file_list) != 2:
778
1164
raise BzrCommandError("Files are in different branches")
779
1165
780
b, file1 = Branch.open_containing(file_list[0])
781
b2, file2 = Branch.open_containing(file_list[1])
1166
tree1, file1 = WorkingTree.open_containing(file_list[0])
1167
tree2, file2 = WorkingTree.open_containing(file_list[1])
782
1168
if file1 != "" or file2 != "":
783
1169
# FIXME diff those two files. rbc 20051123
784
1170
raise BzrCommandError("Files are in different branches")
785
1171
file_list = None
1172
except NotBranchError:
1173
if (revision is not None and len(revision) == 2
1174
and not revision[0].needs_branch()
1175
and not revision[1].needs_branch()):
1176
# If both revision specs include a branch, we can
1177
# diff them without needing a local working tree
1178
tree1, tree2 = None, None
1179
else:
1180
raise
786
1181
if revision is not None:
787
if b2 is not None:
1182
if tree2 is not None:
788
1183
raise BzrCommandError("Can't specify -r with two branches")
789
1184
if (len(revision) == 1) or (revision[1].spec is None):
790
return show_diff(tree.branch, revision[0], specific_files=file_list,
791
external_diff_options=diff_options)
1185
return diff_cmd_helper(tree1, file_list, diff_options,
1186
revision[0],
1187
old_label=old_label, new_label=new_label)
792
1188
elif len(revision) == 2:
793
return show_diff(tree.branch, revision[0], specific_files=file_list,
794
external_diff_options=diff_options,
795
revision2=revision[1])
1189
return diff_cmd_helper(tree1, file_list, diff_options,
1190
revision[0], revision[1],
1191
old_label=old_label, new_label=new_label)
796
1192
else:
797
1193
raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')
798
1194
else:
799
if b is not None:
800
return show_diff(b, None, specific_files=file_list,
801
external_diff_options=diff_options, b2=b2)
1195
if tree2 is not None:
1196
return show_diff_trees(tree1, tree2, sys.stdout,
1197
specific_files=file_list,
1198
external_diff_options=diff_options,
1199
old_label=old_label, new_label=new_label)
802
1200
else:
803
return show_diff(tree.branch, None, specific_files=file_list,
804
external_diff_options=diff_options)
1201
return diff_cmd_helper(tree1, file_list, diff_options,
1202
old_label=old_label, new_label=new_label)
805
1203
806
1204
807
1205
class cmd_deleted(Command):
813
1211
# directories with readdir, rather than stating each one. Same
814
1212
# level of effort but possibly much less IO. (Or possibly not,
815
1213
# if the directories are very large...)
1214
takes_options = ['show-ids']
1215
816
1216
@display_command
817
1217
def run(self, show_ids=False):
818
1218
tree = WorkingTree.open_containing(u'.')[0]
819
old = tree.branch.basis_tree()
1219
old = tree.basis_tree()
820
1220
for path, ie in old.inventory.iter_entries():
821
1221
if not tree.has_id(ie.file_id):
1222
self.outf.write(path)
822
1223
if show_ids:
823
print '%-50s %s' % (path, ie.file_id)
824
else:
825
print path
1224
self.outf.write(' ')
1225
self.outf.write(ie.file_id)
1226
self.outf.write('\n')
826
1227
827
1228
828
1229
class cmd_modified(Command):
830
1231
hidden = True
831
1232
@display_command
832
1233
def run(self):
833
from bzrlib.delta import compare_trees
834
835
1234
tree = WorkingTree.open_containing(u'.')[0]
836
td = compare_trees(tree.branch.basis_tree(), tree)
837
1235
td = tree.changes_from(tree.basis_tree())
838
1236
for path, id, kind, text_modified, meta_modified in td.modified:
839
print path
840
1237
self.outf.write(path + '\n')
841
1238
842
1239
843
1240
class cmd_added(Command):
846
1243
@display_command
847
1244
def run(self):
848
1245
wt = WorkingTree.open_containing(u'.')[0]
849
basis_inv = wt.branch.basis_tree().inventory
1246
basis_inv = wt.basis_tree().inventory
850
1247
inv = wt.inventory
851
1248
for file_id in inv:
852
1249
if file_id in basis_inv:
853
1250
continue
854
1251
path = inv.id2path(file_id)
855
if not os.access(bzrlib.osutils.abspath(path), os.F_OK):
1252
if not os.access(osutils.abspath(path), os.F_OK):
856
1253
continue
857
print path
858
859
1254
self.outf.write(path + '\n')
1255
860
1256
861
1257
class cmd_root(Command):
862
1258
"""Show the tree root directory.
868
1264
def run(self, filename=None):
869
1265
"""Print the branch root."""
870
1266
tree = WorkingTree.open_containing(filename)[0]
871
print tree.basedir
1267
self.outf.write(tree.basedir + '\n')
872
1268
873
1269
874
1270
class cmd_log(Command):
875
"""Show log of this branch.
1271
"""Show log of a branch, file, or directory.
1272
1273
By default show the log of the branch containing the working directory.
876
1274
877
1275
To request a range of logs, you can use the command -r begin..end
878
1276
-r revision requests a specific revision, -r ..end or -r begin.. are
879
1277
also valid.
1278
1279
examples:
1280
bzr log
1281
bzr log foo.c
1282
bzr log -r -10.. http://server/branch
880
1283
"""
881
1284
882
1285
# TODO: Make --revision support uuid: and hash: [future tag:] notation.
883
1286
884
takes_args = ['filename?']
1287
takes_args = ['location?']
885
1288
takes_options = [Option('forward',
886
1289
help='show from oldest to newest'),
887
'timezone', 'verbose',
1290
'timezone',
1291
Option('verbose',
1292
help='show files changed in each revision'),
888
1293
'show-ids', 'revision',
1294
'log-format',
889
1295
'line', 'long',
890
1296
Option('message',
891
1297
help='show revisions whose message matches this regexp',
892
1298
type=str),
893
1299
'short',
894
1300
]
1301
encoding_type = 'replace'
1302
895
1303
@display_command
896
def run(self, filename=None, timezone='original',
1304
def run(self, location=None, timezone='original',
897
1305
verbose=False,
898
1306
show_ids=False,
899
1307
forward=False,
900
1308
revision=None,
1309
log_format=None,
901
1310
message=None,
902
1311
long=False,
903
1312
short=False,
904
1313
line=False):
905
1314
from bzrlib.log import log_formatter, show_log
906
import codecs
907
1315
assert message is None or isinstance(message, basestring), \
908
1316
"invalid message argument %r" % message
909
1317
direction = (forward and 'forward') or 'reverse'
910
1318
911
if filename:
912
# might be a tree:
913
tree = None
914
try:
915
tree, fp = WorkingTree.open_containing(filename)
916
b = tree.branch
917
if fp != '':
918
inv = tree.read_working_inventory()
919
except NotBranchError:
920
pass
921
if tree is None:
922
b, fp = Branch.open_containing(filename)
923
if fp != '':
924
inv = b.repository.get_inventory(b.last_revision())
1319
# log everything
1320
file_id = None
1321
if location:
1322
# find the file id to log:
1323
1324
dir, fp = bzrdir.BzrDir.open_containing(location)
1325
b = dir.open_branch()
925
1326
if fp != '':
1327
try:
1328
# might be a tree:
1329
inv = dir.open_workingtree().inventory
1330
except (errors.NotBranchError, errors.NotLocalUrl):
1331
# either no tree, or is remote.
1332
inv = b.basis_tree().inventory
926
1333
file_id = inv.path2id(fp)
927
else:
928
file_id = None # points to branch root
929
1334
else:
930
tree, relpath = WorkingTree.open_containing(u'.')
931
b = tree.branch
932
file_id = None
1335
# local dir only
1336
# FIXME ? log the current subdir only RBC 20060203
1337
dir, relpath = bzrdir.BzrDir.open_containing('.')
1338
b = dir.open_branch()
933
1339
934
1340
if revision is None:
935
1341
rev1 = None
937
1343
elif len(revision) == 1:
938
1344
rev1 = rev2 = revision[0].in_history(b).revno
939
1345
elif len(revision) == 2:
940
rev1 = revision[0].in_history(b).revno
941
rev2 = revision[1].in_history(b).revno
1346
if revision[0].spec is None:
1347
# missing begin-range means first revision
1348
rev1 = 1
1349
else:
1350
rev1 = revision[0].in_history(b).revno
1351
1352
if revision[1].spec is None:
1353
# missing end-range means last known revision
1354
rev2 = b.revno()
1355
else:
1356
rev2 = revision[1].in_history(b).revno
942
1357
else:
943
1358
raise BzrCommandError('bzr log --revision takes one or two values.')
944
1359
948
1363
if rev1 > rev2:
949
1364
(rev2, rev1) = (rev1, rev2)
950
1365
951
mutter('encoding log as %r', bzrlib.user_encoding)
952
953
# use 'replace' so that we don't abort if trying to write out
954
# in e.g. the default C locale.
955
outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')
956
957
log_format = get_log_format(long=long, short=short, line=line)
1366
if (log_format == None):
1367
default = b.get_config().log_format()
1368
log_format = get_log_format(long=long, short=short, line=line,
1369
default=default)
958
1370
lf = log_formatter(log_format,
959
1371
show_ids=show_ids,
960
to_file=outf,
1372
to_file=self.outf,
961
1373
show_timezone=timezone)
962
1374
963
1375
show_log(b,
969
1381
end_revision=rev2,
970
1382
search=message)
971
1383
1384
972
1385
def get_log_format(long=False, short=False, line=False, default='long'):
973
1386
log_format = default
974
1387
if long:
983
1396
class cmd_touching_revisions(Command):
984
1397
"""Return revision-ids which affected a particular file.
985
1398
986
A more user-friendly interface is "bzr log FILE"."""
1399
A more user-friendly interface is "bzr log FILE".
1400
"""
1401
987
1402
hidden = True
988
1403
takes_args = ["filename"]
1404
989
1405
@display_command
990
1406
def run(self, filename):
991
1407
tree, relpath = WorkingTree.open_containing(filename)
992
1408
b = tree.branch
993
1409
inv = tree.read_working_inventory()
994
1410
file_id = inv.path2id(relpath)
995
for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):
996
print "%6d %s" % (revno, what)
1411
for revno, revision_id, what in log.find_touching_revisions(b, file_id):
1412
self.outf.write("%6d %s\n" % (revno, what))
997
1413
998
1414
999
1415
class cmd_ls(Command):
1032
1448
if revision is not None:
1033
1449
tree = tree.branch.repository.revision_tree(
1034
1450
revision[0].in_history(tree.branch).rev_id)
1451
1035
1452
for fp, fc, kind, fid, entry in tree.list_files():
1036
1453
if fp.startswith(relpath):
1037
1454
fp = fp[len(relpath):]
1041
1458
continue
1042
1459
if verbose:
1043
1460
kindch = entry.kind_character()
1044
print '%-8s %s%s' % (fc, fp, kindch)
1461
self.outf.write('%-8s %s%s\n' % (fc, fp, kindch))
1045
1462
elif null:
1046
sys.stdout.write(fp)
1047
sys.stdout.write('\0')
1048
sys.stdout.flush()
1463
self.outf.write(fp + '\0')
1464
self.outf.flush()
1049
1465
else:
1050
print fp
1466
self.outf.write(fp + '\n')
1051
1467
1052
1468
1053
1469
class cmd_unknowns(Command):
1054
1470
"""List unknown files."""
1055
1471
@display_command
1056
1472
def run(self):
1057
from bzrlib.osutils import quotefn
1058
1473
for f in WorkingTree.open_containing(u'.')[0].unknowns():
1059
print quotefn(f)
1474
self.outf.write(osutils.quotefn(f) + '\n')
1060
1475
1061
1476
1062
1477
class cmd_ignore(Command):
1078
1493
bzr ignore '*.class'
1079
1494
"""
1080
1495
# TODO: Complain if the filename is absolute
1081
takes_args = ['name_pattern']
1496
takes_args = ['name_pattern?']
1497
takes_options = [
1498
Option('old-default-rules',
1499
help='Out the ignore rules bzr < 0.9 always used.')
1500
]
1082
1501
1083
def run(self, name_pattern):
1502
def run(self, name_pattern=None, old_default_rules=None):
1084
1503
from bzrlib.atomicfile import AtomicFile
1085
import os.path
1086
1504
if old_default_rules is not None:
1505
# dump the rules and exit
1506
for pattern in ignores.OLD_DEFAULTS:
1507
print pattern
1508
return
1509
if name_pattern is None:
1510
raise BzrCommandError("ignore requires a NAME_PATTERN")
1087
1511
tree, relpath = WorkingTree.open_containing(u'.')
1088
1512
ifn = tree.abspath('.bzrignore')
1089
1090
1513
if os.path.exists(ifn):
1091
1514
f = open(ifn, 'rt')
1092
1515
try:
1103
1526
igns += '\n'
1104
1527
igns += name_pattern + '\n'
1105
1528
1529
f = AtomicFile(ifn, 'wt')
1106
1530
try:
1107
f = AtomicFile(ifn, 'wt')
1108
1531
f.write(igns.encode('utf-8'))
1109
1532
f.commit()
1110
1533
finally:
1166
1589
1167
1590
Note: export of tree with non-ascii filenames to zip is not supported.
1168
1591
1169
Supported formats Autodetected by extension
1170
----------------- -------------------------
1592
Supported formats Autodetected by extension
1593
----------------- -------------------------
1171
1594
dir -
1172
1595
tar .tar
1173
1596
tbz2 .tar.bz2, .tbz2
1177
1600
takes_args = ['dest']
1178
1601
takes_options = ['revision', 'format', 'root']
1179
1602
def run(self, dest, revision=None, format=None, root=None):
1180
import os.path
1181
1603
from bzrlib.export import export
1182
1604
tree = WorkingTree.open_containing(u'.')[0]
1183
1605
b = tree.branch
1226
1648
hidden = True
1227
1649
@display_command
1228
1650
def run(self):
1229
print bzrlib.osutils.local_time_offset()
1651
print osutils.local_time_offset()
1230
1652
1231
1653
1232
1654
1262
1684
Option('strict',
1263
1685
help="refuse to commit if there are unknown "
1264
1686
"files in the working tree."),
1687
Option('local',
1688
help="perform a local only commit in a bound "
1689
"branch. Such commits are not pushed to "
1690
"the master branch until a normal commit "
1691
"is performed."
1692
),
1265
1693
]
1266
1694
aliases = ['ci', 'checkin']
1267
1695
1268
1696
def run(self, message=None, file=None, verbose=True, selected_list=None,
1269
unchanged=False, strict=False):
1697
unchanged=False, strict=False, local=False):
1698
from bzrlib.commit import (NullCommitReporter, ReportCommitToLog)
1270
1699
from bzrlib.errors import (PointlessCommit, ConflictsInTree,
1271
1700
StrictCommitFailed)
1272
1701
from bzrlib.msgeditor import edit_commit_message, \
1273
1702
make_commit_message_template
1274
from bzrlib.status import show_status
1275
1703
from tempfile import TemporaryFile
1276
import codecs
1277
1704
1278
1705
# TODO: Need a blackbox test for invoking the external editor; may be
1279
1706
# slightly problematic to run this cross-platform.
1284
1711
# TODO: if the commit *does* happen to fail, then save the commit
1285
1712
# message to a temporary file where it can be recovered
1286
1713
tree, selected_list = tree_files(selected_list)
1714
if selected_list == ['']:
1715
# workaround - commit of root of tree should be exactly the same
1716
# as just default commit in that tree, and succeed even though
1717
# selected-file merge commit is not done yet
1718
selected_list = []
1719
1720
if local and not tree.branch.get_bound_location():
1721
raise errors.LocalRequiresBoundBranch()
1287
1722
if message is None and not file:
1288
1723
template = make_commit_message_template(tree, selected_list)
1289
1724
message = edit_commit_message(template)
1294
1729
raise BzrCommandError("please specify either --message or --file")
1295
1730
1296
1731
if file:
1297
import codecs
1298
1732
message = codecs.open(file, 'rt', bzrlib.user_encoding).read()
1299
1733
1300
1734
if message == "":
1301
raise BzrCommandError("empty commit message specified")
1302
1735
raise BzrCommandError("empty commit message specified")
1736
1737
if verbose:
1738
reporter = ReportCommitToLog()
1739
else:
1740
reporter = NullCommitReporter()
1741
1303
1742
try:
1304
1743
tree.commit(message, specific_files=selected_list,
1305
allow_pointless=unchanged, strict=strict)
1744
allow_pointless=unchanged, strict=strict, local=local,
1745
reporter=reporter)
1306
1746
except PointlessCommit:
1307
1747
# FIXME: This should really happen before the file is read in;
1308
1748
# perhaps prepare the commit; get the message; then actually commit
1309
raise BzrCommandError("no changes to commit",
1310
["use --unchanged to commit anyhow"])
1749
raise BzrCommandError("no changes to commit."
1750
" use --unchanged to commit anyhow")
1311
1751
except ConflictsInTree:
1312
1752
raise BzrCommandError("Conflicts detected in working tree. "
1313
1753
'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')
1314
1754
except StrictCommitFailed:
1315
1755
raise BzrCommandError("Commit refused because there are unknown "
1316
1756
"files in the working tree.")
1317
note('Committed revision %d.' % (tree.branch.revno(),))
1757
except errors.BoundBranchOutOfDate, e:
1758
raise BzrCommandError(str(e)
1759
+ ' Either unbind, update, or'
1760
' pass --local to commit.')
1318
1761
1319
1762
1320
1763
class cmd_check(Command):
1353
1796
1354
1797
if c.needs_write:
1355
1798
c.write()
1356
1357
1799
1358
1800
1359
1801
class cmd_upgrade(Command):
1360
1802
"""Upgrade branch storage to current format.
1361
1803
1362
1804
The check command or bzr developers may sometimes advise you to run
1363
this command.
1364
1365
This version of this command upgrades from the full-text storage
1366
used by bzr 0.0.8 and earlier to the weave format (v5).
1805
this command. When the default format has changed you may also be warned
1806
during other operations to upgrade.
1367
1807
"""
1368
takes_args = ['dir?']
1369
1370
def run(self, dir=u'.'):
1808
takes_args = ['url?']
1809
takes_options = [
1810
Option('format',
1811
help='Upgrade to a specific format. Current formats'
1812
' are: default, knit, metaweave and weave.'
1813
' Default is knit; metaweave and weave are'
1814
' deprecated',
1815
type=get_format_type),
1816
]
1817
1818
1819
def run(self, url='.', format=None):
1371
1820
from bzrlib.upgrade import upgrade
1372
upgrade(dir)
1821
if format is None:
1822
format = get_format_type('default')
1823
upgrade(url, format)
1373
1824
1374
1825
1375
1826
class cmd_whoami(Command):
1376
"""Show bzr user id."""
1377
takes_options = ['email']
1827
"""Show or set bzr user id.
1828
1829
examples:
1830
bzr whoami --email
1831
bzr whoami 'Frank Chu <fchu@example.com>'
1832
"""
1833
takes_options = [ Option('email',
1834
help='display email address only'),
1835
Option('branch',
1836
help='set identity for the current branch instead of '
1837
'globally'),
1838
]
1839
takes_args = ['name?']
1840
encoding_type = 'replace'
1378
1841
1379
1842
@display_command
1380
def run(self, email=False):
1843
def run(self, email=False, branch=False, name=None):
1844
if name is None:
1845
# use branch if we're inside one; otherwise global config
1846
try:
1847
c = Branch.open_containing('.')[0].get_config()
1848
except NotBranchError:
1849
c = config.GlobalConfig()
1850
if email:
1851
self.outf.write(c.user_email() + '\n')
1852
else:
1853
self.outf.write(c.username() + '\n')
1854
return
1855
1856
# display a warning if an email address isn't included in the given name.
1381
1857
try:
1382
b = WorkingTree.open_containing(u'.')[0].branch
1383
config = bzrlib.config.BranchConfig(b)
1384
except NotBranchError:
1385
config = bzrlib.config.GlobalConfig()
1858
config.extract_email_address(name)
1859
except BzrError, e:
1860
warning('"%s" does not seem to contain an email address. '
1861
'This is allowed, but not recommended.', name)
1386
1862
1387
if email:
1388
print config.user_email()
1863
# use global config unless --branch given
1864
if branch:
1865
c = Branch.open_containing('.')[0].get_config()
1389
1866
else:
1390
print config.username()
1867
c = config.GlobalConfig()
1868
c.set_user_option('email', name)
1869
1391
1870
1392
1871
class cmd_nick(Command):
1393
"""\
1394
Print or set the branch nickname.
1872
"""Print or set the branch nickname.
1873
1395
1874
If unset, the tree root directory name is used as the nickname
1396
1875
To print the current nickname, execute with no argument.
1397
1876
"""
1407
1886
def printme(self, branch):
1408
1887
print branch.nick
1409
1888
1889
1410
1890
class cmd_selftest(Command):
1411
1891
"""Run internal test suite.
1412
1892
1417
1897
1418
1898
If arguments are given, they are regular expressions that say
1419
1899
which tests should run.
1900
1901
If the global option '--no-plugins' is given, plugins are not loaded
1902
before running the selftests. This has two effects: features provided or
1903
modified by plugins will not be tested, and tests provided by plugins will
1904
not be run.
1905
1906
examples:
1907
bzr selftest ignore
1908
bzr --no-plugins selftest -v
1420
1909
"""
1421
1910
# TODO: --list should give a list of all available tests
1911
1912
# NB: this is used from the class without creating an instance, which is
1913
# why it does not have a self parameter.
1914
def get_transport_type(typestring):
1915
"""Parse and return a transport specifier."""
1916
if typestring == "sftp":
1917
from bzrlib.transport.sftp import SFTPAbsoluteServer
1918
return SFTPAbsoluteServer
1919
if typestring == "memory":
1920
from bzrlib.transport.memory import MemoryServer
1921
return MemoryServer
1922
if typestring == "fakenfs":
1923
from bzrlib.transport.fakenfs import FakeNFSServer
1924
return FakeNFSServer
1925
msg = "No known transport type %s. Supported types are: sftp\n" %\
1926
(typestring)
1927
raise BzrCommandError(msg)
1928
1422
1929
hidden = True
1423
1930
takes_args = ['testspecs*']
1424
takes_options = ['verbose',
1931
takes_options = ['verbose',
1425
1932
Option('one', help='stop when one test fails'),
1426
1933
Option('keep-output',
1427
help='keep output directories when tests fail')
1428
]
1934
help='keep output directories when tests fail'),
1935
Option('transport',
1936
help='Use a different transport by default '
1937
'throughout the test suite.',
1938
type=get_transport_type),
1939
Option('benchmark', help='run the bzr bencharks.'),
1940
Option('lsprof-timed',
1941
help='generate lsprof output for benchmarked'
1942
' sections of code.'),
1943
]
1429
1944
1430
def run(self, testspecs_list=None, verbose=False, one=False,
1431
keep_output=False):
1945
def run(self, testspecs_list=None, verbose=None, one=False,
1946
keep_output=False, transport=None, benchmark=None,
1947
lsprof_timed=None):
1432
1948
import bzrlib.ui
1433
1949
from bzrlib.tests import selftest
1950
import bzrlib.benchmarks as benchmarks
1434
1951
# we don't want progress meters from the tests to go to the
1435
1952
# real output; and we don't want log messages cluttering up
1436
1953
# the real logs.
1437
save_ui = bzrlib.ui.ui_factory
1438
bzrlib.trace.info('running tests...')
1954
save_ui = ui.ui_factory
1955
print '%10s: %s' % ('bzr', osutils.realpath(sys.argv[0]))
1956
print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])
1957
print
1958
info('running tests...')
1439
1959
try:
1440
bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
1960
ui.ui_factory = ui.SilentUIFactory()
1441
1961
if testspecs_list is not None:
1442
1962
pattern = '|'.join(testspecs_list)
1443
1963
else:
1444
1964
pattern = ".*"
1965
if benchmark:
1966
test_suite_factory = benchmarks.test_suite
1967
if verbose is None:
1968
verbose = True
1969
else:
1970
test_suite_factory = None
1971
if verbose is None:
1972
verbose = False
1445
1973
result = selftest(verbose=verbose,
1446
1974
pattern=pattern,
1447
1975
stop_on_failure=one,
1448
keep_output=keep_output)
1976
keep_output=keep_output,
1977
transport=transport,
1978
test_suite_factory=test_suite_factory,
1979
lsprof_timed=lsprof_timed)
1449
1980
if result:
1450
bzrlib.trace.info('tests passed')
1981
info('tests passed')
1451
1982
else:
1452
bzrlib.trace.info('tests failed')
1983
info('tests failed')
1453
1984
return int(not result)
1454
1985
finally:
1455
bzrlib.ui.ui_factory = save_ui
1986
ui.ui_factory = save_ui
1456
1987
1457
1988
1458
1989
def _get_bzr_branch():
1459
1990
"""If bzr is run from a branch, return Branch or None"""
1460
import bzrlib.errors
1461
from bzrlib.branch import Branch
1462
from bzrlib.osutils import abspath
1463
1991
from os.path import dirname
1464
1992
1465
1993
try:
1466
branch = Branch.open(dirname(abspath(dirname(__file__))))
1994
branch = Branch.open(dirname(osutils.abspath(dirname(__file__))))
1467
1995
return branch
1468
except bzrlib.errors.BzrError:
1996
except errors.BzrError:
1469
1997
return None
1470
1998
1471
1999
1472
2000
def show_version():
1473
print "bzr (bazaar-ng) %s" % bzrlib.__version__
2001
import bzrlib
2002
print "Bazaar (bzr) %s" % bzrlib.__version__
1474
2003
# is bzrlib itself in a branch?
1475
2004
branch = _get_bzr_branch()
1476
2005
if branch:
1480
2009
print " nick: %s" % (branch.nick,)
1481
2010
if rh:
1482
2011
print " revid: %s" % (rh[-1],)
2012
print "Using python interpreter:", sys.executable
2013
import site
2014
print "Using python standard library:", os.path.dirname(site.__file__)
2015
print "Using bzrlib:",
2016
if len(bzrlib.__path__) > 1:
2017
# print repr, which is a good enough way of making it clear it's
2018
# more than one element (eg ['/foo/bar', '/foo/bzr'])
2019
print repr(bzrlib.__path__)
2020
else:
2021
print bzrlib.__path__[0]
2022
2023
print
1483
2024
print bzrlib.__copyright__
1484
print "http://bazaar-ng.org/"
2025
print "http://bazaar-vcs.org/"
1485
2026
print
1486
2027
print "bzr comes with ABSOLUTELY NO WARRANTY. bzr is free software, and"
1487
2028
print "you may use, modify and redistribute it under the terms of the GNU"
1490
2031
1491
2032
class cmd_version(Command):
1492
2033
"""Show version of bzr."""
2034
1493
2035
@display_command
1494
2036
def run(self):
1495
2037
show_version()
1496
2038
2039
1497
2040
class cmd_rocks(Command):
1498
2041
"""Statement of optimism."""
2042
1499
2043
hidden = True
2044
1500
2045
@display_command
1501
2046
def run(self):
1502
2047
print "it sure does!"
1503
2048
1504
2049
1505
2050
class cmd_find_merge_base(Command):
1506
"""Find and print a base revision for merging two branches.
1507
"""
2051
"""Find and print a base revision for merging two branches."""
1508
2052
# TODO: Options to specify revisions on either side, as if
1509
2053
# merging only part of the history.
1510
2054
takes_args = ['branch', 'other']
1523
2067
last1 = branch1.last_revision()
1524
2068
last2 = branch2.last_revision()
1525
2069
1526
source = MultipleRevisionSources(branch1, branch2)
2070
source = MultipleRevisionSources(branch1.repository,
2071
branch2.repository)
1527
2072
1528
2073
base_rev_id = common_ancestor(last1, last2, source)
1529
2074
1530
2075
print 'merge base is revision %s' % base_rev_id
1531
1532
return
1533
1534
if base_revno is None:
1535
raise bzrlib.errors.UnrelatedBranches()
1536
1537
print ' r%-6d in %s' % (base_revno, branch)
1538
1539
other_revno = branch2.revision_id_to_revno(base_revid)
1540
1541
print ' r%-6d in %s' % (other_revno, other)
1542
1543
2076
1544
2077
1545
2078
class cmd_merge(Command):
1546
2079
"""Perform a three-way merge.
1547
2080
1548
The branch is the branch you will merge from. By default, it will
1549
merge the latest revision. If you specify a revision, that
1550
revision will be merged. If you specify two revisions, the first
1551
will be used as a BASE, and the second one as OTHER. Revision
1552
numbers are always relative to the specified branch.
2081
The branch is the branch you will merge from. By default, it will merge
2082
the latest revision. If you specify a revision, that revision will be
2083
merged. If you specify two revisions, the first will be used as a BASE,
2084
and the second one as OTHER. Revision numbers are always relative to the
2085
specified branch.
1553
2086
1554
By default bzr will try to merge in all new work from the other
2087
By default, bzr will try to merge in all new work from the other
1555
2088
branch, automatically determining an appropriate base. If this
1556
2089
fails, you may need to give an explicit base.
1557
2090
2091
Merge will do its best to combine the changes in two branches, but there
2092
are some kinds of problems only a human can fix. When it encounters those,
2093
it will mark a conflict. A conflict means that you need to fix something,
2094
before you should commit.
2095
2096
Use bzr resolve when you have fixed a problem. See also bzr conflicts.
2097
2098
If there is no default branch set, the first merge will set it. After
2099
that, you can omit the branch to use the default. To change the
2100
default, use --remember. The value will only be saved if the remote
2101
location can be accessed.
2102
1558
2103
Examples:
1559
2104
1560
2105
To merge the latest revision from bzr.dev
1568
2113
1569
2114
merge refuses to run if there are any uncommitted changes, unless
1570
2115
--force is given.
2116
2117
The following merge types are available:
1571
2118
"""
1572
2119
takes_args = ['branch?']
1573
takes_options = ['revision', 'force', 'merge-type', 'reprocess',
2120
takes_options = ['revision', 'force', 'merge-type', 'reprocess', 'remember',
1574
2121
Option('show-base', help="Show base revision text in "
1575
2122
"conflicts")]
1576
2123
2124
def help(self):
2125
from merge import merge_type_help
2126
from inspect import getdoc
2127
return getdoc(self) + '\n' + merge_type_help()
2128
1577
2129
def run(self, branch=None, revision=None, force=False, merge_type=None,
1578
show_base=False, reprocess=False):
1579
from bzrlib._merge_core import ApplyMerge3
2130
show_base=False, reprocess=False, remember=False):
1580
2131
if merge_type is None:
1581
merge_type = ApplyMerge3
1582
if branch is None:
1583
branch = WorkingTree.open_containing(u'.')[0].branch.get_parent()
1584
if branch is None:
1585
raise BzrCommandError("No merge location known or specified.")
2132
merge_type = Merge3Merger
2133
2134
tree = WorkingTree.open_containing(u'.')[0]
2135
2136
if branch is not None:
2137
try:
2138
reader = bundle.read_bundle_from_url(branch)
2139
except NotABundle:
2140
pass # Continue on considering this url a Branch
1586
2141
else:
1587
print "Using saved location: %s" % branch
2142
conflicts = merge_bundle(reader, tree, not force, merge_type,
2143
reprocess, show_base)
2144
if conflicts == 0:
2145
return 0
2146
else:
2147
return 1
2148
2149
branch = self._get_remembered_parent(tree, branch, 'Merging from')
2150
1588
2151
if revision is None or len(revision) < 1:
1589
2152
base = [None, None]
1590
2153
other = [branch, -1]
2154
other_branch, path = Branch.open_containing(branch)
1591
2155
else:
1592
2156
if len(revision) == 1:
1593
2157
base = [None, None]
1594
other_branch = Branch.open_containing(branch)[0]
2158
other_branch, path = Branch.open_containing(branch)
1595
2159
revno = revision[0].in_history(other_branch).revno
1596
2160
other = [branch, revno]
1597
2161
else:
1599
2163
if None in revision:
1600
2164
raise BzrCommandError(
1601
2165
"Merge doesn't permit that revision specifier.")
1602
b = Branch.open_containing(branch)[0]
1603
1604
base = [branch, revision[0].in_history(b).revno]
1605
other = [branch, revision[1].in_history(b).revno]
1606
2166
other_branch, path = Branch.open_containing(branch)
2167
2168
base = [branch, revision[0].in_history(other_branch).revno]
2169
other = [branch, revision[1].in_history(other_branch).revno]
2170
2171
if tree.branch.get_parent() is None or remember:
2172
tree.branch.set_parent(other_branch.base)
2173
2174
if path != "":
2175
interesting_files = [path]
2176
else:
2177
interesting_files = None
2178
pb = ui.ui_factory.nested_progress_bar()
1607
2179
try:
1608
conflict_count = merge(other, base, check_clean=(not force),
1609
merge_type=merge_type, reprocess=reprocess,
1610
show_base=show_base)
2180
try:
2181
conflict_count = merge(other, base, check_clean=(not force),
2182
merge_type=merge_type,
2183
reprocess=reprocess,
2184
show_base=show_base,
2185
pb=pb, file_list=interesting_files)
2186
finally:
2187
pb.finished()
1611
2188
if conflict_count != 0:
1612
2189
return 1
1613
2190
else:
1614
2191
return 0
1615
except bzrlib.errors.AmbiguousBase, e:
2192
except errors.AmbiguousBase, e:
1616
2193
m = ("sorry, bzr can't determine the right merge base yet\n"
1617
2194
"candidates are:\n "
1618
2195
+ "\n ".join(e.bases)
1621
2198
"and (if you want) report this to the bzr developers\n")
1622
2199
log_error(m)
1623
2200
2201
# TODO: move up to common parent; this isn't merge-specific anymore.
2202
def _get_remembered_parent(self, tree, supplied_location, verb_string):
2203
"""Use tree.branch's parent if none was supplied.
2204
2205
Report if the remembered location was used.
2206
"""
2207
if supplied_location is not None:
2208
return supplied_location
2209
stored_location = tree.branch.get_parent()
2210
mutter("%s", stored_location)
2211
if stored_location is None:
2212
raise BzrCommandError("No location specified or remembered")
2213
display_url = urlutils.unescape_for_display(stored_location, self.outf.encoding)
2214
self.outf.write("%s remembered location %s\n" % (verb_string, display_url))
2215
return stored_location
2216
1624
2217
1625
2218
class cmd_remerge(Command):
1626
2219
"""Redo a merge.
1627
"""
2220
2221
Use this if you want to try a different merge technique while resolving
2222
conflicts. Some merge techniques are better than others, and remerge
2223
lets you try different ones on different files.
2224
2225
The options for remerge have the same meaning and defaults as the ones for
2226
merge. The difference is that remerge can (only) be run when there is a
2227
pending merge, and it lets you specify particular files.
2228
2229
Examples:
2230
$ bzr remerge --show-base
2231
Re-do the merge of all conflicted files, and show the base text in
2232
conflict regions, in addition to the usual THIS and OTHER texts.
2233
2234
$ bzr remerge --merge-type weave --reprocess foobar
2235
Re-do the merge of "foobar", using the weave merge algorithm, with
2236
additional processing to reduce the size of conflict regions.
2237
2238
The following merge types are available:"""
1628
2239
takes_args = ['file*']
1629
2240
takes_options = ['merge-type', 'reprocess',
1630
2241
Option('show-base', help="Show base revision text in "
1631
2242
"conflicts")]
1632
2243
2244
def help(self):
2245
from merge import merge_type_help
2246
from inspect import getdoc
2247
return getdoc(self) + '\n' + merge_type_help()
2248
1633
2249
def run(self, file_list=None, merge_type=None, show_base=False,
1634
2250
reprocess=False):
1635
2251
from bzrlib.merge import merge_inner, transform_tree
1636
from bzrlib._merge_core import ApplyMerge3
1637
2252
if merge_type is None:
1638
merge_type = ApplyMerge3
2253
merge_type = Merge3Merger
1639
2254
tree, file_list = tree_files(file_list)
1640
2255
tree.lock_write()
1641
2256
try:
1642
2257
pending_merges = tree.pending_merges()
1643
2258
if len(pending_merges) != 1:
1644
2259
raise BzrCommandError("Sorry, remerge only works after normal"
1645
+ " merges. Not cherrypicking or"
1646
+ "multi-merges.")
2260
" merges. Not cherrypicking or"
2261
" multi-merges.")
1647
2262
repository = tree.branch.repository
1648
2263
base_revision = common_ancestor(tree.branch.last_revision(),
1649
2264
pending_merges[0], repository)
1650
2265
base_tree = repository.revision_tree(base_revision)
1651
2266
other_tree = repository.revision_tree(pending_merges[0])
1652
2267
interesting_ids = None
2268
new_conflicts = []
2269
conflicts = tree.conflicts()
1653
2270
if file_list is not None:
1654
2271
interesting_ids = set()
1655
2272
for filename in file_list:
1656
2273
file_id = tree.path2id(filename)
2274
if file_id is None:
2275
raise NotVersionedError(filename)
1657
2276
interesting_ids.add(file_id)
1658
2277
if tree.kind(file_id) != "directory":
1659
2278
continue
1660
2279
1661
2280
for name, ie in tree.inventory.iter_entries(file_id):
1662
2281
interesting_ids.add(ie.file_id)
1663
transform_tree(tree, tree.branch.basis_tree(), interesting_ids)
2282
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
2283
transform_tree(tree, tree.basis_tree(), interesting_ids)
2284
tree.set_conflicts(ConflictList(new_conflicts))
1664
2285
if file_list is None:
1665
2286
restore_files = list(tree.iter_conflicts())
1666
2287
else:
1670
2291
restore(tree.abspath(filename))
1671
2292
except NotConflicted:
1672
2293
pass
1673
conflicts = merge_inner(tree.branch, other_tree, base_tree,
1674
interesting_ids = interesting_ids,
1675
other_rev_id=pending_merges[0],
1676
merge_type=merge_type,
1677
show_base=show_base,
1678
reprocess=reprocess)
2294
conflicts = merge_inner(tree.branch, other_tree, base_tree,
2295
this_tree=tree,
2296
interesting_ids=interesting_ids,
2297
other_rev_id=pending_merges[0],
2298
merge_type=merge_type,
2299
show_base=show_base,
2300
reprocess=reprocess)
1679
2301
finally:
1680
2302
tree.unlock()
1681
2303
if conflicts > 0:
1705
2327
tree, file_list = tree_files(file_list)
1706
2328
if revision is None:
1707
2329
# FIXME should be tree.last_revision
1708
rev_id = tree.branch.last_revision()
2330
rev_id = tree.last_revision()
1709
2331
elif len(revision) != 1:
1710
2332
raise BzrCommandError('bzr revert --revision takes exactly 1 argument')
1711
2333
else:
1712
2334
rev_id = revision[0].in_history(tree.branch).rev_id
1713
tree.revert(file_list, tree.branch.repository.revision_tree(rev_id),
1714
not no_backup)
2335
pb = ui.ui_factory.nested_progress_bar()
2336
try:
2337
tree.revert(file_list,
2338
tree.branch.repository.revision_tree(rev_id),
2339
not no_backup, pb)
2340
finally:
2341
pb.finished()
1715
2342
1716
2343
1717
2344
class cmd_assert_fail(Command):
1725
2352
"""Show help on a command or other topic.
1726
2353
1727
2354
For a list of all available commands, say 'bzr help commands'."""
1728
takes_options = ['long']
2355
takes_options = [Option('long', 'show help on all commands')]
1729
2356
takes_args = ['topic?']
1730
aliases = ['?']
2357
aliases = ['?', '--help', '-?', '-h']
1731
2358
1732
2359
@display_command
1733
2360
def run(self, topic=None, long=False):
1759
2386
takes_args = ['from_branch', 'to_branch']
1760
2387
def run(self, from_branch, to_branch):
1761
2388
from bzrlib.fetch import Fetcher
1762
from bzrlib.branch import Branch
1763
2389
from_b = Branch.open(from_branch)
1764
2390
to_b = Branch.open(to_branch)
1765
2391
Fetcher(to_b, from_b)
1775
2401
'Display changes in the local branch only'),
1776
2402
Option('theirs-only',
1777
2403
'Display changes in the remote branch only'),
2404
'log-format',
1778
2405
'line',
1779
2406
'long',
1780
2407
'short',
1781
2408
'show-ids',
1782
2409
'verbose'
1783
2410
]
2411
encoding_type = 'replace'
1784
2412
2413
@display_command
1785
2414
def run(self, other_branch=None, reverse=False, mine_only=False,
1786
theirs_only=False, long=True, short=False, line=False,
2415
theirs_only=False, log_format=None, long=False, short=False, line=False,
1787
2416
show_ids=False, verbose=False):
1788
2417
from bzrlib.missing import find_unmerged, iter_log_data
1789
2418
from bzrlib.log import log_formatter
1790
local_branch = bzrlib.branch.Branch.open_containing(u".")[0]
2419
local_branch = Branch.open_containing(u".")[0]
1791
2420
parent = local_branch.get_parent()
1792
2421
if other_branch is None:
1793
2422
other_branch = parent
1794
2423
if other_branch is None:
1795
raise BzrCommandError("No missing location known or specified.")
2424
raise BzrCommandError("No peer location known or specified.")
1796
2425
print "Using last location: " + local_branch.get_parent()
1797
remote_branch = bzrlib.branch.Branch.open(other_branch)
1798
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
1799
log_format = get_log_format(long=long, short=short, line=line)
1800
lf = log_formatter(log_format, sys.stdout,
1801
show_ids=show_ids,
1802
show_timezone='original')
1803
if reverse is False:
1804
local_extra.reverse()
1805
remote_extra.reverse()
1806
if local_extra and not theirs_only:
1807
print "You have %d extra revision(s):" % len(local_extra)
1808
for data in iter_log_data(local_extra, local_branch.repository,
1809
verbose):
1810
lf.show(*data)
1811
printed_local = True
1812
else:
1813
printed_local = False
1814
if remote_extra and not mine_only:
1815
if printed_local is True:
1816
print "\n\n"
1817
print "You are missing %d revision(s):" % len(remote_extra)
1818
for data in iter_log_data(remote_extra, remote_branch.repository,
1819
verbose):
1820
lf.show(*data)
1821
if not remote_extra and not local_extra:
1822
status_code = 0
1823
print "Branches are up to date."
1824
else:
1825
status_code = 1
1826
if parent is None and other_branch is not None:
1827
local_branch.set_parent(other_branch)
2426
remote_branch = Branch.open(other_branch)
2427
if remote_branch.base == local_branch.base:
2428
remote_branch = local_branch
2429
local_branch.lock_read()
2430
try:
2431
remote_branch.lock_read()
2432
try:
2433
local_extra, remote_extra = find_unmerged(local_branch, remote_branch)
2434
if (log_format == None):
2435
default = local_branch.get_config().log_format()
2436
log_format = get_log_format(long=long, short=short,
2437
line=line, default=default)
2438
lf = log_formatter(log_format,
2439
to_file=self.outf,
2440
show_ids=show_ids,
2441
show_timezone='original')
2442
if reverse is False:
2443
local_extra.reverse()
2444
remote_extra.reverse()
2445
if local_extra and not theirs_only:
2446
print "You have %d extra revision(s):" % len(local_extra)
2447
for data in iter_log_data(local_extra, local_branch.repository,
2448
verbose):
2449
lf.show(*data)
2450
printed_local = True
2451
else:
2452
printed_local = False
2453
if remote_extra and not mine_only:
2454
if printed_local is True:
2455
print "\n\n"
2456
print "You are missing %d revision(s):" % len(remote_extra)
2457
for data in iter_log_data(remote_extra, remote_branch.repository,
2458
verbose):
2459
lf.show(*data)
2460
if not remote_extra and not local_extra:
2461
status_code = 0
2462
print "Branches are up to date."
2463
else:
2464
status_code = 1
2465
finally:
2466
remote_branch.unlock()
2467
finally:
2468
local_branch.unlock()
2469
if not status_code and parent is None and other_branch is not None:
2470
local_branch.lock_write()
2471
try:
2472
# handle race conditions - a parent might be set while we run.
2473
if local_branch.get_parent() is None:
2474
local_branch.set_parent(remote_branch.base)
2475
finally:
2476
local_branch.unlock()
1828
2477
return status_code
1829
2478
1830
2479
1850
2499
1851
2500
class cmd_testament(Command):
1852
2501
"""Show testament (signing-form) of a revision."""
1853
takes_options = ['revision', 'long']
2502
takes_options = ['revision', 'long',
2503
Option('strict', help='Produce a strict-format'
2504
' testament')]
1854
2505
takes_args = ['branch?']
1855
2506
@display_command
1856
def run(self, branch=u'.', revision=None, long=False):
1857
from bzrlib.testament import Testament
2507
def run(self, branch=u'.', revision=None, long=False, strict=False):
2508
from bzrlib.testament import Testament, StrictTestament
2509
if strict is True:
2510
testament_class = StrictTestament
2511
else:
2512
testament_class = Testament
1858
2513
b = WorkingTree.open_containing(branch)[0].branch
1859
2514
b.lock_read()
1860
2515
try:
1862
2517
rev_id = b.last_revision()
1863
2518
else:
1864
2519
rev_id = revision[0].in_history(b).rev_id
1865
t = Testament.from_revision(b.repository, rev_id)
2520
t = testament_class.from_revision(b.repository, rev_id)
1866
2521
if long:
1867
2522
sys.stdout.writelines(t.as_text_lines())
1868
2523
else:
1881
2536
shown only at the top, unless the --all option is given.
1882
2537
"""
1883
2538
# TODO: annotate directories; showing when each file was last changed
1884
# TODO: annotate a previous version of a file
1885
2539
# TODO: if the working copy is modified, show annotations on that
1886
2540
# with new uncommitted lines marked
1887
aliases = ['blame', 'praise']
2541
aliases = ['ann', 'blame', 'praise']
1888
2542
takes_args = ['filename']
1889
2543
takes_options = [Option('all', help='show annotations on all lines'),
1890
2544
Option('long', help='show date in annotations'),
2545
'revision'
1891
2546
]
1892
2547
1893
2548
@display_command
1894
def run(self, filename, all=False, long=False):
2549
def run(self, filename, all=False, long=False, revision=None):
1895
2550
from bzrlib.annotate import annotate_file
1896
2551
tree, relpath = WorkingTree.open_containing(filename)
1897
2552
branch = tree.branch
1898
2553
branch.lock_read()
1899
2554
try:
2555
if revision is None:
2556
revision_id = branch.last_revision()
2557
elif len(revision) != 1:
2558
raise BzrCommandError('bzr annotate --revision takes exactly 1 argument')
2559
else:
2560
revision_id = revision[0].in_history(branch).rev_id
1900
2561
file_id = tree.inventory.path2id(relpath)
1901
tree = branch.repository.revision_tree(branch.last_revision())
2562
tree = branch.repository.revision_tree(revision_id)
1902
2563
file_version = tree.inventory[file_id].revision
1903
2564
annotate_file(branch, file_version, file_id, long, all, sys.stdout)
1904
2565
finally:
1910
2571
# TODO be able to replace existing ones.
1911
2572
1912
2573
hidden = True # is this right ?
1913
takes_args = ['revision_id?']
2574
takes_args = ['revision_id*']
1914
2575
takes_options = ['revision']
1915
2576
1916
def run(self, revision_id=None, revision=None):
1917
import bzrlib.config as config
2577
def run(self, revision_id_list=None, revision=None):
1918
2578
import bzrlib.gpg as gpg
1919
if revision_id is not None and revision is not None:
2579
if revision_id_list is not None and revision is not None:
1920
2580
raise BzrCommandError('You can only supply one of revision_id or --revision')
1921
if revision_id is None and revision is None:
2581
if revision_id_list is None and revision is None:
1922
2582
raise BzrCommandError('You must supply either --revision or a revision_id')
1923
2583
b = WorkingTree.open_containing(u'.')[0].branch
1924
gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))
1925
if revision_id is not None:
1926
b.repository.sign_revision(revision_id, gpg_strategy)
2584
gpg_strategy = gpg.GPGStrategy(b.get_config())
2585
if revision_id_list is not None:
2586
for revision_id in revision_id_list:
2587
b.repository.sign_revision(revision_id, gpg_strategy)
1927
2588
elif revision is not None:
1928
2589
if len(revision) == 1:
1929
2590
revno, rev_id = revision[0].in_history(b)
1945
2606
raise BzrCommandError('Please supply either one revision, or a range.')
1946
2607
1947
2608
1948
class cmd_uncommit(bzrlib.commands.Command):
2609
class cmd_bind(Command):
2610
"""Bind the current branch to a master branch.
2611
2612
After binding, commits must succeed on the master branch
2613
before they are executed on the local one.
2614
"""
2615
2616
takes_args = ['location']
2617
takes_options = []
2618
2619
def run(self, location=None):
2620
b, relpath = Branch.open_containing(u'.')
2621
b_other = Branch.open(location)
2622
try:
2623
b.bind(b_other)
2624
except DivergedBranches:
2625
raise BzrCommandError('These branches have diverged.'
2626
' Try merging, and then bind again.')
2627
2628
2629
class cmd_unbind(Command):
2630
"""Unbind the current branch from its master branch.
2631
2632
After unbinding, the local branch is considered independent.
2633
All subsequent commits will be local.
2634
"""
2635
2636
takes_args = []
2637
takes_options = []
2638
2639
def run(self):
2640
b, relpath = Branch.open_containing(u'.')
2641
if not b.unbind():
2642
raise BzrCommandError('Local branch is not bound')
2643
2644
2645
class cmd_uncommit(Command):
1949
2646
"""Remove the last committed revision.
1950
2647
1951
By supplying the --all flag, it will not only remove the entry
1952
from revision_history, but also remove all of the entries in the
1953
stores.
1954
1955
2648
--verbose will print out what is being removed.
1956
2649
--dry-run will go through all the motions, but not actually
1957
2650
remove anything.
1958
2651
1959
In the future, uncommit will create a changeset, which can then
2652
In the future, uncommit will create a revision bundle, which can then
1960
2653
be re-applied.
2654
"""
1961
2655
1962
TODO: jam 20060108 Add an option to allow uncommit to remove unreferenced
1963
information in 'branch-as-repostory' branches.
1964
TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
1965
information in shared branches as well.
1966
"""
2656
# TODO: jam 20060108 Add an option to allow uncommit to remove
2657
# unreferenced information in 'branch-as-repository' branches.
2658
# TODO: jam 20060108 Add the ability for uncommit to remove unreferenced
2659
# information in shared branches as well.
1967
2660
takes_options = ['verbose', 'revision',
1968
2661
Option('dry-run', help='Don\'t actually make changes'),
1969
2662
Option('force', help='Say yes to all questions.')]
1970
2663
takes_args = ['location?']
1971
2664
aliases = []
1972
2665
1973
def run(self, location=None,
2666
def run(self, location=None,
1974
2667
dry_run=False, verbose=False,
1975
2668
revision=None, force=False):
1976
from bzrlib.branch import Branch
1977
from bzrlib.log import log_formatter
2669
from bzrlib.log import log_formatter, show_log
1978
2670
import sys
1979
2671
from bzrlib.uncommit import uncommit
1980
2672
1981
2673
if location is None:
1982
2674
location = u'.'
1983
b, relpath = Branch.open_containing(location)
2675
control, relpath = bzrdir.BzrDir.open_containing(location)
2676
try:
2677
tree = control.open_workingtree()
2678
b = tree.branch
2679
except (errors.NoWorkingTree, errors.NotLocalUrl):
2680
tree = None
2681
b = control.open_branch()
1984
2682
2683
rev_id = None
1985
2684
if revision is None:
1986
2685
revno = b.revno()
1987
rev_id = b.last_revision()
1988
2686
else:
1989
revno, rev_id = revision[0].in_history(b)
2687
# 'bzr uncommit -r 10' actually means uncommit
2688
# so that the final tree is at revno 10.
2689
# but bzrlib.uncommit.uncommit() actually uncommits
2690
# the revisions that are supplied.
2691
# So we need to offset it by one
2692
revno = revision[0].in_history(b).revno+1
2693
2694
if revno <= b.revno():
2695
rev_id = b.get_rev_id(revno)
1990
2696
if rev_id is None:
1991
print 'No revisions to uncommit.'
1992
1993
for r in range(revno, b.revno()+1):
1994
rev_id = b.get_rev_id(r)
1995
lf = log_formatter('short', to_file=sys.stdout,show_timezone='original')
1996
lf.show(r, b.repository.get_revision(rev_id), None)
2697
self.outf.write('No revisions to uncommit.\n')
2698
return 1
2699
2700
lf = log_formatter('short',
2701
to_file=self.outf,
2702
show_timezone='original')
2703
2704
show_log(b,
2705
lf,
2706
verbose=False,
2707
direction='forward',
2708
start_revision=revno,
2709
end_revision=b.revno())
1997
2710
1998
2711
if dry_run:
1999
2712
print 'Dry-run, pretending to remove the above revisions.'
2007
2720
print 'Canceled'
2008
2721
return 0
2009
2722
2010
uncommit(b, dry_run=dry_run, verbose=verbose,
2723
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
2011
2724
revno=revno)
2012
2725
2013
2726
2727
class cmd_break_lock(Command):
2728
"""Break a dead lock on a repository, branch or working directory.
2729
2730
CAUTION: Locks should only be broken when you are sure that the process
2731
holding the lock has been stopped.
2732
2733
You can get information on what locks are open via the 'bzr info' command.
2734
2735
example:
2736
bzr break-lock
2737
"""
2738
takes_args = ['location?']
2739
2740
def run(self, location=None, show=False):
2741
if location is None:
2742
location = u'.'
2743
control, relpath = bzrdir.BzrDir.open_containing(location)
2744
try:
2745
control.break_lock()
2746
except NotImplementedError:
2747
pass
2748
2749
2750
2751
# command-line interpretation helper for merge-related commands
2014
2752
def merge(other_revision, base_revision,
2015
2753
check_clean=True, ignore_zero=False,
2016
this_dir=None, backup_files=False, merge_type=ApplyMerge3,
2017
file_list=None, show_base=False, reprocess=False):
2754
this_dir=None, backup_files=False, merge_type=Merge3Merger,
2755
file_list=None, show_base=False, reprocess=False,
2756
pb=DummyProgress()):
2018
2757
"""Merge changes into a tree.
2019
2758
2020
2759
base_revision
2042
2781
clients might prefer to call merge.merge_inner(), which has less magic
2043
2782
behavior.
2044
2783
"""
2045
from bzrlib.merge import Merger, _MergeConflictHandler
2784
from bzrlib.merge import Merger
2046
2785
if this_dir is None:
2047
2786
this_dir = u'.'
2048
this_branch = Branch.open_containing(this_dir)[0]
2049
if show_base and not merge_type is ApplyMerge3:
2787
this_tree = WorkingTree.open_containing(this_dir)[0]
2788
if show_base and not merge_type is Merge3Merger:
2050
2789
raise BzrCommandError("Show-base is not supported for this merge"
2051
2790
" type. %s" % merge_type)
2052
if reprocess and not merge_type is ApplyMerge3:
2053
raise BzrCommandError("Reprocess is not supported for this merge"
2054
" type. %s" % merge_type)
2791
if reprocess and not merge_type.supports_reprocess:
2792
raise BzrCommandError("Conflict reduction is not supported for merge"
2793
" type %s." % merge_type)
2055
2794
if reprocess and show_base:
2056
raise BzrCommandError("Cannot reprocess and show base.")
2057
merger = Merger(this_branch)
2058
merger.check_basis(check_clean)
2059
merger.set_other(other_revision)
2060
merger.set_base(base_revision)
2061
if merger.base_rev_id == merger.other_rev_id:
2062
note('Nothing to do.')
2063
return 0
2064
merger.backup_files = backup_files
2065
merger.merge_type = merge_type
2066
merger.set_interesting_files(file_list)
2067
merger.show_base = show_base
2068
merger.reprocess = reprocess
2069
merger.conflict_handler = _MergeConflictHandler(merger.this_tree,
2070
merger.base_tree,
2071
merger.other_tree,
2072
ignore_zero=ignore_zero)
2073
conflicts = merger.do_merge()
2074
merger.set_pending()
2795
raise BzrCommandError("Cannot do conflict reduction and show base.")
2796
try:
2797
merger = Merger(this_tree.branch, this_tree=this_tree, pb=pb)
2798
merger.pp = ProgressPhase("Merge phase", 5, pb)
2799
merger.pp.next_phase()
2800
merger.check_basis(check_clean)
2801
merger.set_other(other_revision)
2802
merger.pp.next_phase()
2803
merger.set_base(base_revision)
2804
if merger.base_rev_id == merger.other_rev_id:
2805
note('Nothing to do.')
2806
return 0
2807
merger.backup_files = backup_files
2808
merger.merge_type = merge_type
2809
merger.set_interesting_files(file_list)
2810
merger.show_base = show_base
2811
merger.reprocess = reprocess
2812
conflicts = merger.do_merge()
2813
if file_list is None:
2814
merger.set_pending()
2815
finally:
2816
pb.clear()
2075
2817
return conflicts
2076
2818
2077
2819
2078
2820
# these get imported and then picked up by the scan for cmd_*
2079
2821
# TODO: Some more consistent way to split command definitions across files;
2080
2822
# we do need to load at least some information about them to know of
2081
# aliases.
2823
# aliases. ideally we would avoid loading the implementation until the
2824
# details were needed.
2082
2825
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
2826
from bzrlib.bundle.commands import cmd_bundle_revisions
2827
from bzrlib.sign_my_commits import cmd_sign_my_commits
2828
from bzrlib.weave_commands import cmd_weave_list, cmd_weave_join, \
2829
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.1