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 = _mod_config.GlobalConfig()
3327
c = Branch.open(directory).get_config()
3351
3329
self.outf.write(c.user_email() + '\n')
3356
3334
# display a warning if an email address isn't included in the given name.
3358
config.extract_email_address(name)
3336
_mod_config.extract_email_address(name)
3359
3337
except errors.NoEmailInUsername, e:
3360
3338
warning('"%s" does not seem to contain an email address. '
3361
3339
'This is allowed, but not recommended.', name)
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
c = config.GlobalConfig()
3348
c = _mod_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)
3436
3418
'bzr alias --remove expects an alias to remove.')
3437
3419
# If alias is not found, print something like:
3438
3420
# unalias: foo: not found
3439
c = config.GlobalConfig()
3421
c = _mod_config.GlobalConfig()
3440
3422
c.unset_alias(alias_name)
3442
3424
@display_command
3443
3425
def print_aliases(self):
3444
3426
"""Print out the defined aliases in a similar format to bash."""
3445
aliases = config.GlobalConfig().get_aliases()
3427
aliases = _mod_config.GlobalConfig().get_aliases()
3446
3428
for key, value in sorted(aliases.iteritems()):
3447
3429
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3459
3441
def set_alias(self, alias_name, alias_command):
3460
3442
"""Save the alias in the global config."""
3461
c = config.GlobalConfig()
3443
c = _mod_config.GlobalConfig()
3462
3444
c.set_alias(alias_name, alias_command)
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
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)
3573
from bzrlib import tests
3602
3575
if testspecs_list is not None:
3603
3576
pattern = '|'.join(testspecs_list)
3612
3585
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3613
3586
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3614
3587
# stdout, which would corrupt the subunit stream.
3615
if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3588
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3589
# following code can be deleted when it's sufficiently deployed
3590
# -- vila/mgz 20100514
3591
if (sys.platform == "win32"
3592
and getattr(sys.stdout, 'fileno', None) is not None):
3617
3594
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3619
3596
self.additional_selftest_args.setdefault(
3620
3597
'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
3599
raise errors.BzrCommandError(
3600
"--benchmark is no longer supported from bzr 2.2; "
3601
"use bzr-usertest instead")
3602
test_suite_factory = None
3631
3603
selftest_kwargs = {"verbose": verbose,
3632
3604
"pattern": pattern,
3633
3605
"stop_on_failure": one,
3635
3607
"test_suite_factory": test_suite_factory,
3636
3608
"lsprof_timed": lsprof_timed,
3637
3609
"lsprof_tests": lsprof_tests,
3638
"bench_history": benchfile,
3639
3610
"matching_tests_first": first,
3640
3611
"list_only": list_only,
3641
3612
"random_seed": randomize,
3646
3617
"starting_with": starting_with
3648
3619
selftest_kwargs.update(self.additional_selftest_args)
3649
result = selftest(**selftest_kwargs)
3621
# Make deprecation warnings visible, unless -Werror is set
3622
cleanup = symbol_versioning.activate_deprecation_warnings(
3625
result = tests.selftest(**selftest_kwargs)
3650
3628
return int(not result)
3691
3669
branch1 = Branch.open_containing(branch)[0]
3692
3670
branch2 = Branch.open_containing(other)[0]
3694
self.add_cleanup(branch1.unlock)
3696
self.add_cleanup(branch2.unlock)
3671
self.add_cleanup(branch1.lock_read().unlock)
3672
self.add_cleanup(branch2.lock_read().unlock)
3697
3673
last1 = ensure_null(branch1.last_revision())
3698
3674
last2 = ensure_null(branch2.last_revision())
3793
3769
' completely merged into the source, pull from the'
3794
3770
' source rather than merging. When this happens,'
3795
3771
' you do not need to commit the result.'),
3772
custom_help('directory',
3797
3773
help='Branch to merge into, '
3798
'rather than the one containing the working directory.',
3774
'rather than the one containing the working directory.'),
3802
3775
Option('preview', help='Instead of merging, show a diff of the'
3804
3777
Option('interactive', help='Select changes interactively.',
3837
3810
unversioned_filter=tree.is_ignored, view_info=view_info)
3838
3811
pb = ui.ui_factory.nested_progress_bar()
3839
3812
self.add_cleanup(pb.finished)
3841
self.add_cleanup(tree.unlock)
3813
self.add_cleanup(tree.lock_write().unlock)
3842
3814
if location is not None:
3844
3816
mergeable = bundle.read_mergeable_from_url(location,
3905
3877
def _do_preview(self, merger):
3906
3878
from bzrlib.diff import show_diff_trees
3907
3879
result_tree = self._get_preview(merger)
3880
path_encoding = osutils.get_diff_header_encoding()
3908
3881
show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
old_label='', new_label='')
3882
old_label='', new_label='',
3883
path_encoding=path_encoding)
3911
3885
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
3886
merger.change_reporter = change_reporter
4099
4073
from bzrlib.conflicts import restore
4100
4074
if merge_type is None:
4101
4075
merge_type = _mod_merge.Merge3Merger
4102
tree, file_list = tree_files(file_list)
4104
self.add_cleanup(tree.unlock)
4076
tree, file_list = WorkingTree.open_containing_paths(file_list)
4077
self.add_cleanup(tree.lock_write().unlock)
4105
4078
parents = tree.get_parent_ids()
4106
4079
if len(parents) != 2:
4107
4080
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4217
4190
def run(self, revision=None, no_backup=False, file_list=None,
4218
4191
forget_merges=None):
4219
tree, file_list = tree_files(file_list)
4220
tree.lock_tree_write()
4221
self.add_cleanup(tree.unlock)
4192
tree, file_list = WorkingTree.open_containing_paths(file_list)
4193
self.add_cleanup(tree.lock_tree_write().unlock)
4222
4194
if forget_merges:
4223
4195
tree.set_parent_ids(tree.get_parent_ids()[:1])
4313
4285
_see_also = ['merge', 'pull']
4314
4286
takes_args = ['other_branch?']
4315
4287
takes_options = [
4316
4289
Option('reverse', 'Reverse the order of revisions.'),
4317
4290
Option('mine-only',
4318
4291
'Display changes in the local branch only.'),
4340
4313
theirs_only=False,
4341
4314
log_format=None, long=False, short=False, line=False,
4342
4315
show_ids=False, verbose=False, this=False, other=False,
4343
include_merges=False, revision=None, my_revision=None):
4316
include_merges=False, revision=None, my_revision=None,
4344
4318
from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4319
def message(s):
4346
4320
if not is_quiet():
4359
4333
elif theirs_only:
4360
4334
restrict = 'remote'
4362
local_branch = Branch.open_containing(u".")[0]
4363
local_branch.lock_read()
4364
self.add_cleanup(local_branch.unlock)
4336
local_branch = Branch.open_containing(directory)[0]
4337
self.add_cleanup(local_branch.lock_read().unlock)
4366
4339
parent = local_branch.get_parent()
4367
4340
if other_branch is None:
4378
4351
if remote_branch.base == local_branch.base:
4379
4352
remote_branch = local_branch
4381
remote_branch.lock_read()
4382
self.add_cleanup(remote_branch.unlock)
4354
self.add_cleanup(remote_branch.lock_read().unlock)
4384
4356
local_revid_range = _revision_range_to_revid_range(
4385
4357
_get_revision_range(my_revision, local_branch,
4440
4412
message("Branches are up to date.\n")
4441
4413
self.cleanup_now()
4442
4414
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)
4415
self.add_cleanup(local_branch.lock_write().unlock)
4445
4416
# handle race conditions - a parent might be set while we run.
4446
4417
if local_branch.get_parent() is None:
4447
4418
local_branch.set_parent(remote_branch.base)
4578
4548
Option('long', help='Show commit date in annotations.'),
4582
4553
encoding_type = 'exact'
4584
4555
@display_command
4585
4556
def run(self, filename, all=False, long=False, revision=None,
4557
show_ids=False, directory=None):
4587
4558
from bzrlib.annotate import annotate_file, annotate_file_tree
4588
4559
wt, branch, relpath = \
4589
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4560
_open_directory_or_containing_tree_or_branch(filename, directory)
4590
4561
if wt is not None:
4592
self.add_cleanup(wt.unlock)
4562
self.add_cleanup(wt.lock_read().unlock)
4595
self.add_cleanup(branch.unlock)
4564
self.add_cleanup(branch.lock_read().unlock)
4596
4565
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4598
self.add_cleanup(tree.unlock)
4566
self.add_cleanup(tree.lock_read().unlock)
4599
4567
if wt is not None:
4600
4568
file_id = wt.path2id(relpath)
4620
4588
hidden = True # is this right ?
4621
4589
takes_args = ['revision_id*']
4622
takes_options = ['revision']
4590
takes_options = ['directory', 'revision']
4624
def run(self, revision_id_list=None, revision=None):
4592
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4593
if revision_id_list is not None and revision is not None:
4626
4594
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4595
if revision_id_list is None and revision is None:
4628
4596
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)
4597
b = WorkingTree.open_containing(directory)[0].branch
4598
self.add_cleanup(b.lock_write().unlock)
4632
4599
return self._run(b, revision_id_list, revision)
4634
4601
def _run(self, b, revision_id_list, revision):
4694
4661
_see_also = ['checkouts', 'unbind']
4695
4662
takes_args = ['location?']
4663
takes_options = ['directory']
4698
def run(self, location=None):
4699
b, relpath = Branch.open_containing(u'.')
4665
def run(self, location=None, directory=u'.'):
4666
b, relpath = Branch.open_containing(directory)
4700
4667
if location is None:
4702
4669
location = b.get_old_bound_location()
4730
4697
_see_also = ['checkouts', 'bind']
4731
4698
takes_args = []
4699
takes_options = ['directory']
4735
b, relpath = Branch.open_containing(u'.')
4701
def run(self, directory=u'.'):
4702
b, relpath = Branch.open_containing(directory)
4736
4703
if not b.unbind():
4737
4704
raise errors.BzrCommandError('Local branch is not bound')
4784
4751
b = control.open_branch()
4786
4753
if tree is not None:
4788
self.add_cleanup(tree.unlock)
4754
self.add_cleanup(tree.lock_write().unlock)
4791
self.add_cleanup(b.unlock)
4756
self.add_cleanup(b.lock_write().unlock)
4792
4757
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4794
4759
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4848
4813
class cmd_break_lock(Command):
4849
__doc__ = """Break a dead lock on a repository, branch or working directory.
4814
__doc__ = """Break a dead lock.
4816
This command breaks a lock on a repository, branch, working directory or
4851
4819
CAUTION: Locks should only be broken when you are sure that the process
4852
4820
holding the lock has been stopped.
4859
4827
bzr break-lock bzr+ssh://example.com/bzr/foo
4828
bzr break-lock --conf ~/.bazaar
4861
4831
takes_args = ['location?']
4834
help='LOCATION is the directory where the config lock is.'),
4863
def run(self, location=None, show=False):
4837
def run(self, location=None, config=False):
4864
4838
if location is None:
4865
4839
location = u'.'
4866
control, relpath = bzrdir.BzrDir.open_containing(location)
4868
control.break_lock()
4869
except NotImplementedError:
4841
conf = _mod_config.LockableConfig(file_name=location)
4844
control, relpath = bzrdir.BzrDir.open_containing(location)
4846
control.break_lock()
4847
except NotImplementedError:
4873
4851
class cmd_wait_until_signalled(Command):
4902
4880
'result in a dynamically allocated port. The default port '
4903
4881
'depends on the protocol.',
4906
help='Serve contents of this directory.',
4883
custom_help('directory',
4884
help='Serve contents of this directory.'),
4908
4885
Option('allow-writes',
4909
4886
help='By default the server is a readonly server. Supplying '
4910
4887
'--allow-writes enables write access to the contents of '
4938
4915
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
4916
protocol=None):
4940
from bzrlib.transport import get_transport, transport_server_registry
4917
from bzrlib import transport
4941
4918
if directory is None:
4942
4919
directory = os.getcwd()
4943
4920
if protocol is None:
4944
protocol = transport_server_registry.get()
4921
protocol = transport.transport_server_registry.get()
4945
4922
host, port = self.get_host_and_port(port)
4946
4923
url = urlutils.local_path_to_url(directory)
4947
4924
if not allow_writes:
4948
4925
url = 'readonly+' + url
4949
transport = get_transport(url)
4950
protocol(transport, host, port, inet)
4926
t = transport.get_transport(url)
4927
protocol(t, host, port, inet)
4953
4930
class cmd_join(Command):
5064
5042
encoding_type = 'exact'
5066
5044
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
sign=False, revision=None, mail_to=None, message=None):
5045
sign=False, revision=None, mail_to=None, message=None,
5068
5047
from bzrlib.revision import ensure_null, NULL_REVISION
5069
5048
include_patch, include_bundle = {
5070
5049
'plain': (False, False),
5071
5050
'diff': (True, False),
5072
5051
'bundle': (True, True),
5074
branch = Branch.open('.')
5053
branch = Branch.open(directory)
5075
5054
stored_submit_branch = branch.get_submit_branch()
5076
5055
if submit_branch is None:
5077
5056
submit_branch = stored_submit_branch
5162
5141
given, in which case it is sent to a file.
5164
5143
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.
5144
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5166
5145
If the preferred client can't be found (or used), your editor will be used.
5168
5147
To use a specific mail program, set the mail_client configuration option.
5339
5318
Option('delete',
5340
5319
help='Delete this tag rather than placing it.',
5343
help='Branch in which to place the tag.',
5321
custom_help('directory',
5322
help='Branch in which to place the tag.'),
5347
5323
Option('force',
5348
5324
help='Replace existing tags.',
5359
5335
branch, relpath = Branch.open_containing(directory)
5361
self.add_cleanup(branch.unlock)
5336
self.add_cleanup(branch.lock_write().unlock)
5363
5338
if tag_name is None:
5364
5339
raise errors.BzrCommandError("No tag specified to delete.")
5393
5368
_see_also = ['tag']
5394
5369
takes_options = [
5396
help='Branch whose tags should be displayed.',
5370
custom_help('directory',
5371
help='Branch whose tags should be displayed.'),
5400
5372
RegistryOption.from_kwargs('sort',
5401
5373
'Sort tags by different criteria.', title='Sorting',
5402
5374
alpha='Sort tags lexicographically (default).',
5423
self.add_cleanup(branch.unlock)
5394
self.add_cleanup(branch.lock_read().unlock)
5425
5396
graph = branch.repository.get_graph()
5426
5397
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5575
5546
takes_args = ['to_location?']
5576
takes_options = [Option('force',
5547
takes_options = ['directory',
5577
5549
help='Switch even if local commits will be lost.'),
5579
5551
Option('create-branch', short_name='b',
5584
5556
def run(self, to_location=None, force=False, create_branch=False,
5557
revision=None, directory=u'.'):
5586
5558
from bzrlib import switch
5559
tree_location = directory
5588
5560
revision = _get_one_revision('switch', revision)
5589
5561
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5562
if to_location is None:
5591
5563
if revision is None:
5592
5564
raise errors.BzrCommandError('You must supply either a'
5593
5565
' revision or a location')
5566
to_location = tree_location
5596
5568
branch = control_dir.open_branch()
5597
5569
had_explicit_nick = branch.get_config().has_explicit_nickname()
5735
tree, file_list = tree_files(file_list, apply_view=False)
5707
tree, file_list = WorkingTree.open_containing_paths(file_list,
5736
5709
current_view, view_dict = tree.views.get_view_info()
5737
5710
if name is None:
5738
5711
name = current_view
5886
5860
_see_also = ['unshelve']
5888
5862
def run(self, revision=None, all=False, file_list=None, message=None,
5889
writer=None, list=False, destroy=False):
5863
writer=None, list=False, destroy=False, directory=u'.'):
5891
5865
return self.run_for_list()
5892
5866
from bzrlib.shelf_ui import Shelver
5894
5868
writer = bzrlib.option.diff_writer_registry.get()
5896
5870
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
file_list, message, destroy=destroy)
5871
file_list, message, destroy=destroy, directory=directory)
5905
5879
def run_for_list(self):
5906
5880
tree = WorkingTree.open_containing('.')[0]
5908
self.add_cleanup(tree.unlock)
5881
self.add_cleanup(tree.lock_read().unlock)
5909
5882
manager = tree.get_shelf_manager()
5910
5883
shelves = manager.active_shelves()
5911
5884
if len(shelves) == 0:
5930
5903
takes_args = ['shelf_id?']
5931
5904
takes_options = [
5932
5906
RegistryOption.from_kwargs(
5933
5907
'action', help="The action to perform.",
5934
5908
enum_switch=False, value_switches=True,
5943
5917
_see_also = ['shelve']
5945
def run(self, shelf_id=None, action='apply'):
5919
def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
5920
from bzrlib.shelf_ui import Unshelver
5947
unshelver = Unshelver.from_args(shelf_id, action)
5921
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5949
5923
unshelver.run()
5967
5941
To check what clean-tree will do, use --dry-run.
5969
takes_options = [Option('ignored', help='Delete all ignored files.'),
5943
takes_options = ['directory',
5944
Option('ignored', help='Delete all ignored files.'),
5970
5945
Option('detritus', help='Delete conflict files, merge'
5971
5946
' backups, and failed selftest dirs.'),
5972
5947
Option('unknown',
5975
5950
' deleting them.'),
5976
5951
Option('force', help='Do not prompt before deleting.')]
5977
5952
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5953
force=False, directory=u'.'):
5979
5954
from bzrlib.clean_tree import clean_tree
5980
5955
if not (unknown or ignored or detritus):
5984
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
dry_run=dry_run, no_prompt=force)
5959
clean_tree(directory, unknown=unknown, ignored=ignored,
5960
detritus=detritus, dry_run=dry_run, no_prompt=force)
5988
5963
class cmd_reference(Command):
added
removed
bzrlib/builtins.py
