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)
3499
3481
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3500
3482
into a pdb postmortem session.
3484
The --coverage=DIRNAME global option produces a report with covered code
3503
3488
Run only tests relating to 'ignore'::
3537
3522
'throughout the test suite.',
3538
3523
type=get_transport_type),
3539
3524
Option('benchmark',
3540
help='Run the benchmarks rather than selftests.'),
3525
help='Run the benchmarks rather than selftests.',
3541
3527
Option('lsprof-timed',
3542
3528
help='Generate lsprof output for benchmarked'
3543
3529
' sections of code.'),
3544
3530
Option('lsprof-tests',
3545
3531
help='Generate lsprof output for each test.'),
3546
Option('cache-dir', type=str,
3547
help='Cache intermediate benchmark output in this '
3549
3532
Option('first',
3550
3533
help='Run all tests, but run specified tests first.',
3551
3534
short_name='f',
3586
3569
def run(self, testspecs_list=None, verbose=False, one=False,
3587
3570
transport=None, benchmark=None,
3588
lsprof_timed=None, cache_dir=None,
3589
3572
first=False, list_only=False,
3590
3573
randomize=None, exclude=None, strict=False,
3591
3574
load_list=None, debugflag=None, starting_with=None, subunit=False,
3592
3575
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)
3576
from bzrlib import tests
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,
3646
3620
"starting_with": starting_with
3648
3622
selftest_kwargs.update(self.additional_selftest_args)
3649
result = selftest(**selftest_kwargs)
3624
# Make deprecation warnings visible, unless -Werror is set
3625
cleanup = symbol_versioning.activate_deprecation_warnings(
3628
result = tests.selftest(**selftest_kwargs)
3650
3631
return int(not result)
3691
3672
branch1 = Branch.open_containing(branch)[0]
3692
3673
branch2 = Branch.open_containing(other)[0]
3694
self.add_cleanup(branch1.unlock)
3696
self.add_cleanup(branch2.unlock)
3674
self.add_cleanup(branch1.lock_read().unlock)
3675
self.add_cleanup(branch2.lock_read().unlock)
3697
3676
last1 = ensure_null(branch1.last_revision())
3698
3677
last2 = ensure_null(branch2.last_revision())
3793
3772
' completely merged into the source, pull from the'
3794
3773
' source rather than merging. When this happens,'
3795
3774
' you do not need to commit the result.'),
3775
custom_help('directory',
3797
3776
help='Branch to merge into, '
3798
'rather than the one containing the working directory.',
3777
'rather than the one containing the working directory.'),
3802
3778
Option('preview', help='Instead of merging, show a diff of the'
3804
3780
Option('interactive', help='Select changes interactively.',
3837
3813
unversioned_filter=tree.is_ignored, view_info=view_info)
3838
3814
pb = ui.ui_factory.nested_progress_bar()
3839
3815
self.add_cleanup(pb.finished)
3841
self.add_cleanup(tree.unlock)
3816
self.add_cleanup(tree.lock_write().unlock)
3842
3817
if location is not None:
3844
3819
mergeable = bundle.read_mergeable_from_url(location,
3905
3880
def _do_preview(self, merger):
3906
3881
from bzrlib.diff import show_diff_trees
3907
3882
result_tree = self._get_preview(merger)
3883
path_encoding = osutils.get_diff_header_encoding()
3908
3884
show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
old_label='', new_label='')
3885
old_label='', new_label='',
3886
path_encoding=path_encoding)
3911
3888
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
3889
merger.change_reporter = change_reporter
4099
4076
from bzrlib.conflicts import restore
4100
4077
if merge_type is None:
4101
4078
merge_type = _mod_merge.Merge3Merger
4102
tree, file_list = tree_files(file_list)
4104
self.add_cleanup(tree.unlock)
4079
tree, file_list = WorkingTree.open_containing_paths(file_list)
4080
self.add_cleanup(tree.lock_write().unlock)
4105
4081
parents = tree.get_parent_ids()
4106
4082
if len(parents) != 2:
4107
4083
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4217
4193
def run(self, revision=None, no_backup=False, file_list=None,
4218
4194
forget_merges=None):
4219
tree, file_list = tree_files(file_list)
4220
tree.lock_tree_write()
4221
self.add_cleanup(tree.unlock)
4195
tree, file_list = WorkingTree.open_containing_paths(file_list)
4196
self.add_cleanup(tree.lock_tree_write().unlock)
4222
4197
if forget_merges:
4223
4198
tree.set_parent_ids(tree.get_parent_ids()[:1])
4313
4288
_see_also = ['merge', 'pull']
4314
4289
takes_args = ['other_branch?']
4315
4290
takes_options = [
4316
4292
Option('reverse', 'Reverse the order of revisions.'),
4317
4293
Option('mine-only',
4318
4294
'Display changes in the local branch only.'),
4340
4316
theirs_only=False,
4341
4317
log_format=None, long=False, short=False, line=False,
4342
4318
show_ids=False, verbose=False, this=False, other=False,
4343
include_merges=False, revision=None, my_revision=None):
4319
include_merges=False, revision=None, my_revision=None,
4344
4321
from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4322
def message(s):
4346
4323
if not is_quiet():
4359
4336
elif theirs_only:
4360
4337
restrict = 'remote'
4362
local_branch = Branch.open_containing(u".")[0]
4363
local_branch.lock_read()
4364
self.add_cleanup(local_branch.unlock)
4339
local_branch = Branch.open_containing(directory)[0]
4340
self.add_cleanup(local_branch.lock_read().unlock)
4366
4342
parent = local_branch.get_parent()
4367
4343
if other_branch is None:
4378
4354
if remote_branch.base == local_branch.base:
4379
4355
remote_branch = local_branch
4381
remote_branch.lock_read()
4382
self.add_cleanup(remote_branch.unlock)
4357
self.add_cleanup(remote_branch.lock_read().unlock)
4384
4359
local_revid_range = _revision_range_to_revid_range(
4385
4360
_get_revision_range(my_revision, local_branch,
4440
4415
message("Branches are up to date.\n")
4441
4416
self.cleanup_now()
4442
4417
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)
4418
self.add_cleanup(local_branch.lock_write().unlock)
4445
4419
# handle race conditions - a parent might be set while we run.
4446
4420
if local_branch.get_parent() is None:
4447
4421
local_branch.set_parent(remote_branch.base)
4578
4551
Option('long', help='Show commit date in annotations.'),
4582
4556
encoding_type = 'exact'
4584
4558
@display_command
4585
4559
def run(self, filename, all=False, long=False, revision=None,
4560
show_ids=False, directory=None):
4587
4561
from bzrlib.annotate import annotate_file, annotate_file_tree
4588
4562
wt, branch, relpath = \
4589
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4563
_open_directory_or_containing_tree_or_branch(filename, directory)
4590
4564
if wt is not None:
4592
self.add_cleanup(wt.unlock)
4565
self.add_cleanup(wt.lock_read().unlock)
4595
self.add_cleanup(branch.unlock)
4567
self.add_cleanup(branch.lock_read().unlock)
4596
4568
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4598
self.add_cleanup(tree.unlock)
4569
self.add_cleanup(tree.lock_read().unlock)
4599
4570
if wt is not None:
4600
4571
file_id = wt.path2id(relpath)
4620
4591
hidden = True # is this right ?
4621
4592
takes_args = ['revision_id*']
4622
takes_options = ['revision']
4593
takes_options = ['directory', 'revision']
4624
def run(self, revision_id_list=None, revision=None):
4595
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4596
if revision_id_list is not None and revision is not None:
4626
4597
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4598
if revision_id_list is None and revision is None:
4628
4599
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)
4600
b = WorkingTree.open_containing(directory)[0].branch
4601
self.add_cleanup(b.lock_write().unlock)
4632
4602
return self._run(b, revision_id_list, revision)
4634
4604
def _run(self, b, revision_id_list, revision):
4694
4664
_see_also = ['checkouts', 'unbind']
4695
4665
takes_args = ['location?']
4666
takes_options = ['directory']
4698
def run(self, location=None):
4699
b, relpath = Branch.open_containing(u'.')
4668
def run(self, location=None, directory=u'.'):
4669
b, relpath = Branch.open_containing(directory)
4700
4670
if location is None:
4702
4672
location = b.get_old_bound_location()
4730
4700
_see_also = ['checkouts', 'bind']
4731
4701
takes_args = []
4702
takes_options = ['directory']
4735
b, relpath = Branch.open_containing(u'.')
4704
def run(self, directory=u'.'):
4705
b, relpath = Branch.open_containing(directory)
4736
4706
if not b.unbind():
4737
4707
raise errors.BzrCommandError('Local branch is not bound')
4784
4754
b = control.open_branch()
4786
4756
if tree is not None:
4788
self.add_cleanup(tree.unlock)
4757
self.add_cleanup(tree.lock_write().unlock)
4791
self.add_cleanup(b.unlock)
4759
self.add_cleanup(b.lock_write().unlock)
4792
4760
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4794
4762
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4848
4816
class cmd_break_lock(Command):
4849
__doc__ = """Break a dead lock on a repository, branch or working directory.
4817
__doc__ = """Break a dead lock.
4819
This command breaks a lock on a repository, branch, working directory or
4851
4822
CAUTION: Locks should only be broken when you are sure that the process
4852
4823
holding the lock has been stopped.
4859
4830
bzr break-lock bzr+ssh://example.com/bzr/foo
4831
bzr break-lock --conf ~/.bazaar
4861
4834
takes_args = ['location?']
4837
help='LOCATION is the directory where the config lock is.'),
4863
def run(self, location=None, show=False):
4840
def run(self, location=None, config=False):
4864
4841
if location is None:
4865
4842
location = u'.'
4866
control, relpath = bzrdir.BzrDir.open_containing(location)
4868
control.break_lock()
4869
except NotImplementedError:
4844
conf = _mod_config.LockableConfig(file_name=location)
4847
control, relpath = bzrdir.BzrDir.open_containing(location)
4849
control.break_lock()
4850
except NotImplementedError:
4873
4854
class cmd_wait_until_signalled(Command):
4902
4883
'result in a dynamically allocated port. The default port '
4903
4884
'depends on the protocol.',
4906
help='Serve contents of this directory.',
4886
custom_help('directory',
4887
help='Serve contents of this directory.'),
4908
4888
Option('allow-writes',
4909
4889
help='By default the server is a readonly server. Supplying '
4910
4890
'--allow-writes enables write access to the contents of '
4938
4918
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
4919
protocol=None):
4940
from bzrlib.transport import get_transport, transport_server_registry
4920
from bzrlib import transport
4941
4921
if directory is None:
4942
4922
directory = os.getcwd()
4943
4923
if protocol is None:
4944
protocol = transport_server_registry.get()
4924
protocol = transport.transport_server_registry.get()
4945
4925
host, port = self.get_host_and_port(port)
4946
4926
url = urlutils.local_path_to_url(directory)
4947
4927
if not allow_writes:
4948
4928
url = 'readonly+' + url
4949
transport = get_transport(url)
4950
protocol(transport, host, port, inet)
4929
t = transport.get_transport(url)
4930
protocol(t, host, port, inet)
4953
4933
class cmd_join(Command):
5064
5045
encoding_type = 'exact'
5066
5047
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
sign=False, revision=None, mail_to=None, message=None):
5048
sign=False, revision=None, mail_to=None, message=None,
5068
5050
from bzrlib.revision import ensure_null, NULL_REVISION
5069
5051
include_patch, include_bundle = {
5070
5052
'plain': (False, False),
5071
5053
'diff': (True, False),
5072
5054
'bundle': (True, True),
5074
branch = Branch.open('.')
5056
branch = Branch.open(directory)
5075
5057
stored_submit_branch = branch.get_submit_branch()
5076
5058
if submit_branch is None:
5077
5059
submit_branch = stored_submit_branch
5162
5144
given, in which case it is sent to a file.
5164
5146
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.
5147
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5166
5148
If the preferred client can't be found (or used), your editor will be used.
5168
5150
To use a specific mail program, set the mail_client configuration option.
5339
5321
Option('delete',
5340
5322
help='Delete this tag rather than placing it.',
5343
help='Branch in which to place the tag.',
5324
custom_help('directory',
5325
help='Branch in which to place the tag.'),
5347
5326
Option('force',
5348
5327
help='Replace existing tags.',
5359
5338
branch, relpath = Branch.open_containing(directory)
5361
self.add_cleanup(branch.unlock)
5339
self.add_cleanup(branch.lock_write().unlock)
5363
5341
if tag_name is None:
5364
5342
raise errors.BzrCommandError("No tag specified to delete.")
5393
5371
_see_also = ['tag']
5394
5372
takes_options = [
5396
help='Branch whose tags should be displayed.',
5373
custom_help('directory',
5374
help='Branch whose tags should be displayed.'),
5400
5375
RegistryOption.from_kwargs('sort',
5401
5376
'Sort tags by different criteria.', title='Sorting',
5402
5377
alpha='Sort tags lexicographically (default).',
5423
self.add_cleanup(branch.unlock)
5397
self.add_cleanup(branch.lock_read().unlock)
5425
5399
graph = branch.repository.get_graph()
5426
5400
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5575
5549
takes_args = ['to_location?']
5576
takes_options = [Option('force',
5550
takes_options = ['directory',
5577
5552
help='Switch even if local commits will be lost.'),
5579
5554
Option('create-branch', short_name='b',
5584
5559
def run(self, to_location=None, force=False, create_branch=False,
5560
revision=None, directory=u'.'):
5586
5561
from bzrlib import switch
5562
tree_location = directory
5588
5563
revision = _get_one_revision('switch', revision)
5589
5564
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5565
if to_location is None:
5591
5566
if revision is None:
5592
5567
raise errors.BzrCommandError('You must supply either a'
5593
5568
' revision or a location')
5569
to_location = tree_location
5596
5571
branch = control_dir.open_branch()
5597
5572
had_explicit_nick = branch.get_config().has_explicit_nickname()
5735
tree, file_list = tree_files(file_list, apply_view=False)
5710
tree, file_list = WorkingTree.open_containing_paths(file_list,
5736
5712
current_view, view_dict = tree.views.get_view_info()
5737
5713
if name is None:
5738
5714
name = current_view
5886
5863
_see_also = ['unshelve']
5888
5865
def run(self, revision=None, all=False, file_list=None, message=None,
5889
writer=None, list=False, destroy=False):
5866
writer=None, list=False, destroy=False, directory=u'.'):
5891
5868
return self.run_for_list()
5892
5869
from bzrlib.shelf_ui import Shelver
5894
5871
writer = bzrlib.option.diff_writer_registry.get()
5896
5873
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
file_list, message, destroy=destroy)
5874
file_list, message, destroy=destroy, directory=directory)
5905
5882
def run_for_list(self):
5906
5883
tree = WorkingTree.open_containing('.')[0]
5908
self.add_cleanup(tree.unlock)
5884
self.add_cleanup(tree.lock_read().unlock)
5909
5885
manager = tree.get_shelf_manager()
5910
5886
shelves = manager.active_shelves()
5911
5887
if len(shelves) == 0:
5930
5906
takes_args = ['shelf_id?']
5931
5907
takes_options = [
5932
5909
RegistryOption.from_kwargs(
5933
5910
'action', help="The action to perform.",
5934
5911
enum_switch=False, value_switches=True,
5943
5920
_see_also = ['shelve']
5945
def run(self, shelf_id=None, action='apply'):
5922
def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
5923
from bzrlib.shelf_ui import Unshelver
5947
unshelver = Unshelver.from_args(shelf_id, action)
5924
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5949
5926
unshelver.run()
5967
5944
To check what clean-tree will do, use --dry-run.
5969
takes_options = [Option('ignored', help='Delete all ignored files.'),
5946
takes_options = ['directory',
5947
Option('ignored', help='Delete all ignored files.'),
5970
5948
Option('detritus', help='Delete conflict files, merge'
5971
5949
' backups, and failed selftest dirs.'),
5972
5950
Option('unknown',
5975
5953
' deleting them.'),
5976
5954
Option('force', help='Do not prompt before deleting.')]
5977
5955
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5956
force=False, directory=u'.'):
5979
5957
from bzrlib.clean_tree import clean_tree
5980
5958
if not (unknown or ignored or detritus):
5984
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
dry_run=dry_run, no_prompt=force)
5962
clean_tree(directory, unknown=unknown, ignored=ignored,
5963
detritus=detritus, dry_run=dry_run, no_prompt=force)
5988
5966
class cmd_reference(Command):
added
removed
bzrlib/builtins.py
