« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 4869.3.20
- compare with another revision
- compare with revision 4011.6.1
- download diff
- download tarball
- view history from revision 4869.3.20
- Committer: Andrew Bennetts
- Date: 2010-01-15 03:58:20 UTC
- mfrom: (4963 +trunk)
- mto: (4973.1.1 integration)
- mto: This revision was merged to the branch mainline in revision 4975.
- Revision ID: andrew.bennetts@canonical.com-20100115035820-ilb3t36swgzq6v1l
Merge lp:bzr.
- files added:
- MANIFEST.in
- bzrlib/help_topics/es
- contrib/debian
- files renamed:
- bzrlib/help_topics/en/conflicts.txt => bzrlib/help_topics/en/conflict-types.txt
- doc/es/user-guide/resolving_conflicts.txt => bzrlib/help_topics/es/conflicts.txt
- bzrlib/tests/test_bencode.py => bzrlib/tests/test__bencode.py
- files modified:
- Makefile
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Canonical Ltd
1
# Copyright (C) 2004-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
31
31
bundle,
32
32
btree_index,
33
33
bzrdir,
34
directory_service,
34
35
delta,
35
36
config,
36
37
errors,
501
502
wt.lock_read()
502
503
except (errors.NoWorkingTree, errors.NotLocalUrl):
503
504
raise errors.NoWorkingTree(location)
505
self.add_cleanup(wt.unlock)
506
revid = wt.last_revision()
504
507
try:
505
revid = wt.last_revision()
506
try:
507
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
508
except errors.NoSuchRevision:
509
revno_t = ('???',)
510
revno = ".".join(str(n) for n in revno_t)
511
finally:
512
wt.unlock()
508
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
509
except errors.NoSuchRevision:
510
revno_t = ('???',)
511
revno = ".".join(str(n) for n in revno_t)
513
512
else:
514
513
b = Branch.open_containing(location)[0]
515
514
b.lock_read()
516
try:
517
revno = b.revno()
518
finally:
519
b.unlock()
520
515
self.add_cleanup(b.unlock)
516
revno = b.revno()
517
self.cleanup_now()
521
518
self.outf.write(str(revno) + '\n')
522
519
523
520
545
542
wt = WorkingTree.open_containing(directory)[0]
546
543
b = wt.branch
547
544
wt.lock_read()
545
self.add_cleanup(wt.unlock)
548
546
except (errors.NoWorkingTree, errors.NotLocalUrl):
549
547
wt = None
550
548
b = Branch.open_containing(directory)[0]
551
549
b.lock_read()
552
try:
553
revision_ids = []
554
if revision is not None:
555
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
556
if revision_info_list is not None:
557
for rev_str in revision_info_list:
558
rev_spec = RevisionSpec.from_string(rev_str)
559
revision_ids.append(rev_spec.as_revision_id(b))
560
# No arguments supplied, default to the last revision
561
if len(revision_ids) == 0:
562
if tree:
563
if wt is None:
564
raise errors.NoWorkingTree(directory)
565
revision_ids.append(wt.last_revision())
566
else:
567
revision_ids.append(b.last_revision())
568
569
revinfos = []
570
maxlen = 0
571
for revision_id in revision_ids:
572
try:
573
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
574
revno = '.'.join(str(i) for i in dotted_revno)
575
except errors.NoSuchRevision:
576
revno = '???'
577
maxlen = max(maxlen, len(revno))
578
revinfos.append([revno, revision_id])
579
finally:
580
if wt is None:
581
b.unlock()
550
self.add_cleanup(b.unlock)
551
revision_ids = []
552
if revision is not None:
553
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
554
if revision_info_list is not None:
555
for rev_str in revision_info_list:
556
rev_spec = RevisionSpec.from_string(rev_str)
557
revision_ids.append(rev_spec.as_revision_id(b))
558
# No arguments supplied, default to the last revision
559
if len(revision_ids) == 0:
560
if tree:
561
if wt is None:
562
raise errors.NoWorkingTree(directory)
563
revision_ids.append(wt.last_revision())
582
564
else:
583
wt.unlock()
584
565
revision_ids.append(b.last_revision())
566
567
revinfos = []
568
maxlen = 0
569
for revision_id in revision_ids:
570
try:
571
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
572
revno = '.'.join(str(i) for i in dotted_revno)
573
except errors.NoSuchRevision:
574
revno = '???'
575
maxlen = max(maxlen, len(revno))
576
revinfos.append([revno, revision_id])
577
578
self.cleanup_now()
585
579
for ri in revinfos:
586
580
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
587
581
659
653
660
654
if base_tree:
661
655
base_tree.lock_read()
662
try:
663
tree, file_list = tree_files_for_add(file_list)
664
added, ignored = tree.smart_add(file_list, not
665
no_recurse, action=action, save=not dry_run)
666
finally:
667
if base_tree is not None:
668
base_tree.unlock()
656
self.add_cleanup(base_tree.unlock)
657
tree, file_list = tree_files_for_add(file_list)
658
added, ignored = tree.smart_add(file_list, not
659
no_recurse, action=action, save=not dry_run)
660
self.cleanup_now()
669
661
if len(ignored) > 0:
670
662
if verbose:
671
663
for glob in sorted(ignored.keys()):
735
727
revision = _get_one_revision('inventory', revision)
736
728
work_tree, file_list = tree_files(file_list)
737
729
work_tree.lock_read()
738
try:
739
if revision is not None:
740
tree = revision.as_tree(work_tree.branch)
741
742
extra_trees = [work_tree]
743
tree.lock_read()
744
else:
745
tree = work_tree
746
extra_trees = []
747
748
if file_list is not None:
749
file_ids = tree.paths2ids(file_list, trees=extra_trees,
750
require_versioned=True)
751
# find_ids_across_trees may include some paths that don't
752
# exist in 'tree'.
753
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
754
for file_id in file_ids if file_id in tree)
755
else:
756
entries = tree.inventory.entries()
757
finally:
758
tree.unlock()
759
if tree is not work_tree:
760
work_tree.unlock()
761
730
self.add_cleanup(work_tree.unlock)
731
if revision is not None:
732
tree = revision.as_tree(work_tree.branch)
733
734
extra_trees = [work_tree]
735
tree.lock_read()
736
self.add_cleanup(tree.unlock)
737
else:
738
tree = work_tree
739
extra_trees = []
740
741
if file_list is not None:
742
file_ids = tree.paths2ids(file_list, trees=extra_trees,
743
require_versioned=True)
744
# find_ids_across_trees may include some paths that don't
745
# exist in 'tree'.
746
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
747
for file_id in file_ids if file_id in tree)
748
else:
749
entries = tree.inventory.entries()
750
751
self.cleanup_now()
762
752
for path, entry in entries:
763
753
if kind and kind != entry.kind:
764
754
continue
810
800
raise errors.BzrCommandError("missing file argument")
811
801
tree, rel_names = tree_files(names_list, canonicalize=False)
812
802
tree.lock_tree_write()
813
try:
814
self._run(tree, names_list, rel_names, after)
815
finally:
816
tree.unlock()
803
self.add_cleanup(tree.unlock)
804
self._run(tree, names_list, rel_names, after)
817
805
818
806
def run_auto(self, names_list, after, dry_run):
819
807
if names_list is not None and len(names_list) > 1:
824
812
' --auto.')
825
813
work_tree, file_list = tree_files(names_list, default_branch='.')
826
814
work_tree.lock_tree_write()
827
try:
828
rename_map.RenameMap.guess_renames(work_tree, dry_run)
829
finally:
830
work_tree.unlock()
815
self.add_cleanup(work_tree.unlock)
816
rename_map.RenameMap.guess_renames(work_tree, dry_run)
831
817
832
818
def _run(self, tree, names_list, rel_names, after):
833
819
into_existing = osutils.isdir(names_list[-1])
1011
997
1012
998
if branch_from is not branch_to:
1013
999
branch_from.lock_read()
1014
try:
1015
if revision is not None:
1016
revision_id = revision.as_revision_id(branch_from)
1017
1018
branch_to.lock_write()
1019
try:
1020
if tree_to is not None:
1021
view_info = _get_view_info_for_change_reporter(tree_to)
1022
change_reporter = delta._ChangeReporter(
1023
unversioned_filter=tree_to.is_ignored,
1024
view_info=view_info)
1025
result = tree_to.pull(
1026
branch_from, overwrite, revision_id, change_reporter,
1027
possible_transports=possible_transports, local=local)
1028
else:
1029
result = branch_to.pull(
1030
branch_from, overwrite, revision_id, local=local)
1031
1032
result.report(self.outf)
1033
if verbose and result.old_revid != result.new_revid:
1034
log.show_branch_change(
1035
branch_to, self.outf, result.old_revno,
1036
result.old_revid)
1037
finally:
1038
branch_to.unlock()
1039
finally:
1040
if branch_from is not branch_to:
1041
branch_from.unlock()
1000
self.add_cleanup(branch_from.unlock)
1001
if revision is not None:
1002
revision_id = revision.as_revision_id(branch_from)
1003
1004
branch_to.lock_write()
1005
self.add_cleanup(branch_to.unlock)
1006
if tree_to is not None:
1007
view_info = _get_view_info_for_change_reporter(tree_to)
1008
change_reporter = delta._ChangeReporter(
1009
unversioned_filter=tree_to.is_ignored,
1010
view_info=view_info)
1011
result = tree_to.pull(
1012
branch_from, overwrite, revision_id, change_reporter,
1013
possible_transports=possible_transports, local=local)
1014
else:
1015
result = branch_to.pull(
1016
branch_from, overwrite, revision_id, local=local)
1017
1018
result.report(self.outf)
1019
if verbose and result.old_revid != result.new_revid:
1020
log.show_branch_change(
1021
branch_to, self.outf, result.old_revno,
1022
result.old_revid)
1042
1023
1043
1024
1044
1025
class cmd_push(Command):
1199
1180
' directory exists, but does not already'
1200
1181
' have a control directory. This flag will'
1201
1182
' allow branch to proceed.'),
1183
Option('bind',
1184
help="Bind new branch to from location."),
1202
1185
]
1203
1186
aliases = ['get', 'clone']
1204
1187
1205
1188
def run(self, from_location, to_location=None, revision=None,
1206
1189
hardlink=False, stacked=False, standalone=False, no_tree=False,
1207
use_existing_dir=False, switch=False):
1190
use_existing_dir=False, switch=False, bind=False):
1208
1191
from bzrlib import switch as _mod_switch
1209
1192
from bzrlib.tag import _merge_tags_if_possible
1210
1193
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1211
1194
from_location)
1212
1195
revision = _get_one_revision('branch', revision)
1213
1196
br_from.lock_read()
1197
self.add_cleanup(br_from.unlock)
1198
if revision is not None:
1199
revision_id = revision.as_revision_id(br_from)
1200
else:
1201
# FIXME - wt.last_revision, fallback to branch, fall back to
1202
# None or perhaps NULL_REVISION to mean copy nothing
1203
# RBC 20060209
1204
revision_id = br_from.last_revision()
1205
if to_location is None:
1206
to_location = urlutils.derive_to_location(from_location)
1207
to_transport = transport.get_transport(to_location)
1214
1208
try:
1215
if revision is not None:
1216
revision_id = revision.as_revision_id(br_from)
1209
to_transport.mkdir('.')
1210
except errors.FileExists:
1211
if not use_existing_dir:
1212
raise errors.BzrCommandError('Target directory "%s" '
1213
'already exists.' % to_location)
1217
1214
else:
1218
# FIXME - wt.last_revision, fallback to branch, fall back to
1219
# None or perhaps NULL_REVISION to mean copy nothing
1220
# RBC 20060209
1221
revision_id = br_from.last_revision()
1222
if to_location is None:
1223
to_location = urlutils.derive_to_location(from_location)
1224
to_transport = transport.get_transport(to_location)
1225
try:
1226
to_transport.mkdir('.')
1227
except errors.FileExists:
1228
if not use_existing_dir:
1229
raise errors.BzrCommandError('Target directory "%s" '
1230
'already exists.' % to_location)
1215
try:
1216
bzrdir.BzrDir.open_from_transport(to_transport)
1217
except errors.NotBranchError:
1218
pass
1231
1219
else:
1232
try:
1233
bzrdir.BzrDir.open_from_transport(to_transport)
1234
except errors.NotBranchError:
1235
pass
1236
else:
1237
raise errors.AlreadyBranchError(to_location)
1238
except errors.NoSuchFile:
1239
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1240
% to_location)
1241
try:
1242
# preserve whatever source format we have.
1243
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1244
possible_transports=[to_transport],
1245
accelerator_tree=accelerator_tree,
1246
hardlink=hardlink, stacked=stacked,
1247
force_new_repo=standalone,
1248
create_tree_if_local=not no_tree,
1249
source_branch=br_from)
1250
branch = dir.open_branch()
1251
except errors.NoSuchRevision:
1252
to_transport.delete_tree('.')
1253
msg = "The branch %s has no revision %s." % (from_location,
1254
revision)
1255
raise errors.BzrCommandError(msg)
1256
_merge_tags_if_possible(br_from, branch)
1257
# If the source branch is stacked, the new branch may
1258
# be stacked whether we asked for that explicitly or not.
1259
# We therefore need a try/except here and not just 'if stacked:'
1260
try:
1261
note('Created new stacked branch referring to %s.' %
1262
branch.get_stacked_on_url())
1263
except (errors.NotStacked, errors.UnstackableBranchFormat,
1264
errors.UnstackableRepositoryFormat), e:
1265
note('Branched %d revision(s).' % branch.revno())
1266
if switch:
1267
# Switch to the new branch
1268
wt, _ = WorkingTree.open_containing('.')
1269
_mod_switch.switch(wt.bzrdir, branch)
1270
note('Switched to branch: %s',
1271
urlutils.unescape_for_display(branch.base, 'utf-8'))
1272
finally:
1273
br_from.unlock()
1220
raise errors.AlreadyBranchError(to_location)
1221
except errors.NoSuchFile:
1222
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1223
% to_location)
1224
try:
1225
# preserve whatever source format we have.
1226
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1227
possible_transports=[to_transport],
1228
accelerator_tree=accelerator_tree,
1229
hardlink=hardlink, stacked=stacked,
1230
force_new_repo=standalone,
1231
create_tree_if_local=not no_tree,
1232
source_branch=br_from)
1233
branch = dir.open_branch()
1234
except errors.NoSuchRevision:
1235
to_transport.delete_tree('.')
1236
msg = "The branch %s has no revision %s." % (from_location,
1237
revision)
1238
raise errors.BzrCommandError(msg)
1239
_merge_tags_if_possible(br_from, branch)
1240
# If the source branch is stacked, the new branch may
1241
# be stacked whether we asked for that explicitly or not.
1242
# We therefore need a try/except here and not just 'if stacked:'
1243
try:
1244
note('Created new stacked branch referring to %s.' %
1245
branch.get_stacked_on_url())
1246
except (errors.NotStacked, errors.UnstackableBranchFormat,
1247
errors.UnstackableRepositoryFormat), e:
1248
note('Branched %d revision(s).' % branch.revno())
1249
if bind:
1250
# Bind to the parent
1251
parent_branch = Branch.open(from_location)
1252
branch.bind(parent_branch)
1253
note('New branch bound to %s' % from_location)
1254
if switch:
1255
# Switch to the new branch
1256
wt, _ = WorkingTree.open_containing('.')
1257
_mod_switch.switch(wt.bzrdir, branch)
1258
note('Switched to branch: %s',
1259
urlutils.unescape_for_display(branch.base, 'utf-8'))
1274
1260
1275
1261
1276
1262
class cmd_checkout(Command):
1355
1341
def run(self, dir=u'.'):
1356
1342
tree = WorkingTree.open_containing(dir)[0]
1357
1343
tree.lock_read()
1358
try:
1359
new_inv = tree.inventory
1360
old_tree = tree.basis_tree()
1361
old_tree.lock_read()
1362
try:
1363
old_inv = old_tree.inventory
1364
renames = []
1365
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1366
for f, paths, c, v, p, n, k, e in iterator:
1367
if paths[0] == paths[1]:
1368
continue
1369
if None in (paths):
1370
continue
1371
renames.append(paths)
1372
renames.sort()
1373
for old_name, new_name in renames:
1374
self.outf.write("%s => %s\n" % (old_name, new_name))
1375
finally:
1376
old_tree.unlock()
1377
finally:
1378
tree.unlock()
1344
self.add_cleanup(tree.unlock)
1345
new_inv = tree.inventory
1346
old_tree = tree.basis_tree()
1347
old_tree.lock_read()
1348
self.add_cleanup(old_tree.unlock)
1349
old_inv = old_tree.inventory
1350
renames = []
1351
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1352
for f, paths, c, v, p, n, k, e in iterator:
1353
if paths[0] == paths[1]:
1354
continue
1355
if None in (paths):
1356
continue
1357
renames.append(paths)
1358
renames.sort()
1359
for old_name, new_name in renames:
1360
self.outf.write("%s => %s\n" % (old_name, new_name))
1379
1361
1380
1362
1381
1363
class cmd_update(Command):
1387
1369
1388
1370
If you want to discard your local changes, you can just do a
1389
1371
'bzr revert' instead of 'bzr commit' after the update.
1372
1373
If the tree's branch is bound to a master branch, it will also update
1374
the branch from the master.
1390
1375
"""
1391
1376
1392
1377
_see_also = ['pull', 'working-trees', 'status-flags']
1393
1378
takes_args = ['dir?']
1379
takes_options = ['revision']
1394
1380
aliases = ['up']
1395
1381
1396
def run(self, dir='.'):
1382
def run(self, dir='.', revision=None):
1383
if revision is not None and len(revision) != 1:
1384
raise errors.BzrCommandError(
1385
"bzr update --revision takes exactly one revision")
1397
1386
tree = WorkingTree.open_containing(dir)[0]
1387
branch = tree.branch
1398
1388
possible_transports = []
1399
master = tree.branch.get_master_branch(
1389
master = branch.get_master_branch(
1400
1390
possible_transports=possible_transports)
1401
1391
if master is not None:
1402
1392
tree.lock_write()
1393
branch_location = master.base
1403
1394
else:
1404
1395
tree.lock_tree_write()
1396
branch_location = tree.branch.base
1397
self.add_cleanup(tree.unlock)
1398
# get rid of the final '/' and be ready for display
1399
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1400
self.outf.encoding)
1401
existing_pending_merges = tree.get_parent_ids()[1:]
1402
if master is None:
1403
old_tip = None
1404
else:
1405
# may need to fetch data into a heavyweight checkout
1406
# XXX: this may take some time, maybe we should display a
1407
# message
1408
old_tip = branch.update(possible_transports)
1409
if revision is not None:
1410
revision_id = revision[0].as_revision_id(branch)
1411
else:
1412
revision_id = branch.last_revision()
1413
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1414
revno = branch.revision_id_to_revno(revision_id)
1415
note("Tree is up to date at revision %d of branch %s" %
1416
(revno, branch_location))
1417
return 0
1418
view_info = _get_view_info_for_change_reporter(tree)
1419
change_reporter = delta._ChangeReporter(
1420
unversioned_filter=tree.is_ignored,
1421
view_info=view_info)
1405
1422
try:
1406
existing_pending_merges = tree.get_parent_ids()[1:]
1407
last_rev = _mod_revision.ensure_null(tree.last_revision())
1408
if last_rev == _mod_revision.ensure_null(
1409
tree.branch.last_revision()):
1410
# may be up to date, check master too.
1411
if master is None or last_rev == _mod_revision.ensure_null(
1412
master.last_revision()):
1413
revno = tree.branch.revision_id_to_revno(last_rev)
1414
note("Tree is up to date at revision %d." % (revno,))
1415
return 0
1416
view_info = _get_view_info_for_change_reporter(tree)
1417
1423
conflicts = tree.update(
1418
delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1419
view_info=view_info), possible_transports=possible_transports)
1420
revno = tree.branch.revision_id_to_revno(
1421
_mod_revision.ensure_null(tree.last_revision()))
1422
note('Updated to revision %d.' % (revno,))
1423
if tree.get_parent_ids()[1:] != existing_pending_merges:
1424
note('Your local commits will now show as pending merges with '
1425
"'bzr status', and can be committed with 'bzr commit'.")
1426
if conflicts != 0:
1427
return 1
1428
else:
1429
return 0
1430
finally:
1431
tree.unlock()
1424
change_reporter,
1425
possible_transports=possible_transports,
1426
revision=revision_id,
1427
old_tip=old_tip)
1428
except errors.NoSuchRevision, e:
1429
raise errors.BzrCommandError(
1430
"branch has no revision %s\n"
1431
"bzr update --revision only works"
1432
" for a revision in the branch history"
1433
% (e.revision))
1434
revno = tree.branch.revision_id_to_revno(
1435
_mod_revision.ensure_null(tree.last_revision()))
1436
note('Updated to revision %d of branch %s' %
1437
(revno, branch_location))
1438
if tree.get_parent_ids()[1:] != existing_pending_merges:
1439
note('Your local commits will now show as pending merges with '
1440
"'bzr status', and can be committed with 'bzr commit'.")
1441
if conflicts != 0:
1442
return 1
1443
else:
1444
return 0
1432
1445
1433
1446
1434
1447
class cmd_info(Command):
1505
1518
file_list = [f for f in file_list]
1506
1519
1507
1520
tree.lock_write()
1508
try:
1509
# Heuristics should probably all move into tree.remove_smart or
1510
# some such?
1511
if new:
1512
added = tree.changes_from(tree.basis_tree(),
1513
specific_files=file_list).added
1514
file_list = sorted([f[0] for f in added], reverse=True)
1515
if len(file_list) == 0:
1516
raise errors.BzrCommandError('No matching files.')
1517
elif file_list is None:
1518
# missing files show up in iter_changes(basis) as
1519
# versioned-with-no-kind.
1520
missing = []
1521
for change in tree.iter_changes(tree.basis_tree()):
1522
# Find paths in the working tree that have no kind:
1523
if change[1][1] is not None and change[6][1] is None:
1524
missing.append(change[1][1])
1525
file_list = sorted(missing, reverse=True)
1526
file_deletion_strategy = 'keep'
1527
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1528
keep_files=file_deletion_strategy=='keep',
1529
force=file_deletion_strategy=='force')
1530
finally:
1531
tree.unlock()
1521
self.add_cleanup(tree.unlock)
1522
# Heuristics should probably all move into tree.remove_smart or
1523
# some such?
1524
if new:
1525
added = tree.changes_from(tree.basis_tree(),
1526
specific_files=file_list).added
1527
file_list = sorted([f[0] for f in added], reverse=True)
1528
if len(file_list) == 0:
1529
raise errors.BzrCommandError('No matching files.')
1530
elif file_list is None:
1531
# missing files show up in iter_changes(basis) as
1532
# versioned-with-no-kind.
1533
missing = []
1534
for change in tree.iter_changes(tree.basis_tree()):
1535
# Find paths in the working tree that have no kind:
1536
if change[1][1] is not None and change[6][1] is None:
1537
missing.append(change[1][1])
1538
file_list = sorted(missing, reverse=True)
1539
file_deletion_strategy = 'keep'
1540
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1541
keep_files=file_deletion_strategy=='keep',
1542
force=file_deletion_strategy=='force')
1532
1543
1533
1544
1534
1545
class cmd_file_id(Command):
1960
1971
def run(self, show_ids=False):
1961
1972
tree = WorkingTree.open_containing(u'.')[0]
1962
1973
tree.lock_read()
1963
try:
1964
old = tree.basis_tree()
1965
old.lock_read()
1966
try:
1967
for path, ie in old.inventory.iter_entries():
1968
if not tree.has_id(ie.file_id):
1969
self.outf.write(path)
1970
if show_ids:
1971
self.outf.write(' ')
1972
self.outf.write(ie.file_id)
1973
self.outf.write('\n')
1974
finally:
1975
old.unlock()
1976
finally:
1977
tree.unlock()
1974
self.add_cleanup(tree.unlock)
1975
old = tree.basis_tree()
1976
old.lock_read()
1977
self.add_cleanup(old.unlock)
1978
for path, ie in old.inventory.iter_entries():
1979
if not tree.has_id(ie.file_id):
1980
self.outf.write(path)
1981
if show_ids:
1982
self.outf.write(' ')
1983
self.outf.write(ie.file_id)
1984
self.outf.write('\n')
1978
1985
1979
1986
1980
1987
class cmd_modified(Command):
2016
2023
def run(self, null=False):
2017
2024
wt = WorkingTree.open_containing(u'.')[0]
2018
2025
wt.lock_read()
2019
try:
2020
basis = wt.basis_tree()
2021
basis.lock_read()
2022
try:
2023
basis_inv = basis.inventory
2024
inv = wt.inventory
2025
for file_id in inv:
2026
if file_id in basis_inv:
2027
continue
2028
if inv.is_root(file_id) and len(basis_inv) == 0:
2029
continue
2030
path = inv.id2path(file_id)
2031
if not os.access(osutils.abspath(path), os.F_OK):
2032
continue
2033
if null:
2034
self.outf.write(path + '\0')
2035
else:
2036
self.outf.write(osutils.quotefn(path) + '\n')
2037
finally:
2038
basis.unlock()
2039
finally:
2040
wt.unlock()
2026
self.add_cleanup(wt.unlock)
2027
basis = wt.basis_tree()
2028
basis.lock_read()
2029
self.add_cleanup(basis.unlock)
2030
basis_inv = basis.inventory
2031
inv = wt.inventory
2032
for file_id in inv:
2033
if file_id in basis_inv:
2034
continue
2035
if inv.is_root(file_id) and len(basis_inv) == 0:
2036
continue
2037
path = inv.id2path(file_id)
2038
if not os.access(osutils.abspath(path), os.F_OK):
2039
continue
2040
if null:
2041
self.outf.write(path + '\0')
2042
else:
2043
self.outf.write(osutils.quotefn(path) + '\n')
2041
2044
2042
2045
2043
2046
class cmd_root(Command):
2301
2304
2302
2305
file_ids = []
2303
2306
filter_by_dir = False
2304
b = None
2305
try:
2306
if file_list:
2307
# find the file ids to log and check for directory filtering
2308
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2309
revision, file_list)
2310
for relpath, file_id, kind in file_info_list:
2311
if file_id is None:
2312
raise errors.BzrCommandError(
2313
"Path unknown at end or start of revision range: %s" %
2314
relpath)
2315
# If the relpath is the top of the tree, we log everything
2316
if relpath == '':
2317
file_ids = []
2318
break
2319
else:
2320
file_ids.append(file_id)
2321
filter_by_dir = filter_by_dir or (
2322
kind in ['directory', 'tree-reference'])
2323
else:
2324
# log everything
2325
# FIXME ? log the current subdir only RBC 20060203
2326
if revision is not None \
2327
and len(revision) > 0 and revision[0].get_branch():
2328
location = revision[0].get_branch()
2307
if file_list:
2308
# find the file ids to log and check for directory filtering
2309
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2310
revision, file_list)
2311
self.add_cleanup(b.unlock)
2312
for relpath, file_id, kind in file_info_list:
2313
if file_id is None:
2314
raise errors.BzrCommandError(
2315
"Path unknown at end or start of revision range: %s" %
2316
relpath)
2317
# If the relpath is the top of the tree, we log everything
2318
if relpath == '':
2319
file_ids = []
2320
break
2329
2321
else:
2330
location = '.'
2331
dir, relpath = bzrdir.BzrDir.open_containing(location)
2332
b = dir.open_branch()
2333
b.lock_read()
2334
rev1, rev2 = _get_revision_range(revision, b, self.name())
2335
2336
# Decide on the type of delta & diff filtering to use
2337
# TODO: add an --all-files option to make this configurable & consistent
2338
if not verbose:
2339
delta_type = None
2340
else:
2341
delta_type = 'full'
2342
if not show_diff:
2343
diff_type = None
2344
elif file_ids:
2345
diff_type = 'partial'
2346
else:
2347
diff_type = 'full'
2348
2349
# Build the log formatter
2350
if log_format is None:
2351
log_format = log.log_formatter_registry.get_default(b)
2352
lf = log_format(show_ids=show_ids, to_file=self.outf,
2353
show_timezone=timezone,
2354
delta_format=get_verbosity_level(),
2355
levels=levels,
2356
show_advice=levels is None)
2357
2358
# Choose the algorithm for doing the logging. It's annoying
2359
# having multiple code paths like this but necessary until
2360
# the underlying repository format is faster at generating
2361
# deltas or can provide everything we need from the indices.
2362
# The default algorithm - match-using-deltas - works for
2363
# multiple files and directories and is faster for small
2364
# amounts of history (200 revisions say). However, it's too
2365
# slow for logging a single file in a repository with deep
2366
# history, i.e. > 10K revisions. In the spirit of "do no
2367
# evil when adding features", we continue to use the
2368
# original algorithm - per-file-graph - for the "single
2369
# file that isn't a directory without showing a delta" case.
2370
partial_history = revision and b.repository._format.supports_chks
2371
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2372
or delta_type or partial_history)
2373
2374
# Build the LogRequest and execute it
2375
if len(file_ids) == 0:
2376
file_ids = None
2377
rqst = make_log_request_dict(
2378
direction=direction, specific_fileids=file_ids,
2379
start_revision=rev1, end_revision=rev2, limit=limit,
2380
message_search=message, delta_type=delta_type,
2381
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2382
Logger(b, rqst).show(lf)
2383
finally:
2384
if b is not None:
2385
b.unlock()
2322
file_ids.append(file_id)
2323
filter_by_dir = filter_by_dir or (
2324
kind in ['directory', 'tree-reference'])
2325
else:
2326
# log everything
2327
# FIXME ? log the current subdir only RBC 20060203
2328
if revision is not None \
2329
and len(revision) > 0 and revision[0].get_branch():
2330
location = revision[0].get_branch()
2331
else:
2332
location = '.'
2333
dir, relpath = bzrdir.BzrDir.open_containing(location)
2334
b = dir.open_branch()
2335
b.lock_read()
2336
self.add_cleanup(b.unlock)
2337
rev1, rev2 = _get_revision_range(revision, b, self.name())
2338
2339
# Decide on the type of delta & diff filtering to use
2340
# TODO: add an --all-files option to make this configurable & consistent
2341
if not verbose:
2342
delta_type = None
2343
else:
2344
delta_type = 'full'
2345
if not show_diff:
2346
diff_type = None
2347
elif file_ids:
2348
diff_type = 'partial'
2349
else:
2350
diff_type = 'full'
2351
2352
# Build the log formatter
2353
if log_format is None:
2354
log_format = log.log_formatter_registry.get_default(b)
2355
# Make a non-encoding output to include the diffs - bug 328007
2356
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2357
lf = log_format(show_ids=show_ids, to_file=self.outf,
2358
to_exact_file=unencoded_output,
2359
show_timezone=timezone,
2360
delta_format=get_verbosity_level(),
2361
levels=levels,
2362
show_advice=levels is None)
2363
2364
# Choose the algorithm for doing the logging. It's annoying
2365
# having multiple code paths like this but necessary until
2366
# the underlying repository format is faster at generating
2367
# deltas or can provide everything we need from the indices.
2368
# The default algorithm - match-using-deltas - works for
2369
# multiple files and directories and is faster for small
2370
# amounts of history (200 revisions say). However, it's too
2371
# slow for logging a single file in a repository with deep
2372
# history, i.e. > 10K revisions. In the spirit of "do no
2373
# evil when adding features", we continue to use the
2374
# original algorithm - per-file-graph - for the "single
2375
# file that isn't a directory without showing a delta" case.
2376
partial_history = revision and b.repository._format.supports_chks
2377
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2378
or delta_type or partial_history)
2379
2380
# Build the LogRequest and execute it
2381
if len(file_ids) == 0:
2382
file_ids = None
2383
rqst = make_log_request_dict(
2384
direction=direction, specific_fileids=file_ids,
2385
start_revision=rev1, end_revision=rev2, limit=limit,
2386
message_search=message, delta_type=delta_type,
2387
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2388
Logger(b, rqst).show(lf)
2386
2389
2387
2390
2388
2391
def _get_revision_range(revisionspec_list, branch, command_name):
2455
2458
file_id = tree.path2id(relpath)
2456
2459
b = tree.branch
2457
2460
b.lock_read()
2458
try:
2459
touching_revs = log.find_touching_revisions(b, file_id)
2460
for revno, revision_id, what in touching_revs:
2461
self.outf.write("%6d %s\n" % (revno, what))
2462
finally:
2463
b.unlock()
2461
self.add_cleanup(b.unlock)
2462
touching_revs = log.find_touching_revisions(b, file_id)
2463
for revno, revision_id, what in touching_revs:
2464
self.outf.write("%6d %s\n" % (revno, what))
2464
2465
2465
2466
2466
2467
class cmd_ls(Command):
2533
2534
note("Ignoring files outside view. View is %s" % view_str)
2534
2535
2535
2536
tree.lock_read()
2536
try:
2537
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2538
from_dir=relpath, recursive=recursive):
2539
# Apply additional masking
2540
if not all and not selection[fc]:
2541
continue
2542
if kind is not None and fkind != kind:
2543
continue
2544
if apply_view:
2545
try:
2546
if relpath:
2547
fullpath = osutils.pathjoin(relpath, fp)
2548
else:
2549
fullpath = fp
2550
views.check_path_in_view(tree, fullpath)
2551
except errors.FileOutsideView:
2552
continue
2537
self.add_cleanup(tree.unlock)
2538
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2539
from_dir=relpath, recursive=recursive):
2540
# Apply additional masking
2541
if not all and not selection[fc]:
2542
continue
2543
if kind is not None and fkind != kind:
2544
continue
2545
if apply_view:
2546
try:
2547
if relpath:
2548
fullpath = osutils.pathjoin(relpath, fp)
2549
else:
2550
fullpath = fp
2551
views.check_path_in_view(tree, fullpath)
2552
except errors.FileOutsideView:
2553
continue
2553
2554
2554
# Output the entry
2555
if prefix:
2556
fp = osutils.pathjoin(prefix, fp)
2557
kindch = entry.kind_character()
2558
outstring = fp + kindch
2559
ui.ui_factory.clear_term()
2560
if verbose:
2561
outstring = '%-8s %s' % (fc, outstring)
2562
if show_ids and fid is not None:
2563
outstring = "%-50s %s" % (outstring, fid)
2555
# Output the entry
2556
if prefix:
2557
fp = osutils.pathjoin(prefix, fp)
2558
kindch = entry.kind_character()
2559
outstring = fp + kindch
2560
ui.ui_factory.clear_term()
2561
if verbose:
2562
outstring = '%-8s %s' % (fc, outstring)
2563
if show_ids and fid is not None:
2564
outstring = "%-50s %s" % (outstring, fid)
2565
self.outf.write(outstring + '\n')
2566
elif null:
2567
self.outf.write(fp + '\0')
2568
if show_ids:
2569
if fid is not None:
2570
self.outf.write(fid)
2571
self.outf.write('\0')
2572
self.outf.flush()
2573
else:
2574
if show_ids:
2575
if fid is not None:
2576
my_id = fid
2577
else:
2578
my_id = ''
2579
self.outf.write('%-50s %s\n' % (outstring, my_id))
2580
else:
2564
2581
self.outf.write(outstring + '\n')
2565
elif null:
2566
self.outf.write(fp + '\0')
2567
if show_ids:
2568
if fid is not None:
2569
self.outf.write(fid)
2570
self.outf.write('\0')
2571
self.outf.flush()
2572
else:
2573
if show_ids:
2574
if fid is not None:
2575
my_id = fid
2576
else:
2577
my_id = ''
2578
self.outf.write('%-50s %s\n' % (outstring, my_id))
2579
else:
2580
self.outf.write(outstring + '\n')
2581
finally:
2582
tree.unlock()
2583
2582
2584
2583
2585
2584
class cmd_unknowns(Command):
2697
2696
def run(self):
2698
2697
tree = WorkingTree.open_containing(u'.')[0]
2699
2698
tree.lock_read()
2700
try:
2701
for path, file_class, kind, file_id, entry in tree.list_files():
2702
if file_class != 'I':
2703
continue
2704
## XXX: Slightly inefficient since this was already calculated
2705
pat = tree.is_ignored(path)
2706
self.outf.write('%-50s %s\n' % (path, pat))
2707
finally:
2708
tree.unlock()
2699
self.add_cleanup(tree.unlock)
2700
for path, file_class, kind, file_id, entry in tree.list_files():
2701
if file_class != 'I':
2702
continue
2703
## XXX: Slightly inefficient since this was already calculated
2704
pat = tree.is_ignored(path)
2705
self.outf.write('%-50s %s\n' % (path, pat))
2709
2706
2710
2707
2711
2708
class cmd_lookup_revision(Command):
2814
2811
tree, branch, relpath = \
2815
2812
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2816
2813
branch.lock_read()
2817
try:
2818
return self._run(tree, branch, relpath, filename, revision,
2819
name_from_revision, filters)
2820
finally:
2821
branch.unlock()
2814
self.add_cleanup(branch.unlock)
2815
return self._run(tree, branch, relpath, filename, revision,
2816
name_from_revision, filters)
2822
2817
2823
2818
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2824
2819
filtered):
2825
2820
if tree is None:
2826
2821
tree = b.basis_tree()
2827
2822
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2823
rev_tree.lock_read()
2824
self.add_cleanup(rev_tree.unlock)
2828
2825
2829
2826
old_file_id = rev_tree.path2id(relpath)
2830
2827
2865
2862
chunks = content.splitlines(True)
2866
2863
content = filtered_output_bytes(chunks, filters,
2867
2864
ContentFilterContext(relpath, rev_tree))
2865
self.cleanup_now()
2868
2866
self.outf.writelines(content)
2869
2867
else:
2868
self.cleanup_now()
2870
2869
self.outf.write(content)
2871
2870
2872
2871
3066
3065
if local and not tree.branch.get_bound_location():
3067
3066
raise errors.LocalRequiresBoundBranch()
3068
3067
3068
if message is not None:
3069
try:
3070
file_exists = osutils.lexists(message)
3071
except UnicodeError:
3072
# The commit message contains unicode characters that can't be
3073
# represented in the filesystem encoding, so that can't be a
3074
# file.
3075
file_exists = False
3076
if file_exists:
3077
warning_msg = (
3078
'The commit message is a file name: "%(f)s".\n'
3079
'(use --file "%(f)s" to take commit message from that file)'
3080
% { 'f': message })
3081
ui.ui_factory.show_warning(warning_msg)
3082
3069
3083
def get_message(commit_obj):
3070
3084
"""Callback to get commit message"""
3071
3085
my_message = message
3518
3532
verbose = not is_quiet()
3519
3533
# TODO: should possibly lock the history file...
3520
3534
benchfile = open(".perf_history", "at", buffering=1)
3535
self.add_cleanup(benchfile.close)
3521
3536
else:
3522
3537
test_suite_factory = None
3523
3538
benchfile = None
3524
try:
3525
selftest_kwargs = {"verbose": verbose,
3526
"pattern": pattern,
3527
"stop_on_failure": one,
3528
"transport": transport,
3529
"test_suite_factory": test_suite_factory,
3530
"lsprof_timed": lsprof_timed,
3531
"lsprof_tests": lsprof_tests,
3532
"bench_history": benchfile,
3533
"matching_tests_first": first,
3534
"list_only": list_only,
3535
"random_seed": randomize,
3536
"exclude_pattern": exclude,
3537
"strict": strict,
3538
"load_list": load_list,
3539
"debug_flags": debugflag,
3540
"starting_with": starting_with
3541
}
3542
selftest_kwargs.update(self.additional_selftest_args)
3543
result = selftest(**selftest_kwargs)
3544
finally:
3545
if benchfile is not None:
3546
benchfile.close()
3539
selftest_kwargs = {"verbose": verbose,
3540
"pattern": pattern,
3541
"stop_on_failure": one,
3542
"transport": transport,
3543
"test_suite_factory": test_suite_factory,
3544
"lsprof_timed": lsprof_timed,
3545
"lsprof_tests": lsprof_tests,
3546
"bench_history": benchfile,
3547
"matching_tests_first": first,
3548
"list_only": list_only,
3549
"random_seed": randomize,
3550
"exclude_pattern": exclude,
3551
"strict": strict,
3552
"load_list": load_list,
3553
"debug_flags": debugflag,
3554
"starting_with": starting_with
3555
}
3556
selftest_kwargs.update(self.additional_selftest_args)
3557
result = selftest(**selftest_kwargs)
3547
3558
return int(not result)
3548
3559
3549
3560
3588
3599
branch1 = Branch.open_containing(branch)[0]
3589
3600
branch2 = Branch.open_containing(other)[0]
3590
3601
branch1.lock_read()
3591
try:
3592
branch2.lock_read()
3593
try:
3594
last1 = ensure_null(branch1.last_revision())
3595
last2 = ensure_null(branch2.last_revision())
3596
3597
graph = branch1.repository.get_graph(branch2.repository)
3598
base_rev_id = graph.find_unique_lca(last1, last2)
3599
3600
print 'merge base is revision %s' % base_rev_id
3601
finally:
3602
branch2.unlock()
3603
finally:
3604
branch1.unlock()
3602
self.add_cleanup(branch1.unlock)
3603
branch2.lock_read()
3604
self.add_cleanup(branch2.unlock)
3605
last1 = ensure_null(branch1.last_revision())
3606
last2 = ensure_null(branch2.last_revision())
3607
3608
graph = branch1.repository.get_graph(branch2.repository)
3609
base_rev_id = graph.find_unique_lca(last1, last2)
3610
3611
print 'merge base is revision %s' % base_rev_id
3605
3612
3606
3613
3607
3614
class cmd_merge(Command):
3724
3731
view_info = _get_view_info_for_change_reporter(tree)
3725
3732
change_reporter = delta._ChangeReporter(
3726
3733
unversioned_filter=tree.is_ignored, view_info=view_info)
3727
cleanups = []
3728
try:
3729
pb = ui.ui_factory.nested_progress_bar()
3730
cleanups.append(pb.finished)
3731
tree.lock_write()
3732
cleanups.append(tree.unlock)
3733
if location is not None:
3734
try:
3735
mergeable = bundle.read_mergeable_from_url(location,
3736
possible_transports=possible_transports)
3737
except errors.NotABundle:
3738
mergeable = None
3739
else:
3740
if uncommitted:
3741
raise errors.BzrCommandError('Cannot use --uncommitted'
3742
' with bundles or merge directives.')
3743
3744
if revision is not None:
3745
raise errors.BzrCommandError(
3746
'Cannot use -r with merge directives or bundles')
3747
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3748
mergeable, pb)
3749
3750
if merger is None and uncommitted:
3751
if revision is not None and len(revision) > 0:
3752
raise errors.BzrCommandError('Cannot use --uncommitted and'
3753
' --revision at the same time.')
3754
merger = self.get_merger_from_uncommitted(tree, location, pb,
3755
cleanups)
3756
allow_pending = False
3757
3758
if merger is None:
3759
merger, allow_pending = self._get_merger_from_branch(tree,
3760
location, revision, remember, possible_transports, pb)
3761
3762
merger.merge_type = merge_type
3763
merger.reprocess = reprocess
3764
merger.show_base = show_base
3765
self.sanity_check_merger(merger)
3766
if (merger.base_rev_id == merger.other_rev_id and
3767
merger.other_rev_id is not None):
3768
note('Nothing to do.')
3734
pb = ui.ui_factory.nested_progress_bar()
3735
self.add_cleanup(pb.finished)
3736
tree.lock_write()
3737
self.add_cleanup(tree.unlock)
3738
if location is not None:
3739
try:
3740
mergeable = bundle.read_mergeable_from_url(location,
3741
possible_transports=possible_transports)
3742
except errors.NotABundle:
3743
mergeable = None
3744
else:
3745
if uncommitted:
3746
raise errors.BzrCommandError('Cannot use --uncommitted'
3747
' with bundles or merge directives.')
3748
3749
if revision is not None:
3750
raise errors.BzrCommandError(
3751
'Cannot use -r with merge directives or bundles')
3752
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3753
mergeable, pb)
3754
3755
if merger is None and uncommitted:
3756
if revision is not None and len(revision) > 0:
3757
raise errors.BzrCommandError('Cannot use --uncommitted and'
3758
' --revision at the same time.')
3759
merger = self.get_merger_from_uncommitted(tree, location, pb)
3760
allow_pending = False
3761
3762
if merger is None:
3763
merger, allow_pending = self._get_merger_from_branch(tree,
3764
location, revision, remember, possible_transports, pb)
3765
3766
merger.merge_type = merge_type
3767
merger.reprocess = reprocess
3768
merger.show_base = show_base
3769
self.sanity_check_merger(merger)
3770
if (merger.base_rev_id == merger.other_rev_id and
3771
merger.other_rev_id is not None):
3772
note('Nothing to do.')
3773
return 0
3774
if pull:
3775
if merger.interesting_files is not None:
3776
raise errors.BzrCommandError('Cannot pull individual files')
3777
if (merger.base_rev_id == tree.last_revision()):
3778
result = tree.pull(merger.other_branch, False,
3779
merger.other_rev_id)
3780
result.report(self.outf)
3769
3781
return 0
3770
if pull:
3771
if merger.interesting_files is not None:
3772
raise errors.BzrCommandError('Cannot pull individual files')
3773
if (merger.base_rev_id == tree.last_revision()):
3774
result = tree.pull(merger.other_branch, False,
3775
merger.other_rev_id)
3776
result.report(self.outf)
3777
return 0
3778
if merger.this_basis is None:
3779
raise errors.BzrCommandError(
3780
"This branch has no commits."
3781
" (perhaps you would prefer 'bzr pull')")
3782
if preview:
3783
return self._do_preview(merger, cleanups)
3784
elif interactive:
3785
return self._do_interactive(merger, cleanups)
3786
else:
3787
return self._do_merge(merger, change_reporter, allow_pending,
3788
verified)
3789
finally:
3790
for cleanup in reversed(cleanups):
3791
cleanup()
3782
if merger.this_basis is None:
3783
raise errors.BzrCommandError(
3784
"This branch has no commits."
3785
" (perhaps you would prefer 'bzr pull')")
3786
if preview:
3787
return self._do_preview(merger)
3788
elif interactive:
3789
return self._do_interactive(merger)
3790
else:
3791
return self._do_merge(merger, change_reporter, allow_pending,
3792
verified)
3792
3793
3793
def _get_preview(self, merger, cleanups):
3794
def _get_preview(self, merger):
3794
3795
tree_merger = merger.make_merger()
3795
3796
tt = tree_merger.make_preview_transform()
3796
cleanups.append(tt.finalize)
3797
self.add_cleanup(tt.finalize)
3797
3798
result_tree = tt.get_preview_tree()
3798
3799
return result_tree
3799
3800
3800
def _do_preview(self, merger, cleanups):
3801
def _do_preview(self, merger):
3801
3802
from bzrlib.diff import show_diff_trees
3802
result_tree = self._get_preview(merger, cleanups)
3803
result_tree = self._get_preview(merger)
3803
3804
show_diff_trees(merger.this_tree, result_tree, self.outf,
3804
3805
old_label='', new_label='')
3805
3806
3815
3816
else:
3816
3817
return 0
3817
3818
3818
def _do_interactive(self, merger, cleanups):
3819
def _do_interactive(self, merger):
3819
3820
"""Perform an interactive merge.
3820
3821
3821
3822
This works by generating a preview tree of the merge, then using
3823
3824
and the preview tree.
3824
3825
"""
3825
3826
from bzrlib import shelf_ui
3826
result_tree = self._get_preview(merger, cleanups)
3827
result_tree = self._get_preview(merger)
3827
3828
writer = bzrlib.option.diff_writer_registry.get()
3828
3829
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
3829
3830
reporter=shelf_ui.ApplyReporter(),
3830
3831
diff_writer=writer(sys.stdout))
3831
shelver.run()
3832
try:
3833
shelver.run()
3834
finally:
3835
shelver.finalize()
3832
3836
3833
3837
def sanity_check_merger(self, merger):
3834
3838
if (merger.show_base and
3894
3898
allow_pending = True
3895
3899
return merger, allow_pending
3896
3900
3897
def get_merger_from_uncommitted(self, tree, location, pb, cleanups):
3901
def get_merger_from_uncommitted(self, tree, location, pb):
3898
3902
"""Get a merger for uncommitted changes.
3899
3903
3900
3904
:param tree: The tree the merger should apply to.
3901
3905
:param location: The location containing uncommitted changes.
3902
3906
:param pb: The progress bar to use for showing progress.
3903
:param cleanups: A list of operations to perform to clean up the
3904
temporary directories, unfinalized objects, etc.
3905
3907
"""
3906
3908
location = self._select_branch_location(tree, location)[0]
3907
3909
other_tree, other_path = WorkingTree.open_containing(location)
3994
3996
merge_type = _mod_merge.Merge3Merger
3995
3997
tree, file_list = tree_files(file_list)
3996
3998
tree.lock_write()
3997
try:
3998
parents = tree.get_parent_ids()
3999
if len(parents) != 2:
4000
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4001
" merges. Not cherrypicking or"
4002
" multi-merges.")
4003
repository = tree.branch.repository
4004
interesting_ids = None
4005
new_conflicts = []
4006
conflicts = tree.conflicts()
4007
if file_list is not None:
4008
interesting_ids = set()
4009
for filename in file_list:
4010
file_id = tree.path2id(filename)
4011
if file_id is None:
4012
raise errors.NotVersionedError(filename)
4013
interesting_ids.add(file_id)
4014
if tree.kind(file_id) != "directory":
4015
continue
3999
self.add_cleanup(tree.unlock)
4000
parents = tree.get_parent_ids()
4001
if len(parents) != 2:
4002
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4003
" merges. Not cherrypicking or"
4004
" multi-merges.")
4005
repository = tree.branch.repository
4006
interesting_ids = None
4007
new_conflicts = []
4008
conflicts = tree.conflicts()
4009
if file_list is not None:
4010
interesting_ids = set()
4011
for filename in file_list:
4012
file_id = tree.path2id(filename)
4013
if file_id is None:
4014
raise errors.NotVersionedError(filename)
4015
interesting_ids.add(file_id)
4016
if tree.kind(file_id) != "directory":
4017
continue
4016
4018
4017
for name, ie in tree.inventory.iter_entries(file_id):
4018
interesting_ids.add(ie.file_id)
4019
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4020
else:
4021
# Remerge only supports resolving contents conflicts
4022
allowed_conflicts = ('text conflict', 'contents conflict')
4023
restore_files = [c.path for c in conflicts
4024
if c.typestring in allowed_conflicts]
4025
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4026
tree.set_conflicts(ConflictList(new_conflicts))
4027
if file_list is not None:
4028
restore_files = file_list
4029
for filename in restore_files:
4030
try:
4031
restore(tree.abspath(filename))
4032
except errors.NotConflicted:
4033
pass
4034
# Disable pending merges, because the file texts we are remerging
4035
# have not had those merges performed. If we use the wrong parents
4036
# list, we imply that the working tree text has seen and rejected
4037
# all the changes from the other tree, when in fact those changes
4038
# have not yet been seen.
4039
pb = ui.ui_factory.nested_progress_bar()
4040
tree.set_parent_ids(parents[:1])
4019
for name, ie in tree.inventory.iter_entries(file_id):
4020
interesting_ids.add(ie.file_id)
4021
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4022
else:
4023
# Remerge only supports resolving contents conflicts
4024
allowed_conflicts = ('text conflict', 'contents conflict')
4025
restore_files = [c.path for c in conflicts
4026
if c.typestring in allowed_conflicts]
4027
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4028
tree.set_conflicts(ConflictList(new_conflicts))
4029
if file_list is not None:
4030
restore_files = file_list
4031
for filename in restore_files:
4041
4032
try:
4042
merger = _mod_merge.Merger.from_revision_ids(pb,
4043
tree, parents[1])
4044
merger.interesting_ids = interesting_ids
4045
merger.merge_type = merge_type
4046
merger.show_base = show_base
4047
merger.reprocess = reprocess
4048
conflicts = merger.do_merge()
4049
finally:
4050
tree.set_parent_ids(parents)
4051
pb.finished()
4033
restore(tree.abspath(filename))
4034
except errors.NotConflicted:
4035
pass
4036
# Disable pending merges, because the file texts we are remerging
4037
# have not had those merges performed. If we use the wrong parents
4038
# list, we imply that the working tree text has seen and rejected
4039
# all the changes from the other tree, when in fact those changes
4040
# have not yet been seen.
4041
pb = ui.ui_factory.nested_progress_bar()
4042
tree.set_parent_ids(parents[:1])
4043
try:
4044
merger = _mod_merge.Merger.from_revision_ids(pb,
4045
tree, parents[1])
4046
merger.interesting_ids = interesting_ids
4047
merger.merge_type = merge_type
4048
merger.show_base = show_base
4049
merger.reprocess = reprocess
4050
conflicts = merger.do_merge()
4052
4051
finally:
4053
tree.unlock()
4052
tree.set_parent_ids(parents)
4053
pb.finished()
4054
4054
if conflicts > 0:
4055
4055
return 1
4056
4056
else:
4115
4115
forget_merges=None):
4116
4116
tree, file_list = tree_files(file_list)
4117
4117
tree.lock_write()
4118
try:
4119
if forget_merges:
4120
tree.set_parent_ids(tree.get_parent_ids()[:1])
4121
else:
4122
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4123
finally:
4124
tree.unlock()
4118
self.add_cleanup(tree.unlock)
4119
if forget_merges:
4120
tree.set_parent_ids(tree.get_parent_ids()[:1])
4121
else:
4122
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4125
4123
4126
4124
@staticmethod
4127
4125
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4278
4276
if remote_branch.base == local_branch.base:
4279
4277
remote_branch = local_branch
4280
4278
4279
local_branch.lock_read()
4280
self.add_cleanup(local_branch.unlock)
4281
4281
local_revid_range = _revision_range_to_revid_range(
4282
4282
_get_revision_range(my_revision, local_branch,
4283
4283
self.name()))
4284
4284
4285
remote_branch.lock_read()
4286
self.add_cleanup(remote_branch.unlock)
4285
4287
remote_revid_range = _revision_range_to_revid_range(
4286
4288
_get_revision_range(revision,
4287
4289
remote_branch, self.name()))
4288
4290
4289
local_branch.lock_read()
4290
try:
4291
remote_branch.lock_read()
4292
try:
4293
local_extra, remote_extra = find_unmerged(
4294
local_branch, remote_branch, restrict,
4295
backward=not reverse,
4296
include_merges=include_merges,
4297
local_revid_range=local_revid_range,
4298
remote_revid_range=remote_revid_range)
4299
4300
if log_format is None:
4301
registry = log.log_formatter_registry
4302
log_format = registry.get_default(local_branch)
4303
lf = log_format(to_file=self.outf,
4304
show_ids=show_ids,
4305
show_timezone='original')
4306
4307
status_code = 0
4308
if local_extra and not theirs_only:
4309
message("You have %d extra revision(s):\n" %
4310
len(local_extra))
4311
for revision in iter_log_revisions(local_extra,
4312
local_branch.repository,
4313
verbose):
4314
lf.log_revision(revision)
4315
printed_local = True
4316
status_code = 1
4317
else:
4318
printed_local = False
4319
4320
if remote_extra and not mine_only:
4321
if printed_local is True:
4322
message("\n\n\n")
4323
message("You are missing %d revision(s):\n" %
4324
len(remote_extra))
4325
for revision in iter_log_revisions(remote_extra,
4326
remote_branch.repository,
4327
verbose):
4328
lf.log_revision(revision)
4329
status_code = 1
4330
4331
if mine_only and not local_extra:
4332
# We checked local, and found nothing extra
4333
message('This branch is up to date.\n')
4334
elif theirs_only and not remote_extra:
4335
# We checked remote, and found nothing extra
4336
message('Other branch is up to date.\n')
4337
elif not (mine_only or theirs_only or local_extra or
4338
remote_extra):
4339
# We checked both branches, and neither one had extra
4340
# revisions
4341
message("Branches are up to date.\n")
4342
finally:
4343
remote_branch.unlock()
4344
finally:
4345
local_branch.unlock()
4291
local_extra, remote_extra = find_unmerged(
4292
local_branch, remote_branch, restrict,
4293
backward=not reverse,
4294
include_merges=include_merges,
4295
local_revid_range=local_revid_range,
4296
remote_revid_range=remote_revid_range)
4297
4298
if log_format is None:
4299
registry = log.log_formatter_registry
4300
log_format = registry.get_default(local_branch)
4301
lf = log_format(to_file=self.outf,
4302
show_ids=show_ids,
4303
show_timezone='original')
4304
4305
status_code = 0
4306
if local_extra and not theirs_only:
4307
message("You have %d extra revision(s):\n" %
4308
len(local_extra))
4309
for revision in iter_log_revisions(local_extra,
4310
local_branch.repository,
4311
verbose):
4312
lf.log_revision(revision)
4313
printed_local = True
4314
status_code = 1
4315
else:
4316
printed_local = False
4317
4318
if remote_extra and not mine_only:
4319
if printed_local is True:
4320
message("\n\n\n")
4321
message("You are missing %d revision(s):\n" %
4322
len(remote_extra))
4323
for revision in iter_log_revisions(remote_extra,
4324
remote_branch.repository,
4325
verbose):
4326
lf.log_revision(revision)
4327
status_code = 1
4328
4329
if mine_only and not local_extra:
4330
# We checked local, and found nothing extra
4331
message('This branch is up to date.\n')
4332
elif theirs_only and not remote_extra:
4333
# We checked remote, and found nothing extra
4334
message('Other branch is up to date.\n')
4335
elif not (mine_only or theirs_only or local_extra or
4336
remote_extra):
4337
# We checked both branches, and neither one had extra
4338
# revisions
4339
message("Branches are up to date.\n")
4340
self.cleanup_now()
4346
4341
if not status_code and parent is None and other_branch is not None:
4347
4342
local_branch.lock_write()
4348
try:
4349
# handle race conditions - a parent might be set while we run.
4350
if local_branch.get_parent() is None:
4351
local_branch.set_parent(remote_branch.base)
4352
finally:
4353
local_branch.unlock()
4343
self.add_cleanup(local_branch.unlock)
4344
# handle race conditions - a parent might be set while we run.
4345
if local_branch.get_parent() is None:
4346
local_branch.set_parent(remote_branch.base)
4354
4347
return status_code
4355
4348
4356
4349
4435
4428
else:
4436
4429
b = Branch.open(branch)
4437
4430
b.lock_read()
4438
try:
4439
if revision is None:
4440
rev_id = b.last_revision()
4441
else:
4442
rev_id = revision[0].as_revision_id(b)
4443
t = testament_class.from_revision(b.repository, rev_id)
4444
if long:
4445
sys.stdout.writelines(t.as_text_lines())
4446
else:
4447
sys.stdout.write(t.as_short_text())
4448
finally:
4449
b.unlock()
4431
self.add_cleanup(b.unlock)
4432
if revision is None:
4433
rev_id = b.last_revision()
4434
else:
4435
rev_id = revision[0].as_revision_id(b)
4436
t = testament_class.from_revision(b.repository, rev_id)
4437
if long:
4438
sys.stdout.writelines(t.as_text_lines())
4439
else:
4440
sys.stdout.write(t.as_short_text())
4450
4441
4451
4442
4452
4443
class cmd_annotate(Command):
4478
4469
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4479
4470
if wt is not None:
4480
4471
wt.lock_read()
4472
self.add_cleanup(wt.unlock)
4481
4473
else:
4482
4474
branch.lock_read()
4483
try:
4484
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4485
if wt is not None:
4486
file_id = wt.path2id(relpath)
4487
else:
4488
file_id = tree.path2id(relpath)
4489
if file_id is None:
4490
raise errors.NotVersionedError(filename)
4491
file_version = tree.inventory[file_id].revision
4492
if wt is not None and revision is None:
4493
# If there is a tree and we're not annotating historical
4494
# versions, annotate the working tree's content.
4495
annotate_file_tree(wt, file_id, self.outf, long, all,
4496
show_ids=show_ids)
4497
else:
4498
annotate_file(branch, file_version, file_id, long, all, self.outf,
4499
show_ids=show_ids)
4500
finally:
4501
if wt is not None:
4502
wt.unlock()
4503
else:
4504
branch.unlock()
4475
self.add_cleanup(branch.unlock)
4476
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4477
tree.lock_read()
4478
self.add_cleanup(tree.unlock)
4479
if wt is not None:
4480
file_id = wt.path2id(relpath)
4481
else:
4482
file_id = tree.path2id(relpath)
4483
if file_id is None:
4484
raise errors.NotVersionedError(filename)
4485
file_version = tree.inventory[file_id].revision
4486
if wt is not None and revision is None:
4487
# If there is a tree and we're not annotating historical
4488
# versions, annotate the working tree's content.
4489
annotate_file_tree(wt, file_id, self.outf, long, all,
4490
show_ids=show_ids)
4491
else:
4492
annotate_file(branch, file_version, file_id, long, all, self.outf,
4493
show_ids=show_ids)
4505
4494
4506
4495
4507
4496
class cmd_re_sign(Command):
4519
4508
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4520
4509
b = WorkingTree.open_containing(u'.')[0].branch
4521
4510
b.lock_write()
4522
try:
4523
return self._run(b, revision_id_list, revision)
4524
finally:
4525
b.unlock()
4511
self.add_cleanup(b.unlock)
4512
return self._run(b, revision_id_list, revision)
4526
4513
4527
4514
def _run(self, b, revision_id_list, revision):
4528
4515
import bzrlib.gpg as gpg
4674
4661
4675
4662
if tree is not None:
4676
4663
tree.lock_write()
4664
self.add_cleanup(tree.unlock)
4677
4665
else:
4678
4666
b.lock_write()
4679
try:
4680
return self._run(b, tree, dry_run, verbose, revision, force,
4681
local=local)
4682
finally:
4683
if tree is not None:
4684
tree.unlock()
4685
else:
4686
b.unlock()
4667
self.add_cleanup(b.unlock)
4668
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4687
4669
4688
4670
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4689
4671
from bzrlib.log import log_formatter, show_log
4746
4728
CAUTION: Locks should only be broken when you are sure that the process
4747
4729
holding the lock has been stopped.
4748
4730
4749
You can get information on what locks are open via the 'bzr info' command.
4731
You can get information on what locks are open via the 'bzr info
4732
[location]' command.
4750
4733
4751
4734
:Examples:
4752
4735
bzr break-lock
4736
bzr break-lock bzr+ssh://example.com/bzr/foo
4753
4737
"""
4754
4738
takes_args = ['location?']
4755
4739
5027
5011
directly from the merge directive, without retrieving data from a
5028
5012
branch.
5029
5013
5030
If --no-bundle is specified, then public_branch is needed (and must be
5031
up-to-date), so that the receiver can perform the merge using the
5032
public_branch. The public_branch is always included if known, so that
5033
people can check it later.
5034
5035
The submit branch defaults to the parent, but can be overridden. Both
5036
submit branch and public branch will be remembered if supplied.
5037
5038
If a public_branch is known for the submit_branch, that public submit
5039
branch is used in the merge instructions. This means that a local mirror
5040
can be used as your actual submit branch, once you have set public_branch
5041
for that mirror.
5014
`bzr send` creates a compact data set that, when applied using bzr
5015
merge, has the same effect as merging from the source branch.
5016
5017
By default the merge directive is self-contained and can be applied to any
5018
branch containing submit_branch in its ancestory without needing access to
5019
the source branch.
5020
5021
If --no-bundle is specified, then Bazaar doesn't send the contents of the
5022
revisions, but only a structured request to merge from the
5023
public_location. In that case the public_branch is needed and it must be
5024
up-to-date and accessible to the recipient. The public_branch is always
5025
included if known, so that people can check it later.
5026
5027
The submit branch defaults to the parent of the source branch, but can be
5028
overridden. Both submit branch and public branch will be remembered in
5029
branch.conf the first time they are used for a particular branch. The
5030
source branch defaults to that containing the working directory, but can
5031
be changed using --from.
5032
5033
In order to calculate those changes, bzr must analyse the submit branch.
5034
Therefore it is most efficient for the submit branch to be a local mirror.
5035
If a public location is known for the submit_branch, that location is used
5036
in the merge directive.
5037
5038
The default behaviour is to send the merge directive by mail, unless -o is
5039
given, in which case it is sent to a file.
5042
5040
5043
5041
Mail is sent using your preferred mail program. This should be transparent
5044
5042
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5064
5062
5065
5063
The merge directives created by bzr send may be applied using bzr merge or
5066
5064
bzr pull by specifying a file containing a merge directive as the location.
5065
5066
bzr send makes extensive use of public locations to map local locations into
5067
URLs that can be used by other people. See `bzr help configuration` to
5068
set them, and use `bzr info` to display them.
5067
5069
"""
5068
5070
5069
5071
encoding_type = 'exact'
5228
5230
):
5229
5231
branch, relpath = Branch.open_containing(directory)
5230
5232
branch.lock_write()
5231
try:
5232
if delete:
5233
branch.tags.delete_tag(tag_name)
5234
self.outf.write('Deleted tag %s.\n' % tag_name)
5233
self.add_cleanup(branch.unlock)
5234
if delete:
5235
branch.tags.delete_tag(tag_name)
5236
self.outf.write('Deleted tag %s.\n' % tag_name)
5237
else:
5238
if revision:
5239
if len(revision) != 1:
5240
raise errors.BzrCommandError(
5241
"Tags can only be placed on a single revision, "
5242
"not on a range")
5243
revision_id = revision[0].as_revision_id(branch)
5235
5244
else:
5236
if revision:
5237
if len(revision) != 1:
5238
raise errors.BzrCommandError(
5239
"Tags can only be placed on a single revision, "
5240
"not on a range")
5241
revision_id = revision[0].as_revision_id(branch)
5242
else:
5243
revision_id = branch.last_revision()
5244
if (not force) and branch.tags.has_tag(tag_name):
5245
raise errors.TagAlreadyExists(tag_name)
5246
branch.tags.set_tag(tag_name, revision_id)
5247
self.outf.write('Created tag %s.\n' % tag_name)
5248
finally:
5249
branch.unlock()
5245
revision_id = branch.last_revision()
5246
if (not force) and branch.tags.has_tag(tag_name):
5247
raise errors.TagAlreadyExists(tag_name)
5248
branch.tags.set_tag(tag_name, revision_id)
5249
self.outf.write('Created tag %s.\n' % tag_name)
5250
5250
5251
5251
5252
5252
class cmd_tags(Command):
5285
5285
return
5286
5286
5287
5287
branch.lock_read()
5288
try:
5289
if revision:
5290
graph = branch.repository.get_graph()
5291
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5292
revid1, revid2 = rev1.rev_id, rev2.rev_id
5293
# only show revisions between revid1 and revid2 (inclusive)
5294
tags = [(tag, revid) for tag, revid in tags if
5295
graph.is_between(revid, revid1, revid2)]
5296
if sort == 'alpha':
5297
tags.sort()
5298
elif sort == 'time':
5299
timestamps = {}
5300
for tag, revid in tags:
5301
try:
5302
revobj = branch.repository.get_revision(revid)
5303
except errors.NoSuchRevision:
5304
timestamp = sys.maxint # place them at the end
5305
else:
5306
timestamp = revobj.timestamp
5307
timestamps[revid] = timestamp
5308
tags.sort(key=lambda x: timestamps[x[1]])
5309
if not show_ids:
5310
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5311
for index, (tag, revid) in enumerate(tags):
5312
try:
5313
revno = branch.revision_id_to_dotted_revno(revid)
5314
if isinstance(revno, tuple):
5315
revno = '.'.join(map(str, revno))
5316
except errors.NoSuchRevision:
5317
# Bad tag data/merges can lead to tagged revisions
5318
# which are not in this branch. Fail gracefully ...
5319
revno = '?'
5320
tags[index] = (tag, revno)
5321
finally:
5322
branch.unlock()
5288
self.add_cleanup(branch.unlock)
5289
if revision:
5290
graph = branch.repository.get_graph()
5291
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5292
revid1, revid2 = rev1.rev_id, rev2.rev_id
5293
# only show revisions between revid1 and revid2 (inclusive)
5294
tags = [(tag, revid) for tag, revid in tags if
5295
graph.is_between(revid, revid1, revid2)]
5296
if sort == 'alpha':
5297
tags.sort()
5298
elif sort == 'time':
5299
timestamps = {}
5300
for tag, revid in tags:
5301
try:
5302
revobj = branch.repository.get_revision(revid)
5303
except errors.NoSuchRevision:
5304
timestamp = sys.maxint # place them at the end
5305
else:
5306
timestamp = revobj.timestamp
5307
timestamps[revid] = timestamp
5308
tags.sort(key=lambda x: timestamps[x[1]])
5309
if not show_ids:
5310
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5311
for index, (tag, revid) in enumerate(tags):
5312
try:
5313
revno = branch.revision_id_to_dotted_revno(revid)
5314
if isinstance(revno, tuple):
5315
revno = '.'.join(map(str, revno))
5316
except errors.NoSuchRevision:
5317
# Bad tag data/merges can lead to tagged revisions
5318
# which are not in this branch. Fail gracefully ...
5319
revno = '?'
5320
tags[index] = (tag, revno)
5321
self.cleanup_now()
5323
5322
for tag, revspec in tags:
5324
5323
self.outf.write('%-20s %s\n' % (tag, revspec))
5325
5324
5460
5459
if branch is None:
5461
5460
raise errors.BzrCommandError('cannot create branch without'
5462
5461
' source branch')
5462
to_location = directory_service.directories.dereference(
5463
to_location)
5463
5464
if '/' not in to_location and '\\' not in to_location:
5464
5465
# This path is meant to be relative to the existing branch
5465
5466
this_url = self._get_branch_location(control_dir)
5741
5742
def run_for_list(self):
5742
5743
tree = WorkingTree.open_containing('.')[0]
5743
5744
tree.lock_read()
5744
try:
5745
manager = tree.get_shelf_manager()
5746
shelves = manager.active_shelves()
5747
if len(shelves) == 0:
5748
note('No shelved changes.')
5749
return 0
5750
for shelf_id in reversed(shelves):
5751
message = manager.get_metadata(shelf_id).get('message')
5752
if message is None:
5753
message = '<no message>'
5754
self.outf.write('%3d: %s\n' % (shelf_id, message))
5755
return 1
5756
finally:
5757
tree.unlock()
5745
self.add_cleanup(tree.unlock)
5746
manager = tree.get_shelf_manager()
5747
shelves = manager.active_shelves()
5748
if len(shelves) == 0:
5749
note('No shelved changes.')
5750
return 0
5751
for shelf_id in reversed(shelves):
5752
message = manager.get_metadata(shelf_id).get('message')
5753
if message is None:
5754
message = '<no message>'
5755
self.outf.write('%3d: %s\n' % (shelf_id, message))
5756
return 1
5758
5757
5759
5758
5760
5759
class cmd_unshelve(Command):
5772
5771
enum_switch=False, value_switches=True,
5773
5772
apply="Apply changes and remove from the shelf.",
5774
5773
dry_run="Show changes, but do not apply or remove them.",
5775
delete_only="Delete changes without applying them."
5774
preview="Instead of unshelving the changes, show the diff that "
5775
"would result from unshelving.",
5776
delete_only="Delete changes without applying them.",
5777
keep="Apply changes but don't delete them.",
5776
5778
)
5777
5779
]
5778
5780
_see_also = ['shelve']
Loggerhead is a web-based interface for Breezy
Version: 2.0.1