75
74
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
77
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
78
78
def tree_files(file_list, default_branch=u'.', canonicalize=True,
81
return internal_tree_files(file_list, default_branch, canonicalize,
83
except errors.FileInWrongBranch, e:
84
raise errors.BzrCommandError("%s is not in the same branch as %s" %
85
(e.path, file_list[0]))
80
return internal_tree_files(file_list, default_branch, canonicalize,
88
84
def tree_files_for_add(file_list):
153
149
# XXX: Bad function name; should possibly also be a class method of
154
150
# WorkingTree rather than a function.
151
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
155
152
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
156
153
apply_view=True):
157
154
"""Convert command-line paths to a WorkingTree and relative paths.
156
Deprecated: use WorkingTree.open_containing_paths instead.
159
158
This is typically used for command-line processors that take one or
160
159
more filenames, and infer the workingtree that contains them.
172
171
:return: workingtree, [relative_paths]
174
if file_list is None or len(file_list) == 0:
175
tree = WorkingTree.open_containing(default_branch)[0]
176
if tree.supports_views() and apply_view:
177
view_files = tree.views.lookup_view()
179
file_list = view_files
180
view_str = views.view_display_str(view_files)
181
note("Ignoring files outside view. View is %s" % view_str)
182
return tree, file_list
183
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
184
return tree, safe_relpath_files(tree, file_list, canonicalize,
185
apply_view=apply_view)
188
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
189
"""Convert file_list into a list of relpaths in tree.
191
:param tree: A tree to operate on.
192
:param file_list: A list of user provided paths or None.
193
:param apply_view: if True and a view is set, apply it or check that
194
specified files are within it
195
:return: A list of relative paths.
196
:raises errors.PathNotChild: When a provided path is in a different tree
199
if file_list is None:
201
if tree.supports_views() and apply_view:
202
view_files = tree.views.lookup_view()
206
# tree.relpath exists as a "thunk" to osutils, but canonical_relpath
207
# doesn't - fix that up here before we enter the loop.
209
fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
212
for filename in file_list:
214
relpath = fixer(osutils.dereference_path(filename))
215
if view_files and not osutils.is_inside_any(view_files, relpath):
216
raise errors.FileOutsideView(filename, view_files)
217
new_list.append(relpath)
218
except errors.PathNotChild:
219
raise errors.FileInWrongBranch(tree.branch, filename)
173
return WorkingTree.open_containing_paths(
174
file_list, default_directory='.',
223
179
def _get_view_info_for_change_reporter(tree):
191
def _open_directory_or_containing_tree_or_branch(filename, directory):
192
"""Open the tree or branch containing the specified file, unless
193
the --directory option is used to specify a different branch."""
194
if directory is not None:
195
return (None, Branch.open(directory), filename)
196
return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
235
199
# TODO: Make sure no commands unconditionally use the working directory as a
236
200
# branch. If a filename argument is used, the first of them should be used to
237
201
# specify the branch. (Perhaps this can be factored out into some kind of
315
279
raise errors.BzrCommandError('bzr status --revision takes exactly'
316
280
' one or two revision specifiers')
318
tree, relfile_list = tree_files(file_list)
282
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
319
283
# Avoid asking for specific files when that is not needed.
320
284
if relfile_list == ['']:
321
285
relfile_list = None
353
317
self.outf.write(revtext.decode('utf-8'))
356
def run(self, revision_id=None, revision=None):
320
def run(self, revision_id=None, revision=None, directory=u'.'):
357
321
if revision_id is not None and revision is not None:
358
322
raise errors.BzrCommandError('You can only supply one of'
359
323
' revision_id or --revision')
360
324
if revision_id is None and revision is None:
361
325
raise errors.BzrCommandError('You must supply either'
362
326
' --revision or a revision_id')
363
b = WorkingTree.open_containing(u'.')[0].branch
327
b = WorkingTree.open_containing(directory)[0].branch
365
329
revisions = b.repository.revisions
366
330
if revisions is None:
504
468
if (working.has_changes()):
505
469
raise errors.UncommittedChanges(working)
470
if working.get_shelf_manager().last_shelf() is not None:
471
raise errors.ShelvedChanges(working)
507
473
if working.user_url != working.branch.user_url:
508
474
raise errors.BzrCommandError("You cannot remove the working tree"
530
496
wt = WorkingTree.open_containing(location)[0]
497
self.add_cleanup(wt.lock_read().unlock)
532
498
except (errors.NoWorkingTree, errors.NotLocalUrl):
533
499
raise errors.NoWorkingTree(location)
534
self.add_cleanup(wt.unlock)
535
500
revid = wt.last_revision()
537
502
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
540
505
revno = ".".join(str(n) for n in revno_t)
542
507
b = Branch.open_containing(location)[0]
544
self.add_cleanup(b.unlock)
508
self.add_cleanup(b.lock_read().unlock)
545
509
revno = b.revno()
546
510
self.cleanup_now()
547
511
self.outf.write(str(revno) + '\n')
554
518
takes_args = ['revision_info*']
555
519
takes_options = [
521
custom_help('directory',
558
522
help='Branch to examine, '
559
'rather than the one containing the working directory.',
523
'rather than the one containing the working directory.'),
563
524
Option('tree', help='Show revno of working tree'),
571
532
wt = WorkingTree.open_containing(directory)[0]
574
self.add_cleanup(wt.unlock)
534
self.add_cleanup(wt.lock_read().unlock)
575
535
except (errors.NoWorkingTree, errors.NotLocalUrl):
577
537
b = Branch.open_containing(directory)[0]
579
self.add_cleanup(b.unlock)
538
self.add_cleanup(b.lock_read().unlock)
580
539
revision_ids = []
581
540
if revision is not None:
582
541
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
681
640
should_print=(not is_quiet()))
684
base_tree.lock_read()
685
self.add_cleanup(base_tree.unlock)
643
self.add_cleanup(base_tree.lock_read().unlock)
686
644
tree, file_list = tree_files_for_add(file_list)
687
645
added, ignored = tree.smart_add(file_list, not
688
646
no_recurse, action=action, save=not dry_run)
759
717
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
761
719
revision = _get_one_revision('inventory', revision)
762
work_tree, file_list = tree_files(file_list)
763
work_tree.lock_read()
764
self.add_cleanup(work_tree.unlock)
720
work_tree, file_list = WorkingTree.open_containing_paths(file_list)
721
self.add_cleanup(work_tree.lock_read().unlock)
765
722
if revision is not None:
766
723
tree = revision.as_tree(work_tree.branch)
768
725
extra_trees = [work_tree]
770
self.add_cleanup(tree.unlock)
726
self.add_cleanup(tree.lock_read().unlock)
833
789
if len(names_list) < 2:
834
790
raise errors.BzrCommandError("missing file argument")
835
tree, rel_names = tree_files(names_list, canonicalize=False)
836
tree.lock_tree_write()
837
self.add_cleanup(tree.unlock)
791
tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
792
self.add_cleanup(tree.lock_tree_write().unlock)
838
793
self._run(tree, names_list, rel_names, after)
840
795
def run_auto(self, names_list, after, dry_run):
845
800
raise errors.BzrCommandError('--after cannot be specified with'
847
work_tree, file_list = tree_files(names_list, default_branch='.')
848
work_tree.lock_tree_write()
849
self.add_cleanup(work_tree.unlock)
802
work_tree, file_list = WorkingTree.open_containing_paths(
803
names_list, default_directory='.')
804
self.add_cleanup(work_tree.lock_tree_write().unlock)
850
805
rename_map.RenameMap.guess_renames(work_tree, dry_run)
852
807
def _run(self, tree, names_list, rel_names, after):
960
915
takes_options = ['remember', 'overwrite', 'revision',
961
916
custom_help('verbose',
962
917
help='Show logs of pulled revisions.'),
918
custom_help('directory',
964
919
help='Branch to pull into, '
965
'rather than the one containing the working directory.',
920
'rather than the one containing the working directory.'),
970
922
help="Perform a local pull in a bound "
971
923
"branch. Local pulls are not applied to "
987
939
tree_to = WorkingTree.open_containing(directory)[0]
988
940
branch_to = tree_to.branch
990
self.add_cleanup(tree_to.unlock)
941
self.add_cleanup(tree_to.lock_write().unlock)
991
942
except errors.NoWorkingTree:
993
944
branch_to = Branch.open_containing(directory)[0]
994
branch_to.lock_write()
995
self.add_cleanup(branch_to.unlock)
945
self.add_cleanup(branch_to.lock_write().unlock)
997
947
if local and not branch_to.get_bound_location():
998
948
raise errors.LocalRequiresBoundBranch()
1030
980
branch_from = Branch.open(location,
1031
981
possible_transports=possible_transports)
1032
branch_from.lock_read()
1033
self.add_cleanup(branch_from.unlock)
982
self.add_cleanup(branch_from.lock_read().unlock)
1035
984
if branch_to.get_parent() is None or remember:
1036
985
branch_to.set_parent(branch_from.base)
1088
1037
Option('create-prefix',
1089
1038
help='Create the path leading up to the branch '
1090
1039
'if it does not already exist.'),
1040
custom_help('directory',
1092
1041
help='Branch to push from, '
1093
'rather than the one containing the working directory.',
1042
'rather than the one containing the working directory.'),
1097
1043
Option('use-existing-dir',
1098
1044
help='By default push will fail if the target'
1099
1045
' directory exists, but does not already'
1189
1135
_see_also = ['checkout']
1190
1136
takes_args = ['from_location', 'to_location?']
1191
takes_options = ['revision', Option('hardlink',
1192
help='Hard-link working tree files where possible.'),
1137
takes_options = ['revision',
1138
Option('hardlink', help='Hard-link working tree files where possible.'),
1139
Option('files-from', type=str,
1140
help="Get file contents from this tree."),
1193
1141
Option('no-tree',
1194
1142
help="Create a branch without a working-tree."),
1195
1143
Option('switch',
1214
1162
def run(self, from_location, to_location=None, revision=None,
1215
1163
hardlink=False, stacked=False, standalone=False, no_tree=False,
1216
use_existing_dir=False, switch=False, bind=False):
1164
use_existing_dir=False, switch=False, bind=False,
1217
1166
from bzrlib import switch as _mod_switch
1218
1167
from bzrlib.tag import _merge_tags_if_possible
1219
1168
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1170
if not (hardlink or files_from):
1171
# accelerator_tree is usually slower because you have to read N
1172
# files (no readahead, lots of seeks, etc), but allow the user to
1173
# explicitly request it
1174
accelerator_tree = None
1175
if files_from is not None and files_from != from_location:
1176
accelerator_tree = WorkingTree.open(files_from)
1221
1177
revision = _get_one_revision('branch', revision)
1223
self.add_cleanup(br_from.unlock)
1178
self.add_cleanup(br_from.lock_read().unlock)
1224
1179
if revision is not None:
1225
1180
revision_id = revision.as_revision_id(br_from)
1331
1286
to_location = branch_location
1332
1287
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1333
1288
branch_location)
1289
if not (hardlink or files_from):
1290
# accelerator_tree is usually slower because you have to read N
1291
# files (no readahead, lots of seeks, etc), but allow the user to
1292
# explicitly request it
1293
accelerator_tree = None
1334
1294
revision = _get_one_revision('checkout', revision)
1335
if files_from is not None:
1295
if files_from is not None and files_from != branch_location:
1336
1296
accelerator_tree = WorkingTree.open(files_from)
1337
1297
if revision is not None:
1338
1298
revision_id = revision.as_revision_id(source)
1366
1326
@display_command
1367
1327
def run(self, dir=u'.'):
1368
1328
tree = WorkingTree.open_containing(dir)[0]
1370
self.add_cleanup(tree.unlock)
1329
self.add_cleanup(tree.lock_read().unlock)
1371
1330
new_inv = tree.inventory
1372
1331
old_tree = tree.basis_tree()
1373
old_tree.lock_read()
1374
self.add_cleanup(old_tree.unlock)
1332
self.add_cleanup(old_tree.lock_read().unlock)
1375
1333
old_inv = old_tree.inventory
1377
1335
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1396
1354
If you want to discard your local changes, you can just do a
1397
1355
'bzr revert' instead of 'bzr commit' after the update.
1357
If you want to restore a file that has been removed locally, use
1358
'bzr revert' instead of 'bzr update'.
1399
1360
If the tree's branch is bound to a master branch, it will also update
1400
1361
the branch from the master.
1415
1376
master = branch.get_master_branch(
1416
1377
possible_transports=possible_transports)
1417
1378
if master is not None:
1419
1379
branch_location = master.base
1382
branch_location = tree.branch.base
1421
1383
tree.lock_tree_write()
1422
branch_location = tree.branch.base
1423
1384
self.add_cleanup(tree.unlock)
1424
1385
# get rid of the final '/' and be ready for display
1425
1386
branch_location = urlutils.unescape_for_display(
1519
1480
class cmd_remove(Command):
1520
1481
__doc__ = """Remove files or directories.
1522
This makes bzr stop tracking changes to the specified files. bzr will delete
1523
them if they can easily be recovered using revert. If no options or
1524
parameters are given bzr will scan for files that are being tracked by bzr
1525
but missing in your tree and stop tracking them for you.
1483
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1484
delete them if they can easily be recovered using revert otherwise they
1485
will be backed up (adding an extention of the form .~#~). If no options or
1486
parameters are given Bazaar will scan for files that are being tracked by
1487
Bazaar but missing in your tree and stop tracking them for you.
1527
1489
takes_args = ['file*']
1528
1490
takes_options = ['verbose',
1530
1492
RegistryOption.from_kwargs('file-deletion-strategy',
1531
1493
'The file deletion mode to be used.',
1532
1494
title='Deletion Strategy', value_switches=True, enum_switch=False,
1533
safe='Only delete files if they can be'
1534
' safely recovered (default).',
1495
safe='Backup changed files (default).',
1535
1496
keep='Delete from bzr but leave the working copy.',
1536
1497
force='Delete all the specified files, even if they can not be '
1537
1498
'recovered and even if they are non-empty directories.')]
1541
1502
def run(self, file_list, verbose=False, new=False,
1542
1503
file_deletion_strategy='safe'):
1543
tree, file_list = tree_files(file_list)
1504
tree, file_list = WorkingTree.open_containing_paths(file_list)
1545
1506
if file_list is not None:
1546
1507
file_list = [f for f in file_list]
1549
self.add_cleanup(tree.unlock)
1509
self.add_cleanup(tree.lock_write().unlock)
1550
1510
# Heuristics should probably all move into tree.remove_smart or
1636
1596
_see_also = ['check']
1637
1597
takes_args = ['branch?']
1599
Option('canonicalize-chks',
1600
help='Make sure CHKs are in canonical form (repairs '
1639
def run(self, branch="."):
1605
def run(self, branch=".", canonicalize_chks=False):
1640
1606
from bzrlib.reconcile import reconcile
1641
1607
dir = bzrdir.BzrDir.open(branch)
1608
reconcile(dir, canonicalize_chks=canonicalize_chks)
1645
1611
class cmd_revision_history(Command):
1985
1955
old_branch, new_branch,
1986
1956
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1987
1957
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1958
# GNU diff on Windows uses ANSI encoding for filenames
1959
path_encoding = osutils.get_diff_header_encoding()
1988
1960
return show_diff_trees(old_tree, new_tree, sys.stdout,
1989
1961
specific_files=specific_files,
1990
1962
external_diff_options=diff_options,
1991
1963
old_label=old_label, new_label=new_label,
1992
extra_trees=extra_trees, using=using,
1964
extra_trees=extra_trees,
1965
path_encoding=path_encoding,
1993
1967
format_cls=format)
2003
1977
# level of effort but possibly much less IO. (Or possibly not,
2004
1978
# if the directories are very large...)
2005
1979
_see_also = ['status', 'ls']
2006
takes_options = ['show-ids']
1980
takes_options = ['directory', 'show-ids']
2008
1982
@display_command
2009
def run(self, show_ids=False):
2010
tree = WorkingTree.open_containing(u'.')[0]
2012
self.add_cleanup(tree.unlock)
1983
def run(self, show_ids=False, directory=u'.'):
1984
tree = WorkingTree.open_containing(directory)[0]
1985
self.add_cleanup(tree.lock_read().unlock)
2013
1986
old = tree.basis_tree()
2015
self.add_cleanup(old.unlock)
1987
self.add_cleanup(old.lock_read().unlock)
2016
1988
for path, ie in old.inventory.iter_entries():
2017
1989
if not tree.has_id(ie.file_id):
2018
1990
self.outf.write(path)
2030
2002
_see_also = ['status', 'ls']
2033
help='Write an ascii NUL (\\0) separator '
2034
'between files rather than a newline.')
2003
takes_options = ['directory', 'null']
2037
2005
@display_command
2038
def run(self, null=False):
2039
tree = WorkingTree.open_containing(u'.')[0]
2006
def run(self, null=False, directory=u'.'):
2007
tree = WorkingTree.open_containing(directory)[0]
2040
2008
td = tree.changes_from(tree.basis_tree())
2041
2009
for path, id, kind, text_modified, meta_modified in td.modified:
2053
2021
_see_also = ['status', 'ls']
2056
help='Write an ascii NUL (\\0) separator '
2057
'between files rather than a newline.')
2022
takes_options = ['directory', 'null']
2060
2024
@display_command
2061
def run(self, null=False):
2062
wt = WorkingTree.open_containing(u'.')[0]
2064
self.add_cleanup(wt.unlock)
2025
def run(self, null=False, directory=u'.'):
2026
wt = WorkingTree.open_containing(directory)[0]
2027
self.add_cleanup(wt.lock_read().unlock)
2065
2028
basis = wt.basis_tree()
2067
self.add_cleanup(basis.unlock)
2029
self.add_cleanup(basis.lock_read().unlock)
2068
2030
basis_inv = basis.inventory
2069
2031
inv = wt.inventory
2070
2032
for file_id in inv:
2073
2035
if inv.is_root(file_id) and len(basis_inv) == 0:
2075
2037
path = inv.id2path(file_id)
2076
if not os.access(osutils.abspath(path), os.F_OK):
2038
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2079
2041
self.outf.write(path + '\0')
2279
2241
help='Show just the specified revision.'
2280
2242
' See also "help revisionspec".'),
2244
RegistryOption('authors',
2245
'What names to list as authors - first, all or committer.',
2247
lazy_registry=('bzrlib.log', 'author_list_registry'),
2282
2249
Option('levels',
2283
2250
short_name='n',
2284
2251
help='Number of levels to display - 0 for all, 1 for flat.',
2353
2321
# find the file ids to log and check for directory filtering
2354
2322
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2355
revision, file_list)
2356
self.add_cleanup(b.unlock)
2323
revision, file_list, self.add_cleanup)
2357
2324
for relpath, file_id, kind in file_info_list:
2358
2325
if file_id is None:
2359
2326
raise errors.BzrCommandError(
2378
2345
dir, relpath = bzrdir.BzrDir.open_containing(location)
2379
2346
b = dir.open_branch()
2381
self.add_cleanup(b.unlock)
2347
self.add_cleanup(b.lock_read().unlock)
2382
2348
rev1, rev2 = _get_revision_range(revision, b, self.name())
2384
2350
# Decide on the type of delta & diff filtering to use
2404
2370
show_timezone=timezone,
2405
2371
delta_format=get_verbosity_level(),
2407
show_advice=levels is None)
2373
show_advice=levels is None,
2374
author_list_handler=authors)
2409
2376
# Choose the algorithm for doing the logging. It's annoying
2410
2377
# having multiple code paths like this but necessary until
2508
2475
tree, relpath = WorkingTree.open_containing(filename)
2509
2476
file_id = tree.path2id(relpath)
2510
2477
b = tree.branch
2512
self.add_cleanup(b.unlock)
2478
self.add_cleanup(b.lock_read().unlock)
2513
2479
touching_revs = log.find_touching_revisions(b, file_id)
2514
2480
for revno, revision_id, what in touching_revs:
2515
2481
self.outf.write("%6d %s\n" % (revno, what))
2528
2494
help='Recurse into subdirectories.'),
2529
2495
Option('from-root',
2530
2496
help='Print paths relative to the root of the branch.'),
2531
Option('unknown', help='Print unknown files.'),
2497
Option('unknown', short_name='u',
2498
help='Print unknown files.'),
2532
2499
Option('versioned', help='Print versioned files.',
2533
2500
short_name='V'),
2534
Option('ignored', help='Print ignored files.'),
2536
help='Write an ascii NUL (\\0) separator '
2537
'between files rather than a newline.'),
2501
Option('ignored', short_name='i',
2502
help='Print ignored files.'),
2503
Option('kind', short_name='k',
2539
2504
help='List entries of a particular kind: file, directory, symlink.',
2543
2510
@display_command
2544
2511
def run(self, revision=None, verbose=False,
2545
2512
recursive=False, from_root=False,
2546
2513
unknown=False, versioned=False, ignored=False,
2547
null=False, kind=None, show_ids=False, path=None):
2514
null=False, kind=None, show_ids=False, path=None, directory=None):
2549
2516
if kind and kind not in ('file', 'directory', 'symlink'):
2550
2517
raise errors.BzrCommandError('invalid kind specified')
2562
2529
raise errors.BzrCommandError('cannot specify both --from-root'
2565
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2532
tree, branch, relpath = \
2533
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2568
2535
# Calculate the prefix to use
2584
2551
view_str = views.view_display_str(view_files)
2585
2552
note("Ignoring files outside view. View is %s" % view_str)
2588
self.add_cleanup(tree.unlock)
2554
self.add_cleanup(tree.lock_read().unlock)
2589
2555
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2590
2556
from_dir=relpath, recursive=recursive):
2591
2557
# Apply additional masking
2640
2606
_see_also = ['ls']
2607
takes_options = ['directory']
2642
2609
@display_command
2644
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2610
def run(self, directory=u'.'):
2611
for f in WorkingTree.open_containing(directory)[0].unknowns():
2645
2612
self.outf.write(osutils.quotefn(f) + '\n')
2713
2680
_see_also = ['status', 'ignored', 'patterns']
2714
2681
takes_args = ['name_pattern*']
2682
takes_options = ['directory',
2716
2683
Option('default-rules',
2717
2684
help='Display the default ignore rules that bzr uses.')
2720
def run(self, name_pattern_list=None, default_rules=None):
2687
def run(self, name_pattern_list=None, default_rules=None,
2721
2689
from bzrlib import ignores
2722
2690
if default_rules is not None:
2723
2691
# dump the default rules and exit
2729
2697
"NAME_PATTERN or --default-rules.")
2730
2698
name_pattern_list = [globbing.normalize_pattern(p)
2731
2699
for p in name_pattern_list]
2701
for p in name_pattern_list:
2702
if not globbing.Globster.is_pattern_valid(p):
2703
bad_patterns += ('\n %s' % p)
2705
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2706
ui.ui_factory.show_error(msg)
2707
raise errors.InvalidPattern('')
2732
2708
for name_pattern in name_pattern_list:
2733
2709
if (name_pattern[0] == '/' or
2734
2710
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2735
2711
raise errors.BzrCommandError(
2736
2712
"NAME_PATTERN should not be an absolute path")
2737
tree, relpath = WorkingTree.open_containing(u'.')
2713
tree, relpath = WorkingTree.open_containing(directory)
2738
2714
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2739
2715
ignored = globbing.Globster(name_pattern_list)
2717
self.add_cleanup(tree.lock_read().unlock)
2742
2718
for entry in tree.list_files():
2744
2720
if id is not None:
2745
2721
filename = entry[0]
2746
2722
if ignored.match(filename):
2747
2723
matches.append(filename)
2749
2724
if len(matches) > 0:
2750
2725
self.outf.write("Warning: the following files are version controlled and"
2751
2726
" match your ignore pattern:\n%s"
2767
2742
encoding_type = 'replace'
2768
2743
_see_also = ['ignore', 'ls']
2744
takes_options = ['directory']
2770
2746
@display_command
2772
tree = WorkingTree.open_containing(u'.')[0]
2774
self.add_cleanup(tree.unlock)
2747
def run(self, directory=u'.'):
2748
tree = WorkingTree.open_containing(directory)[0]
2749
self.add_cleanup(tree.lock_read().unlock)
2775
2750
for path, file_class, kind, file_id, entry in tree.list_files():
2776
2751
if file_class != 'I':
2790
2765
takes_args = ['revno']
2766
takes_options = ['directory']
2792
2768
@display_command
2793
def run(self, revno):
2769
def run(self, revno, directory=u'.'):
2795
2771
revno = int(revno)
2796
2772
except ValueError:
2797
2773
raise errors.BzrCommandError("not a valid revision-number: %r"
2799
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2775
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2800
2776
self.outf.write("%s\n" % revid)
2829
2805
================= =========================
2831
2807
takes_args = ['dest', 'branch_or_subdir?']
2808
takes_options = ['directory',
2833
2809
Option('format',
2834
2810
help="Type of file to export to.",
2844
2820
'revision in which it was changed.'),
2846
2822
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2847
root=None, filters=False, per_file_timestamps=False):
2823
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2848
2824
from bzrlib.export import export
2850
2826
if branch_or_subdir is None:
2851
tree = WorkingTree.open_containing(u'.')[0]
2827
tree = WorkingTree.open_containing(directory)[0]
2852
2828
b = tree.branch
2875
2851
_see_also = ['ls']
2852
takes_options = ['directory',
2877
2853
Option('name-from-revision', help='The path name in the old tree.'),
2878
2854
Option('filters', help='Apply content filters to display the '
2879
2855
'convenience form.'),
2885
2861
@display_command
2886
2862
def run(self, filename, revision=None, name_from_revision=False,
2863
filters=False, directory=None):
2888
2864
if revision is not None and len(revision) != 1:
2889
2865
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2890
2866
" one revision specifier")
2891
2867
tree, branch, relpath = \
2892
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2894
self.add_cleanup(branch.unlock)
2868
_open_directory_or_containing_tree_or_branch(filename, directory)
2869
self.add_cleanup(branch.lock_read().unlock)
2895
2870
return self._run(tree, branch, relpath, filename, revision,
2896
2871
name_from_revision, filters)
2900
2875
if tree is None:
2901
2876
tree = b.basis_tree()
2902
2877
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2903
rev_tree.lock_read()
2904
self.add_cleanup(rev_tree.unlock)
2878
self.add_cleanup(rev_tree.lock_read().unlock)
2906
2880
old_file_id = rev_tree.path2id(relpath)
3129
3103
properties = {}
3131
tree, selected_list = tree_files(selected_list)
3105
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3132
3106
if selected_list == ['']:
3133
3107
# workaround - commit of root of tree should be exactly the same
3134
3108
# as just default commit in that tree, and succeed even though
3169
3143
def get_message(commit_obj):
3170
3144
"""Callback to get commit message"""
3172
my_message = codecs.open(
3173
file, 'rt', osutils.get_user_encoding()).read()
3148
my_message = f.read().decode(osutils.get_user_encoding())
3174
3151
elif message is not None:
3175
3152
my_message = message
3205
3182
reporter=None, verbose=verbose, revprops=properties,
3206
3183
authors=author, timestamp=commit_stamp,
3207
3184
timezone=offset,
3208
exclude=safe_relpath_files(tree, exclude))
3185
exclude=tree.safe_relpath_files(exclude))
3209
3186
except PointlessCommit:
3210
3187
raise errors.BzrCommandError("No changes to commit."
3211
3188
" Use --unchanged to commit anyhow.")
3331
3308
bzr whoami "Frank Chu <fchu@example.com>"
3333
takes_options = [ Option('email',
3310
takes_options = [ 'directory',
3334
3312
help='Display email address only.'),
3335
3313
Option('branch',
3336
3314
help='Set identity for the current branch instead of '
3340
3318
encoding_type = 'replace'
3342
3320
@display_command
3343
def run(self, email=False, branch=False, name=None):
3321
def run(self, email=False, branch=False, name=None, directory=None):
3344
3322
if name is None:
3345
# use branch if we're inside one; otherwise global config
3347
c = Branch.open_containing('.')[0].get_config()
3348
except errors.NotBranchError:
3349
c = config.GlobalConfig()
3323
if directory is None:
3324
# use branch if we're inside one; otherwise global config
3326
c = Branch.open_containing(u'.')[0].get_config()
3327
except errors.NotBranchError:
3328
c = _mod_config.GlobalConfig()
3330
c = Branch.open(directory).get_config()
3351
3332
self.outf.write(c.user_email() + '\n')
3356
3337
# display a warning if an email address isn't included in the given name.
3358
config.extract_email_address(name)
3339
_mod_config.extract_email_address(name)
3359
3340
except errors.NoEmailInUsername, e:
3360
3341
warning('"%s" does not seem to contain an email address. '
3361
3342
'This is allowed, but not recommended.', name)
3363
3344
# use global config unless --branch given
3365
c = Branch.open_containing('.')[0].get_config()
3346
if directory is None:
3347
c = Branch.open_containing(u'.')[0].get_config()
3349
c = Branch.open(directory).get_config()
3367
c = config.GlobalConfig()
3351
c = _mod_config.GlobalConfig()
3368
3352
c.set_user_option('email', name)
3381
3365
_see_also = ['info']
3382
3366
takes_args = ['nickname?']
3383
def run(self, nickname=None):
3384
branch = Branch.open_containing(u'.')[0]
3367
takes_options = ['directory']
3368
def run(self, nickname=None, directory=u'.'):
3369
branch = Branch.open_containing(directory)[0]
3385
3370
if nickname is None:
3386
3371
self.printme(branch)
3436
3421
'bzr alias --remove expects an alias to remove.')
3437
3422
# If alias is not found, print something like:
3438
3423
# unalias: foo: not found
3439
c = config.GlobalConfig()
3424
c = _mod_config.GlobalConfig()
3440
3425
c.unset_alias(alias_name)
3442
3427
@display_command
3443
3428
def print_aliases(self):
3444
3429
"""Print out the defined aliases in a similar format to bash."""
3445
aliases = config.GlobalConfig().get_aliases()
3430
aliases = _mod_config.GlobalConfig().get_aliases()
3446
3431
for key, value in sorted(aliases.iteritems()):
3447
3432
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3459
3444
def set_alias(self, alias_name, alias_command):
3460
3445
"""Save the alias in the global config."""
3461
c = config.GlobalConfig()
3446
c = _mod_config.GlobalConfig()
3462
3447
c.set_alias(alias_name, alias_command)
3499
3484
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3500
3485
into a pdb postmortem session.
3487
The --coverage=DIRNAME global option produces a report with covered code
3503
3491
Run only tests relating to 'ignore'::
3537
3525
'throughout the test suite.',
3538
3526
type=get_transport_type),
3539
3527
Option('benchmark',
3540
help='Run the benchmarks rather than selftests.'),
3528
help='Run the benchmarks rather than selftests.',
3541
3530
Option('lsprof-timed',
3542
3531
help='Generate lsprof output for benchmarked'
3543
3532
' sections of code.'),
3544
3533
Option('lsprof-tests',
3545
3534
help='Generate lsprof output for each test.'),
3546
Option('cache-dir', type=str,
3547
help='Cache intermediate benchmark output in this '
3549
3535
Option('first',
3550
3536
help='Run all tests, but run specified tests first.',
3551
3537
short_name='f',
3586
3572
def run(self, testspecs_list=None, verbose=False, one=False,
3587
3573
transport=None, benchmark=None,
3588
lsprof_timed=None, cache_dir=None,
3589
3575
first=False, list_only=False,
3590
3576
randomize=None, exclude=None, strict=False,
3591
3577
load_list=None, debugflag=None, starting_with=None, subunit=False,
3592
3578
parallel=None, lsprof_tests=False):
3593
from bzrlib.tests import selftest
3594
import bzrlib.benchmarks as benchmarks
3595
from bzrlib.benchmarks import tree_creator
3597
# Make deprecation warnings visible, unless -Werror is set
3598
symbol_versioning.activate_deprecation_warnings(override=False)
3600
if cache_dir is not None:
3601
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3579
from bzrlib import tests
3602
3581
if testspecs_list is not None:
3603
3582
pattern = '|'.join(testspecs_list)
3612
3591
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3613
3592
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3614
3593
# stdout, which would corrupt the subunit stream.
3615
if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3594
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3595
# following code can be deleted when it's sufficiently deployed
3596
# -- vila/mgz 20100514
3597
if (sys.platform == "win32"
3598
and getattr(sys.stdout, 'fileno', None) is not None):
3617
3600
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3619
3602
self.additional_selftest_args.setdefault(
3620
3603
'suite_decorators', []).append(parallel)
3622
test_suite_factory = benchmarks.test_suite
3623
# Unless user explicitly asks for quiet, be verbose in benchmarks
3624
verbose = not is_quiet()
3625
# TODO: should possibly lock the history file...
3626
benchfile = open(".perf_history", "at", buffering=1)
3627
self.add_cleanup(benchfile.close)
3629
test_suite_factory = None
3605
raise errors.BzrCommandError(
3606
"--benchmark is no longer supported from bzr 2.2; "
3607
"use bzr-usertest instead")
3608
test_suite_factory = None
3631
3609
selftest_kwargs = {"verbose": verbose,
3632
3610
"pattern": pattern,
3633
3611
"stop_on_failure": one,
3635
3613
"test_suite_factory": test_suite_factory,
3636
3614
"lsprof_timed": lsprof_timed,
3637
3615
"lsprof_tests": lsprof_tests,
3638
"bench_history": benchfile,
3639
3616
"matching_tests_first": first,
3640
3617
"list_only": list_only,
3641
3618
"random_seed": randomize,
3646
3623
"starting_with": starting_with
3648
3625
selftest_kwargs.update(self.additional_selftest_args)
3649
result = selftest(**selftest_kwargs)
3627
# Make deprecation warnings visible, unless -Werror is set
3628
cleanup = symbol_versioning.activate_deprecation_warnings(
3631
result = tests.selftest(**selftest_kwargs)
3650
3634
return int(not result)
3691
3675
branch1 = Branch.open_containing(branch)[0]
3692
3676
branch2 = Branch.open_containing(other)[0]
3694
self.add_cleanup(branch1.unlock)
3696
self.add_cleanup(branch2.unlock)
3677
self.add_cleanup(branch1.lock_read().unlock)
3678
self.add_cleanup(branch2.lock_read().unlock)
3697
3679
last1 = ensure_null(branch1.last_revision())
3698
3680
last2 = ensure_null(branch2.last_revision())
3793
3775
' completely merged into the source, pull from the'
3794
3776
' source rather than merging. When this happens,'
3795
3777
' you do not need to commit the result.'),
3778
custom_help('directory',
3797
3779
help='Branch to merge into, '
3798
'rather than the one containing the working directory.',
3780
'rather than the one containing the working directory.'),
3802
3781
Option('preview', help='Instead of merging, show a diff of the'
3804
3783
Option('interactive', help='Select changes interactively.',
3837
3816
unversioned_filter=tree.is_ignored, view_info=view_info)
3838
3817
pb = ui.ui_factory.nested_progress_bar()
3839
3818
self.add_cleanup(pb.finished)
3841
self.add_cleanup(tree.unlock)
3819
self.add_cleanup(tree.lock_write().unlock)
3842
3820
if location is not None:
3844
3822
mergeable = bundle.read_mergeable_from_url(location,
3905
3883
def _do_preview(self, merger):
3906
3884
from bzrlib.diff import show_diff_trees
3907
3885
result_tree = self._get_preview(merger)
3886
path_encoding = osutils.get_diff_header_encoding()
3908
3887
show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
old_label='', new_label='')
3888
old_label='', new_label='',
3889
path_encoding=path_encoding)
3911
3891
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
3892
merger.change_reporter = change_reporter
4099
4079
from bzrlib.conflicts import restore
4100
4080
if merge_type is None:
4101
4081
merge_type = _mod_merge.Merge3Merger
4102
tree, file_list = tree_files(file_list)
4104
self.add_cleanup(tree.unlock)
4082
tree, file_list = WorkingTree.open_containing_paths(file_list)
4083
self.add_cleanup(tree.lock_write().unlock)
4105
4084
parents = tree.get_parent_ids()
4106
4085
if len(parents) != 2:
4107
4086
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4217
4196
def run(self, revision=None, no_backup=False, file_list=None,
4218
4197
forget_merges=None):
4219
tree, file_list = tree_files(file_list)
4220
tree.lock_tree_write()
4221
self.add_cleanup(tree.unlock)
4198
tree, file_list = WorkingTree.open_containing_paths(file_list)
4199
self.add_cleanup(tree.lock_tree_write().unlock)
4222
4200
if forget_merges:
4223
4201
tree.set_parent_ids(tree.get_parent_ids()[:1])
4313
4291
_see_also = ['merge', 'pull']
4314
4292
takes_args = ['other_branch?']
4315
4293
takes_options = [
4316
4295
Option('reverse', 'Reverse the order of revisions.'),
4317
4296
Option('mine-only',
4318
4297
'Display changes in the local branch only.'),
4340
4319
theirs_only=False,
4341
4320
log_format=None, long=False, short=False, line=False,
4342
4321
show_ids=False, verbose=False, this=False, other=False,
4343
include_merges=False, revision=None, my_revision=None):
4322
include_merges=False, revision=None, my_revision=None,
4344
4324
from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4325
def message(s):
4346
4326
if not is_quiet():
4359
4339
elif theirs_only:
4360
4340
restrict = 'remote'
4362
local_branch = Branch.open_containing(u".")[0]
4363
local_branch.lock_read()
4364
self.add_cleanup(local_branch.unlock)
4342
local_branch = Branch.open_containing(directory)[0]
4343
self.add_cleanup(local_branch.lock_read().unlock)
4366
4345
parent = local_branch.get_parent()
4367
4346
if other_branch is None:
4378
4357
if remote_branch.base == local_branch.base:
4379
4358
remote_branch = local_branch
4381
remote_branch.lock_read()
4382
self.add_cleanup(remote_branch.unlock)
4360
self.add_cleanup(remote_branch.lock_read().unlock)
4384
4362
local_revid_range = _revision_range_to_revid_range(
4385
4363
_get_revision_range(my_revision, local_branch,
4440
4418
message("Branches are up to date.\n")
4441
4419
self.cleanup_now()
4442
4420
if not status_code and parent is None and other_branch is not None:
4443
local_branch.lock_write()
4444
self.add_cleanup(local_branch.unlock)
4421
self.add_cleanup(local_branch.lock_write().unlock)
4445
4422
# handle race conditions - a parent might be set while we run.
4446
4423
if local_branch.get_parent() is None:
4447
4424
local_branch.set_parent(remote_branch.base)
4578
4554
Option('long', help='Show commit date in annotations.'),
4582
4559
encoding_type = 'exact'
4584
4561
@display_command
4585
4562
def run(self, filename, all=False, long=False, revision=None,
4563
show_ids=False, directory=None):
4587
4564
from bzrlib.annotate import annotate_file, annotate_file_tree
4588
4565
wt, branch, relpath = \
4589
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4566
_open_directory_or_containing_tree_or_branch(filename, directory)
4590
4567
if wt is not None:
4592
self.add_cleanup(wt.unlock)
4568
self.add_cleanup(wt.lock_read().unlock)
4595
self.add_cleanup(branch.unlock)
4570
self.add_cleanup(branch.lock_read().unlock)
4596
4571
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4598
self.add_cleanup(tree.unlock)
4572
self.add_cleanup(tree.lock_read().unlock)
4599
4573
if wt is not None:
4600
4574
file_id = wt.path2id(relpath)
4620
4594
hidden = True # is this right ?
4621
4595
takes_args = ['revision_id*']
4622
takes_options = ['revision']
4596
takes_options = ['directory', 'revision']
4624
def run(self, revision_id_list=None, revision=None):
4598
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4599
if revision_id_list is not None and revision is not None:
4626
4600
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4601
if revision_id_list is None and revision is None:
4628
4602
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4629
b = WorkingTree.open_containing(u'.')[0].branch
4631
self.add_cleanup(b.unlock)
4603
b = WorkingTree.open_containing(directory)[0].branch
4604
self.add_cleanup(b.lock_write().unlock)
4632
4605
return self._run(b, revision_id_list, revision)
4634
4607
def _run(self, b, revision_id_list, revision):
4694
4667
_see_also = ['checkouts', 'unbind']
4695
4668
takes_args = ['location?']
4669
takes_options = ['directory']
4698
def run(self, location=None):
4699
b, relpath = Branch.open_containing(u'.')
4671
def run(self, location=None, directory=u'.'):
4672
b, relpath = Branch.open_containing(directory)
4700
4673
if location is None:
4702
4675
location = b.get_old_bound_location()
4730
4703
_see_also = ['checkouts', 'bind']
4731
4704
takes_args = []
4705
takes_options = ['directory']
4735
b, relpath = Branch.open_containing(u'.')
4707
def run(self, directory=u'.'):
4708
b, relpath = Branch.open_containing(directory)
4736
4709
if not b.unbind():
4737
4710
raise errors.BzrCommandError('Local branch is not bound')
4784
4757
b = control.open_branch()
4786
4759
if tree is not None:
4788
self.add_cleanup(tree.unlock)
4760
self.add_cleanup(tree.lock_write().unlock)
4791
self.add_cleanup(b.unlock)
4762
self.add_cleanup(b.lock_write().unlock)
4792
4763
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4794
4765
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4833
4804
self.outf.write('The above revision(s) will be removed.\n')
4836
if not ui.ui_factory.get_boolean('Are you sure'):
4837
self.outf.write('Canceled')
4807
if not ui.ui_factory.confirm_action(
4808
'Uncommit these revisions',
4809
'bzrlib.builtins.uncommit',
4811
self.outf.write('Canceled\n')
4840
4814
mutter('Uncommitting from {%s} to {%s}',
4848
4822
class cmd_break_lock(Command):
4849
__doc__ = """Break a dead lock on a repository, branch or working directory.
4823
__doc__ = """Break a dead lock.
4825
This command breaks a lock on a repository, branch, working directory or
4851
4828
CAUTION: Locks should only be broken when you are sure that the process
4852
4829
holding the lock has been stopped.
4859
4836
bzr break-lock bzr+ssh://example.com/bzr/foo
4837
bzr break-lock --conf ~/.bazaar
4861
4840
takes_args = ['location?']
4843
help='LOCATION is the directory where the config lock is.'),
4863
def run(self, location=None, show=False):
4846
def run(self, location=None, config=False):
4864
4847
if location is None:
4865
4848
location = u'.'
4866
control, relpath = bzrdir.BzrDir.open_containing(location)
4868
control.break_lock()
4869
except NotImplementedError:
4850
conf = _mod_config.LockableConfig(file_name=location)
4853
control, relpath = bzrdir.BzrDir.open_containing(location)
4855
control.break_lock()
4856
except NotImplementedError:
4873
4860
class cmd_wait_until_signalled(Command):
4902
4889
'result in a dynamically allocated port. The default port '
4903
4890
'depends on the protocol.',
4906
help='Serve contents of this directory.',
4892
custom_help('directory',
4893
help='Serve contents of this directory.'),
4908
4894
Option('allow-writes',
4909
4895
help='By default the server is a readonly server. Supplying '
4910
4896
'--allow-writes enables write access to the contents of '
4938
4924
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
4925
protocol=None):
4940
from bzrlib.transport import get_transport, transport_server_registry
4926
from bzrlib import transport
4941
4927
if directory is None:
4942
4928
directory = os.getcwd()
4943
4929
if protocol is None:
4944
protocol = transport_server_registry.get()
4930
protocol = transport.transport_server_registry.get()
4945
4931
host, port = self.get_host_and_port(port)
4946
4932
url = urlutils.local_path_to_url(directory)
4947
4933
if not allow_writes:
4948
4934
url = 'readonly+' + url
4949
transport = get_transport(url)
4950
protocol(transport, host, port, inet)
4935
t = transport.get_transport(url)
4936
protocol(t, host, port, inet)
4953
4939
class cmd_join(Command):
4959
4945
not part of it. (Such trees can be produced by "bzr split", but also by
4960
4946
running "bzr branch" with the target inside a tree.)
4962
The result is a combined tree, with the subtree no longer an independant
4948
The result is a combined tree, with the subtree no longer an independent
4963
4949
part. This is marked as a merge of the subtree into the containing tree,
4964
4950
and all history is preserved.
5064
5051
encoding_type = 'exact'
5066
5053
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
sign=False, revision=None, mail_to=None, message=None):
5054
sign=False, revision=None, mail_to=None, message=None,
5068
5056
from bzrlib.revision import ensure_null, NULL_REVISION
5069
5057
include_patch, include_bundle = {
5070
5058
'plain': (False, False),
5071
5059
'diff': (True, False),
5072
5060
'bundle': (True, True),
5074
branch = Branch.open('.')
5062
branch = Branch.open(directory)
5075
5063
stored_submit_branch = branch.get_submit_branch()
5076
5064
if submit_branch is None:
5077
5065
submit_branch = stored_submit_branch
5162
5150
given, in which case it is sent to a file.
5164
5152
Mail is sent using your preferred mail program. This should be transparent
5165
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5153
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5166
5154
If the preferred client can't be found (or used), your editor will be used.
5168
5156
To use a specific mail program, set the mail_client configuration option.
5339
5327
Option('delete',
5340
5328
help='Delete this tag rather than placing it.',
5343
help='Branch in which to place the tag.',
5330
custom_help('directory',
5331
help='Branch in which to place the tag.'),
5347
5332
Option('force',
5348
5333
help='Replace existing tags.',
5359
5344
branch, relpath = Branch.open_containing(directory)
5361
self.add_cleanup(branch.unlock)
5345
self.add_cleanup(branch.lock_write().unlock)
5363
5347
if tag_name is None:
5364
5348
raise errors.BzrCommandError("No tag specified to delete.")
5393
5377
_see_also = ['tag']
5394
5378
takes_options = [
5396
help='Branch whose tags should be displayed.',
5379
custom_help('directory',
5380
help='Branch whose tags should be displayed.'),
5400
5381
RegistryOption.from_kwargs('sort',
5401
5382
'Sort tags by different criteria.', title='Sorting',
5402
5383
alpha='Sort tags lexicographically (default).',
5423
self.add_cleanup(branch.unlock)
5403
self.add_cleanup(branch.lock_read().unlock)
5425
5405
graph = branch.repository.get_graph()
5426
5406
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5575
5555
takes_args = ['to_location?']
5576
takes_options = [Option('force',
5556
takes_options = ['directory',
5577
5558
help='Switch even if local commits will be lost.'),
5579
5560
Option('create-branch', short_name='b',
5584
5565
def run(self, to_location=None, force=False, create_branch=False,
5566
revision=None, directory=u'.'):
5586
5567
from bzrlib import switch
5568
tree_location = directory
5588
5569
revision = _get_one_revision('switch', revision)
5589
5570
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5571
if to_location is None:
5591
5572
if revision is None:
5592
5573
raise errors.BzrCommandError('You must supply either a'
5593
5574
' revision or a location')
5575
to_location = tree_location
5596
5577
branch = control_dir.open_branch()
5597
5578
had_explicit_nick = branch.get_config().has_explicit_nickname()
5735
tree, file_list = tree_files(file_list, apply_view=False)
5716
tree, file_list = WorkingTree.open_containing_paths(file_list,
5736
5718
current_view, view_dict = tree.views.get_view_info()
5737
5719
if name is None:
5738
5720
name = current_view
5886
5869
_see_also = ['unshelve']
5888
5871
def run(self, revision=None, all=False, file_list=None, message=None,
5889
writer=None, list=False, destroy=False):
5872
writer=None, list=False, destroy=False, directory=u'.'):
5891
5874
return self.run_for_list()
5892
5875
from bzrlib.shelf_ui import Shelver
5894
5877
writer = bzrlib.option.diff_writer_registry.get()
5896
5879
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
file_list, message, destroy=destroy)
5880
file_list, message, destroy=destroy, directory=directory)
5905
5888
def run_for_list(self):
5906
5889
tree = WorkingTree.open_containing('.')[0]
5908
self.add_cleanup(tree.unlock)
5890
self.add_cleanup(tree.lock_read().unlock)
5909
5891
manager = tree.get_shelf_manager()
5910
5892
shelves = manager.active_shelves()
5911
5893
if len(shelves) == 0:
5930
5912
takes_args = ['shelf_id?']
5931
5913
takes_options = [
5932
5915
RegistryOption.from_kwargs(
5933
5916
'action', help="The action to perform.",
5934
5917
enum_switch=False, value_switches=True,
5943
5926
_see_also = ['shelve']
5945
def run(self, shelf_id=None, action='apply'):
5928
def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
5929
from bzrlib.shelf_ui import Unshelver
5947
unshelver = Unshelver.from_args(shelf_id, action)
5930
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5949
5932
unshelver.run()
5967
5950
To check what clean-tree will do, use --dry-run.
5969
takes_options = [Option('ignored', help='Delete all ignored files.'),
5952
takes_options = ['directory',
5953
Option('ignored', help='Delete all ignored files.'),
5970
5954
Option('detritus', help='Delete conflict files, merge'
5971
5955
' backups, and failed selftest dirs.'),
5972
5956
Option('unknown',
5975
5959
' deleting them.'),
5976
5960
Option('force', help='Do not prompt before deleting.')]
5977
5961
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5962
force=False, directory=u'.'):
5979
5963
from bzrlib.clean_tree import clean_tree
5980
5964
if not (unknown or ignored or detritus):
5984
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
dry_run=dry_run, no_prompt=force)
5968
clean_tree(directory, unknown=unknown, ignored=ignored,
5969
detritus=detritus, dry_run=dry_run, no_prompt=force)
5988
5972
class cmd_reference(Command):
added
removed
bzrlib/builtins.py
