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)
1415
1373
master = branch.get_master_branch(
1416
1374
possible_transports=possible_transports)
1417
1375
if master is not None:
1419
1376
branch_location = master.base
1379
branch_location = tree.branch.base
1421
1380
tree.lock_tree_write()
1422
branch_location = tree.branch.base
1423
1381
self.add_cleanup(tree.unlock)
1424
1382
# get rid of the final '/' and be ready for display
1425
1383
branch_location = urlutils.unescape_for_display(
1519
1477
class cmd_remove(Command):
1520
1478
__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.
1480
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1481
delete them if they can easily be recovered using revert otherwise they
1482
will be backed up (adding an extention of the form .~#~). If no options or
1483
parameters are given Bazaar will scan for files that are being tracked by
1484
Bazaar but missing in your tree and stop tracking them for you.
1527
1486
takes_args = ['file*']
1528
1487
takes_options = ['verbose',
1530
1489
RegistryOption.from_kwargs('file-deletion-strategy',
1531
1490
'The file deletion mode to be used.',
1532
1491
title='Deletion Strategy', value_switches=True, enum_switch=False,
1533
safe='Only delete files if they can be'
1534
' safely recovered (default).',
1492
safe='Backup changed files (default).',
1535
1493
keep='Delete from bzr but leave the working copy.',
1536
1494
force='Delete all the specified files, even if they can not be '
1537
1495
'recovered and even if they are non-empty directories.')]
1541
1499
def run(self, file_list, verbose=False, new=False,
1542
1500
file_deletion_strategy='safe'):
1543
tree, file_list = tree_files(file_list)
1501
tree, file_list = WorkingTree.open_containing_paths(file_list)
1545
1503
if file_list is not None:
1546
1504
file_list = [f for f in file_list]
1549
self.add_cleanup(tree.unlock)
1506
self.add_cleanup(tree.lock_write().unlock)
1550
1507
# Heuristics should probably all move into tree.remove_smart or
1636
1593
_see_also = ['check']
1637
1594
takes_args = ['branch?']
1596
Option('canonicalize-chks',
1597
help='Make sure CHKs are in canonical form (repairs '
1639
def run(self, branch="."):
1602
def run(self, branch=".", canonicalize_chks=False):
1640
1603
from bzrlib.reconcile import reconcile
1641
1604
dir = bzrdir.BzrDir.open(branch)
1605
reconcile(dir, canonicalize_chks=canonicalize_chks)
1645
1608
class cmd_revision_history(Command):
1985
1952
old_branch, new_branch,
1986
1953
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1987
1954
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1955
# GNU diff on Windows uses ANSI encoding for filenames
1956
path_encoding = osutils.get_diff_header_encoding()
1988
1957
return show_diff_trees(old_tree, new_tree, sys.stdout,
1989
1958
specific_files=specific_files,
1990
1959
external_diff_options=diff_options,
1991
1960
old_label=old_label, new_label=new_label,
1992
extra_trees=extra_trees, using=using,
1961
extra_trees=extra_trees,
1962
path_encoding=path_encoding,
1993
1964
format_cls=format)
2003
1974
# level of effort but possibly much less IO. (Or possibly not,
2004
1975
# if the directories are very large...)
2005
1976
_see_also = ['status', 'ls']
2006
takes_options = ['show-ids']
1977
takes_options = ['directory', 'show-ids']
2008
1979
@display_command
2009
def run(self, show_ids=False):
2010
tree = WorkingTree.open_containing(u'.')[0]
2012
self.add_cleanup(tree.unlock)
1980
def run(self, show_ids=False, directory=u'.'):
1981
tree = WorkingTree.open_containing(directory)[0]
1982
self.add_cleanup(tree.lock_read().unlock)
2013
1983
old = tree.basis_tree()
2015
self.add_cleanup(old.unlock)
1984
self.add_cleanup(old.lock_read().unlock)
2016
1985
for path, ie in old.inventory.iter_entries():
2017
1986
if not tree.has_id(ie.file_id):
2018
1987
self.outf.write(path)
2030
1999
_see_also = ['status', 'ls']
2033
help='Write an ascii NUL (\\0) separator '
2034
'between files rather than a newline.')
2000
takes_options = ['directory', 'null']
2037
2002
@display_command
2038
def run(self, null=False):
2039
tree = WorkingTree.open_containing(u'.')[0]
2003
def run(self, null=False, directory=u'.'):
2004
tree = WorkingTree.open_containing(directory)[0]
2040
2005
td = tree.changes_from(tree.basis_tree())
2041
2006
for path, id, kind, text_modified, meta_modified in td.modified:
2053
2018
_see_also = ['status', 'ls']
2056
help='Write an ascii NUL (\\0) separator '
2057
'between files rather than a newline.')
2019
takes_options = ['directory', 'null']
2060
2021
@display_command
2061
def run(self, null=False):
2062
wt = WorkingTree.open_containing(u'.')[0]
2064
self.add_cleanup(wt.unlock)
2022
def run(self, null=False, directory=u'.'):
2023
wt = WorkingTree.open_containing(directory)[0]
2024
self.add_cleanup(wt.lock_read().unlock)
2065
2025
basis = wt.basis_tree()
2067
self.add_cleanup(basis.unlock)
2026
self.add_cleanup(basis.lock_read().unlock)
2068
2027
basis_inv = basis.inventory
2069
2028
inv = wt.inventory
2070
2029
for file_id in inv:
2073
2032
if inv.is_root(file_id) and len(basis_inv) == 0:
2075
2034
path = inv.id2path(file_id)
2076
if not os.access(osutils.abspath(path), os.F_OK):
2035
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2079
2038
self.outf.write(path + '\0')
2279
2238
help='Show just the specified revision.'
2280
2239
' See also "help revisionspec".'),
2241
RegistryOption('authors',
2242
'What names to list as authors - first, all or committer.',
2244
lazy_registry=('bzrlib.log', 'author_list_registry'),
2282
2246
Option('levels',
2283
2247
short_name='n',
2284
2248
help='Number of levels to display - 0 for all, 1 for flat.',
2353
2318
# find the file ids to log and check for directory filtering
2354
2319
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2355
revision, file_list)
2356
self.add_cleanup(b.unlock)
2320
revision, file_list, self.add_cleanup)
2357
2321
for relpath, file_id, kind in file_info_list:
2358
2322
if file_id is None:
2359
2323
raise errors.BzrCommandError(
2378
2342
dir, relpath = bzrdir.BzrDir.open_containing(location)
2379
2343
b = dir.open_branch()
2381
self.add_cleanup(b.unlock)
2344
self.add_cleanup(b.lock_read().unlock)
2382
2345
rev1, rev2 = _get_revision_range(revision, b, self.name())
2384
2347
# Decide on the type of delta & diff filtering to use
2404
2367
show_timezone=timezone,
2405
2368
delta_format=get_verbosity_level(),
2407
show_advice=levels is None)
2370
show_advice=levels is None,
2371
author_list_handler=authors)
2409
2373
# Choose the algorithm for doing the logging. It's annoying
2410
2374
# having multiple code paths like this but necessary until
2508
2472
tree, relpath = WorkingTree.open_containing(filename)
2509
2473
file_id = tree.path2id(relpath)
2510
2474
b = tree.branch
2512
self.add_cleanup(b.unlock)
2475
self.add_cleanup(b.lock_read().unlock)
2513
2476
touching_revs = log.find_touching_revisions(b, file_id)
2514
2477
for revno, revision_id, what in touching_revs:
2515
2478
self.outf.write("%6d %s\n" % (revno, what))
2528
2491
help='Recurse into subdirectories.'),
2529
2492
Option('from-root',
2530
2493
help='Print paths relative to the root of the branch.'),
2531
Option('unknown', help='Print unknown files.'),
2494
Option('unknown', short_name='u',
2495
help='Print unknown files.'),
2532
2496
Option('versioned', help='Print versioned files.',
2533
2497
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.'),
2498
Option('ignored', short_name='i',
2499
help='Print ignored files.'),
2500
Option('kind', short_name='k',
2539
2501
help='List entries of a particular kind: file, directory, symlink.',
2543
2507
@display_command
2544
2508
def run(self, revision=None, verbose=False,
2545
2509
recursive=False, from_root=False,
2546
2510
unknown=False, versioned=False, ignored=False,
2547
null=False, kind=None, show_ids=False, path=None):
2511
null=False, kind=None, show_ids=False, path=None, directory=None):
2549
2513
if kind and kind not in ('file', 'directory', 'symlink'):
2550
2514
raise errors.BzrCommandError('invalid kind specified')
2562
2526
raise errors.BzrCommandError('cannot specify both --from-root'
2565
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2529
tree, branch, relpath = \
2530
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2568
2532
# Calculate the prefix to use
2584
2548
view_str = views.view_display_str(view_files)
2585
2549
note("Ignoring files outside view. View is %s" % view_str)
2588
self.add_cleanup(tree.unlock)
2551
self.add_cleanup(tree.lock_read().unlock)
2589
2552
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2590
2553
from_dir=relpath, recursive=recursive):
2591
2554
# Apply additional masking
2640
2603
_see_also = ['ls']
2604
takes_options = ['directory']
2642
2606
@display_command
2644
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2607
def run(self, directory=u'.'):
2608
for f in WorkingTree.open_containing(directory)[0].unknowns():
2645
2609
self.outf.write(osutils.quotefn(f) + '\n')
2713
2677
_see_also = ['status', 'ignored', 'patterns']
2714
2678
takes_args = ['name_pattern*']
2679
takes_options = ['directory',
2716
2680
Option('default-rules',
2717
2681
help='Display the default ignore rules that bzr uses.')
2720
def run(self, name_pattern_list=None, default_rules=None):
2684
def run(self, name_pattern_list=None, default_rules=None,
2721
2686
from bzrlib import ignores
2722
2687
if default_rules is not None:
2723
2688
# dump the default rules and exit
2729
2694
"NAME_PATTERN or --default-rules.")
2730
2695
name_pattern_list = [globbing.normalize_pattern(p)
2731
2696
for p in name_pattern_list]
2698
for p in name_pattern_list:
2699
if not globbing.Globster.is_pattern_valid(p):
2700
bad_patterns += ('\n %s' % p)
2702
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2703
ui.ui_factory.show_error(msg)
2704
raise errors.InvalidPattern('')
2732
2705
for name_pattern in name_pattern_list:
2733
2706
if (name_pattern[0] == '/' or
2734
2707
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2735
2708
raise errors.BzrCommandError(
2736
2709
"NAME_PATTERN should not be an absolute path")
2737
tree, relpath = WorkingTree.open_containing(u'.')
2710
tree, relpath = WorkingTree.open_containing(directory)
2738
2711
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2739
2712
ignored = globbing.Globster(name_pattern_list)
2714
self.add_cleanup(tree.lock_read().unlock)
2742
2715
for entry in tree.list_files():
2744
2717
if id is not None:
2745
2718
filename = entry[0]
2746
2719
if ignored.match(filename):
2747
2720
matches.append(filename)
2749
2721
if len(matches) > 0:
2750
2722
self.outf.write("Warning: the following files are version controlled and"
2751
2723
" match your ignore pattern:\n%s"
2767
2739
encoding_type = 'replace'
2768
2740
_see_also = ['ignore', 'ls']
2741
takes_options = ['directory']
2770
2743
@display_command
2772
tree = WorkingTree.open_containing(u'.')[0]
2774
self.add_cleanup(tree.unlock)
2744
def run(self, directory=u'.'):
2745
tree = WorkingTree.open_containing(directory)[0]
2746
self.add_cleanup(tree.lock_read().unlock)
2775
2747
for path, file_class, kind, file_id, entry in tree.list_files():
2776
2748
if file_class != 'I':
2790
2762
takes_args = ['revno']
2763
takes_options = ['directory']
2792
2765
@display_command
2793
def run(self, revno):
2766
def run(self, revno, directory=u'.'):
2795
2768
revno = int(revno)
2796
2769
except ValueError:
2797
2770
raise errors.BzrCommandError("not a valid revision-number: %r"
2799
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2772
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2800
2773
self.outf.write("%s\n" % revid)
2829
2802
================= =========================
2831
2804
takes_args = ['dest', 'branch_or_subdir?']
2805
takes_options = ['directory',
2833
2806
Option('format',
2834
2807
help="Type of file to export to.",
2844
2817
'revision in which it was changed.'),
2846
2819
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2847
root=None, filters=False, per_file_timestamps=False):
2820
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2848
2821
from bzrlib.export import export
2850
2823
if branch_or_subdir is None:
2851
tree = WorkingTree.open_containing(u'.')[0]
2824
tree = WorkingTree.open_containing(directory)[0]
2852
2825
b = tree.branch
2875
2848
_see_also = ['ls']
2849
takes_options = ['directory',
2877
2850
Option('name-from-revision', help='The path name in the old tree.'),
2878
2851
Option('filters', help='Apply content filters to display the '
2879
2852
'convenience form.'),
2885
2858
@display_command
2886
2859
def run(self, filename, revision=None, name_from_revision=False,
2860
filters=False, directory=None):
2888
2861
if revision is not None and len(revision) != 1:
2889
2862
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2890
2863
" one revision specifier")
2891
2864
tree, branch, relpath = \
2892
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2894
self.add_cleanup(branch.unlock)
2865
_open_directory_or_containing_tree_or_branch(filename, directory)
2866
self.add_cleanup(branch.lock_read().unlock)
2895
2867
return self._run(tree, branch, relpath, filename, revision,
2896
2868
name_from_revision, filters)
2900
2872
if tree is None:
2901
2873
tree = b.basis_tree()
2902
2874
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2903
rev_tree.lock_read()
2904
self.add_cleanup(rev_tree.unlock)
2875
self.add_cleanup(rev_tree.lock_read().unlock)
2906
2877
old_file_id = rev_tree.path2id(relpath)
3129
3100
properties = {}
3131
tree, selected_list = tree_files(selected_list)
3102
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3132
3103
if selected_list == ['']:
3133
3104
# workaround - commit of root of tree should be exactly the same
3134
3105
# as just default commit in that tree, and succeed even though
3169
3140
def get_message(commit_obj):
3170
3141
"""Callback to get commit message"""
3172
my_message = codecs.open(
3173
file, 'rt', osutils.get_user_encoding()).read()
3145
my_message = f.read().decode(osutils.get_user_encoding())
3174
3148
elif message is not None:
3175
3149
my_message = message
3205
3179
reporter=None, verbose=verbose, revprops=properties,
3206
3180
authors=author, timestamp=commit_stamp,
3207
3181
timezone=offset,
3208
exclude=safe_relpath_files(tree, exclude))
3182
exclude=tree.safe_relpath_files(exclude))
3209
3183
except PointlessCommit:
3210
3184
raise errors.BzrCommandError("No changes to commit."
3211
3185
" Use --unchanged to commit anyhow.")
3331
3305
bzr whoami "Frank Chu <fchu@example.com>"
3333
takes_options = [ Option('email',
3307
takes_options = [ 'directory',
3334
3309
help='Display email address only.'),
3335
3310
Option('branch',
3336
3311
help='Set identity for the current branch instead of '
3340
3315
encoding_type = 'replace'
3342
3317
@display_command
3343
def run(self, email=False, branch=False, name=None):
3318
def run(self, email=False, branch=False, name=None, directory=None):
3344
3319
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()
3320
if directory is None:
3321
# use branch if we're inside one; otherwise global config
3323
c = Branch.open_containing(u'.')[0].get_config()
3324
except errors.NotBranchError:
3325
c = config.GlobalConfig()
3327
c = Branch.open(directory).get_config()
3351
3329
self.outf.write(c.user_email() + '\n')
3363
3341
# use global config unless --branch given
3365
c = Branch.open_containing('.')[0].get_config()
3343
if directory is None:
3344
c = Branch.open_containing(u'.')[0].get_config()
3346
c = Branch.open(directory).get_config()
3367
3348
c = config.GlobalConfig()
3368
3349
c.set_user_option('email', name)
3381
3362
_see_also = ['info']
3382
3363
takes_args = ['nickname?']
3383
def run(self, nickname=None):
3384
branch = Branch.open_containing(u'.')[0]
3364
takes_options = ['directory']
3365
def run(self, nickname=None, directory=u'.'):
3366
branch = Branch.open_containing(directory)[0]
3385
3367
if nickname is None:
3386
3368
self.printme(branch)
3537
3519
'throughout the test suite.',
3538
3520
type=get_transport_type),
3539
3521
Option('benchmark',
3540
help='Run the benchmarks rather than selftests.'),
3522
help='Run the benchmarks rather than selftests.',
3541
3524
Option('lsprof-timed',
3542
3525
help='Generate lsprof output for benchmarked'
3543
3526
' sections of code.'),
3544
3527
Option('lsprof-tests',
3545
3528
help='Generate lsprof output for each test.'),
3546
Option('cache-dir', type=str,
3547
help='Cache intermediate benchmark output in this '
3549
3529
Option('first',
3550
3530
help='Run all tests, but run specified tests first.',
3551
3531
short_name='f',
3586
3566
def run(self, testspecs_list=None, verbose=False, one=False,
3587
3567
transport=None, benchmark=None,
3588
lsprof_timed=None, cache_dir=None,
3589
3569
first=False, list_only=False,
3590
3570
randomize=None, exclude=None, strict=False,
3591
3571
load_list=None, debugflag=None, starting_with=None, subunit=False,
3592
3572
parallel=None, lsprof_tests=False):
3593
3573
from bzrlib.tests import selftest
3594
import bzrlib.benchmarks as benchmarks
3595
from bzrlib.benchmarks import tree_creator
3597
3575
# Make deprecation warnings visible, unless -Werror is set
3598
3576
symbol_versioning.activate_deprecation_warnings(override=False)
3600
if cache_dir is not None:
3601
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3602
3578
if testspecs_list is not None:
3603
3579
pattern = '|'.join(testspecs_list)
3612
3588
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3613
3589
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3614
3590
# stdout, which would corrupt the subunit stream.
3615
if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3591
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3592
# following code can be deleted when it's sufficiently deployed
3593
# -- vila/mgz 20100514
3594
if (sys.platform == "win32"
3595
and getattr(sys.stdout, 'fileno', None) is not None):
3617
3597
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3619
3599
self.additional_selftest_args.setdefault(
3620
3600
'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
3602
raise errors.BzrCommandError(
3603
"--benchmark is no longer supported from bzr 2.2; "
3604
"use bzr-usertest instead")
3605
test_suite_factory = None
3631
3606
selftest_kwargs = {"verbose": verbose,
3632
3607
"pattern": pattern,
3633
3608
"stop_on_failure": one,
3635
3610
"test_suite_factory": test_suite_factory,
3636
3611
"lsprof_timed": lsprof_timed,
3637
3612
"lsprof_tests": lsprof_tests,
3638
"bench_history": benchfile,
3639
3613
"matching_tests_first": first,
3640
3614
"list_only": list_only,
3641
3615
"random_seed": randomize,
3691
3665
branch1 = Branch.open_containing(branch)[0]
3692
3666
branch2 = Branch.open_containing(other)[0]
3694
self.add_cleanup(branch1.unlock)
3696
self.add_cleanup(branch2.unlock)
3667
self.add_cleanup(branch1.lock_read().unlock)
3668
self.add_cleanup(branch2.lock_read().unlock)
3697
3669
last1 = ensure_null(branch1.last_revision())
3698
3670
last2 = ensure_null(branch2.last_revision())
3793
3765
' completely merged into the source, pull from the'
3794
3766
' source rather than merging. When this happens,'
3795
3767
' you do not need to commit the result.'),
3768
custom_help('directory',
3797
3769
help='Branch to merge into, '
3798
'rather than the one containing the working directory.',
3770
'rather than the one containing the working directory.'),
3802
3771
Option('preview', help='Instead of merging, show a diff of the'
3804
3773
Option('interactive', help='Select changes interactively.',
3837
3806
unversioned_filter=tree.is_ignored, view_info=view_info)
3838
3807
pb = ui.ui_factory.nested_progress_bar()
3839
3808
self.add_cleanup(pb.finished)
3841
self.add_cleanup(tree.unlock)
3809
self.add_cleanup(tree.lock_write().unlock)
3842
3810
if location is not None:
3844
3812
mergeable = bundle.read_mergeable_from_url(location,
3905
3873
def _do_preview(self, merger):
3906
3874
from bzrlib.diff import show_diff_trees
3907
3875
result_tree = self._get_preview(merger)
3876
path_encoding = osutils.get_diff_header_encoding()
3908
3877
show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
old_label='', new_label='')
3878
old_label='', new_label='',
3879
path_encoding=path_encoding)
3911
3881
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
3882
merger.change_reporter = change_reporter
4099
4069
from bzrlib.conflicts import restore
4100
4070
if merge_type is None:
4101
4071
merge_type = _mod_merge.Merge3Merger
4102
tree, file_list = tree_files(file_list)
4104
self.add_cleanup(tree.unlock)
4072
tree, file_list = WorkingTree.open_containing_paths(file_list)
4073
self.add_cleanup(tree.lock_write().unlock)
4105
4074
parents = tree.get_parent_ids()
4106
4075
if len(parents) != 2:
4107
4076
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4217
4186
def run(self, revision=None, no_backup=False, file_list=None,
4218
4187
forget_merges=None):
4219
tree, file_list = tree_files(file_list)
4220
tree.lock_tree_write()
4221
self.add_cleanup(tree.unlock)
4188
tree, file_list = WorkingTree.open_containing_paths(file_list)
4189
self.add_cleanup(tree.lock_tree_write().unlock)
4222
4190
if forget_merges:
4223
4191
tree.set_parent_ids(tree.get_parent_ids()[:1])
4313
4281
_see_also = ['merge', 'pull']
4314
4282
takes_args = ['other_branch?']
4315
4283
takes_options = [
4316
4285
Option('reverse', 'Reverse the order of revisions.'),
4317
4286
Option('mine-only',
4318
4287
'Display changes in the local branch only.'),
4340
4309
theirs_only=False,
4341
4310
log_format=None, long=False, short=False, line=False,
4342
4311
show_ids=False, verbose=False, this=False, other=False,
4343
include_merges=False, revision=None, my_revision=None):
4312
include_merges=False, revision=None, my_revision=None,
4344
4314
from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4315
def message(s):
4346
4316
if not is_quiet():
4359
4329
elif theirs_only:
4360
4330
restrict = 'remote'
4362
local_branch = Branch.open_containing(u".")[0]
4363
local_branch.lock_read()
4364
self.add_cleanup(local_branch.unlock)
4332
local_branch = Branch.open_containing(directory)[0]
4333
self.add_cleanup(local_branch.lock_read().unlock)
4366
4335
parent = local_branch.get_parent()
4367
4336
if other_branch is None:
4378
4347
if remote_branch.base == local_branch.base:
4379
4348
remote_branch = local_branch
4381
remote_branch.lock_read()
4382
self.add_cleanup(remote_branch.unlock)
4350
self.add_cleanup(remote_branch.lock_read().unlock)
4384
4352
local_revid_range = _revision_range_to_revid_range(
4385
4353
_get_revision_range(my_revision, local_branch,
4440
4408
message("Branches are up to date.\n")
4441
4409
self.cleanup_now()
4442
4410
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)
4411
self.add_cleanup(local_branch.lock_write().unlock)
4445
4412
# handle race conditions - a parent might be set while we run.
4446
4413
if local_branch.get_parent() is None:
4447
4414
local_branch.set_parent(remote_branch.base)
4578
4544
Option('long', help='Show commit date in annotations.'),
4582
4549
encoding_type = 'exact'
4584
4551
@display_command
4585
4552
def run(self, filename, all=False, long=False, revision=None,
4553
show_ids=False, directory=None):
4587
4554
from bzrlib.annotate import annotate_file, annotate_file_tree
4588
4555
wt, branch, relpath = \
4589
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4556
_open_directory_or_containing_tree_or_branch(filename, directory)
4590
4557
if wt is not None:
4592
self.add_cleanup(wt.unlock)
4558
self.add_cleanup(wt.lock_read().unlock)
4595
self.add_cleanup(branch.unlock)
4560
self.add_cleanup(branch.lock_read().unlock)
4596
4561
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4598
self.add_cleanup(tree.unlock)
4562
self.add_cleanup(tree.lock_read().unlock)
4599
4563
if wt is not None:
4600
4564
file_id = wt.path2id(relpath)
4620
4584
hidden = True # is this right ?
4621
4585
takes_args = ['revision_id*']
4622
takes_options = ['revision']
4586
takes_options = ['directory', 'revision']
4624
def run(self, revision_id_list=None, revision=None):
4588
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4589
if revision_id_list is not None and revision is not None:
4626
4590
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4591
if revision_id_list is None and revision is None:
4628
4592
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)
4593
b = WorkingTree.open_containing(directory)[0].branch
4594
self.add_cleanup(b.lock_write().unlock)
4632
4595
return self._run(b, revision_id_list, revision)
4634
4597
def _run(self, b, revision_id_list, revision):
4694
4657
_see_also = ['checkouts', 'unbind']
4695
4658
takes_args = ['location?']
4659
takes_options = ['directory']
4698
def run(self, location=None):
4699
b, relpath = Branch.open_containing(u'.')
4661
def run(self, location=None, directory=u'.'):
4662
b, relpath = Branch.open_containing(directory)
4700
4663
if location is None:
4702
4665
location = b.get_old_bound_location()
4730
4693
_see_also = ['checkouts', 'bind']
4731
4694
takes_args = []
4695
takes_options = ['directory']
4735
b, relpath = Branch.open_containing(u'.')
4697
def run(self, directory=u'.'):
4698
b, relpath = Branch.open_containing(directory)
4736
4699
if not b.unbind():
4737
4700
raise errors.BzrCommandError('Local branch is not bound')
4784
4747
b = control.open_branch()
4786
4749
if tree is not None:
4788
self.add_cleanup(tree.unlock)
4750
self.add_cleanup(tree.lock_write().unlock)
4791
self.add_cleanup(b.unlock)
4752
self.add_cleanup(b.lock_write().unlock)
4792
4753
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4794
4755
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4902
4863
'result in a dynamically allocated port. The default port '
4903
4864
'depends on the protocol.',
4906
help='Serve contents of this directory.',
4866
custom_help('directory',
4867
help='Serve contents of this directory.'),
4908
4868
Option('allow-writes',
4909
4869
help='By default the server is a readonly server. Supplying '
4910
4870
'--allow-writes enables write access to the contents of '
4938
4898
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
4899
protocol=None):
4940
from bzrlib.transport import get_transport, transport_server_registry
4900
from bzrlib import transport
4941
4901
if directory is None:
4942
4902
directory = os.getcwd()
4943
4903
if protocol is None:
4944
protocol = transport_server_registry.get()
4904
protocol = transport.transport_server_registry.get()
4945
4905
host, port = self.get_host_and_port(port)
4946
4906
url = urlutils.local_path_to_url(directory)
4947
4907
if not allow_writes:
4948
4908
url = 'readonly+' + url
4949
transport = get_transport(url)
4950
protocol(transport, host, port, inet)
4909
t = transport.get_transport(url)
4910
protocol(t, host, port, inet)
4953
4913
class cmd_join(Command):
5064
5025
encoding_type = 'exact'
5066
5027
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
sign=False, revision=None, mail_to=None, message=None):
5028
sign=False, revision=None, mail_to=None, message=None,
5068
5030
from bzrlib.revision import ensure_null, NULL_REVISION
5069
5031
include_patch, include_bundle = {
5070
5032
'plain': (False, False),
5071
5033
'diff': (True, False),
5072
5034
'bundle': (True, True),
5074
branch = Branch.open('.')
5036
branch = Branch.open(directory)
5075
5037
stored_submit_branch = branch.get_submit_branch()
5076
5038
if submit_branch is None:
5077
5039
submit_branch = stored_submit_branch
5162
5124
given, in which case it is sent to a file.
5164
5126
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.
5127
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5166
5128
If the preferred client can't be found (or used), your editor will be used.
5168
5130
To use a specific mail program, set the mail_client configuration option.
5339
5301
Option('delete',
5340
5302
help='Delete this tag rather than placing it.',
5343
help='Branch in which to place the tag.',
5304
custom_help('directory',
5305
help='Branch in which to place the tag.'),
5347
5306
Option('force',
5348
5307
help='Replace existing tags.',
5359
5318
branch, relpath = Branch.open_containing(directory)
5361
self.add_cleanup(branch.unlock)
5319
self.add_cleanup(branch.lock_write().unlock)
5363
5321
if tag_name is None:
5364
5322
raise errors.BzrCommandError("No tag specified to delete.")
5393
5351
_see_also = ['tag']
5394
5352
takes_options = [
5396
help='Branch whose tags should be displayed.',
5353
custom_help('directory',
5354
help='Branch whose tags should be displayed.'),
5400
5355
RegistryOption.from_kwargs('sort',
5401
5356
'Sort tags by different criteria.', title='Sorting',
5402
5357
alpha='Sort tags lexicographically (default).',
5423
self.add_cleanup(branch.unlock)
5377
self.add_cleanup(branch.lock_read().unlock)
5425
5379
graph = branch.repository.get_graph()
5426
5380
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5575
5529
takes_args = ['to_location?']
5576
takes_options = [Option('force',
5530
takes_options = ['directory',
5577
5532
help='Switch even if local commits will be lost.'),
5579
5534
Option('create-branch', short_name='b',
5584
5539
def run(self, to_location=None, force=False, create_branch=False,
5540
revision=None, directory=u'.'):
5586
5541
from bzrlib import switch
5542
tree_location = directory
5588
5543
revision = _get_one_revision('switch', revision)
5589
5544
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5545
if to_location is None:
5591
5546
if revision is None:
5592
5547
raise errors.BzrCommandError('You must supply either a'
5593
5548
' revision or a location')
5549
to_location = tree_location
5596
5551
branch = control_dir.open_branch()
5597
5552
had_explicit_nick = branch.get_config().has_explicit_nickname()
5735
tree, file_list = tree_files(file_list, apply_view=False)
5690
tree, file_list = WorkingTree.open_containing_paths(file_list,
5736
5692
current_view, view_dict = tree.views.get_view_info()
5737
5693
if name is None:
5738
5694
name = current_view
5886
5843
_see_also = ['unshelve']
5888
5845
def run(self, revision=None, all=False, file_list=None, message=None,
5889
writer=None, list=False, destroy=False):
5846
writer=None, list=False, destroy=False, directory=u'.'):
5891
5848
return self.run_for_list()
5892
5849
from bzrlib.shelf_ui import Shelver
5894
5851
writer = bzrlib.option.diff_writer_registry.get()
5896
5853
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
file_list, message, destroy=destroy)
5854
file_list, message, destroy=destroy, directory=directory)
5905
5862
def run_for_list(self):
5906
5863
tree = WorkingTree.open_containing('.')[0]
5908
self.add_cleanup(tree.unlock)
5864
self.add_cleanup(tree.lock_read().unlock)
5909
5865
manager = tree.get_shelf_manager()
5910
5866
shelves = manager.active_shelves()
5911
5867
if len(shelves) == 0:
5930
5886
takes_args = ['shelf_id?']
5931
5887
takes_options = [
5932
5889
RegistryOption.from_kwargs(
5933
5890
'action', help="The action to perform.",
5934
5891
enum_switch=False, value_switches=True,
5943
5900
_see_also = ['shelve']
5945
def run(self, shelf_id=None, action='apply'):
5902
def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
5903
from bzrlib.shelf_ui import Unshelver
5947
unshelver = Unshelver.from_args(shelf_id, action)
5904
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5949
5906
unshelver.run()
5967
5924
To check what clean-tree will do, use --dry-run.
5969
takes_options = [Option('ignored', help='Delete all ignored files.'),
5926
takes_options = ['directory',
5927
Option('ignored', help='Delete all ignored files.'),
5970
5928
Option('detritus', help='Delete conflict files, merge'
5971
5929
' backups, and failed selftest dirs.'),
5972
5930
Option('unknown',
5975
5933
' deleting them.'),
5976
5934
Option('force', help='Do not prompt before deleting.')]
5977
5935
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5936
force=False, directory=u'.'):
5979
5937
from bzrlib.clean_tree import clean_tree
5980
5938
if not (unknown or ignored or detritus):
5984
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
dry_run=dry_run, no_prompt=force)
5942
clean_tree(directory, unknown=unknown, ignored=ignored,
5943
detritus=detritus, dry_run=dry_run, no_prompt=force)
5988
5946
class cmd_reference(Command):
added
removed
bzrlib/builtins.py
