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 "
972
924
"the master branch."
927
help="Show base revision text in conflicts.")
975
929
takes_args = ['location?']
976
930
encoding_type = 'replace'
978
932
def run(self, location=None, remember=False, overwrite=False,
979
933
revision=None, verbose=False,
980
directory=None, local=False):
934
directory=None, local=False,
981
936
# FIXME: too much stuff is in the command class
982
937
revision_id = None
987
942
tree_to = WorkingTree.open_containing(directory)[0]
988
943
branch_to = tree_to.branch
990
self.add_cleanup(tree_to.unlock)
944
self.add_cleanup(tree_to.lock_write().unlock)
991
945
except errors.NoWorkingTree:
993
947
branch_to = Branch.open_containing(directory)[0]
994
branch_to.lock_write()
995
self.add_cleanup(branch_to.unlock)
948
self.add_cleanup(branch_to.lock_write().unlock)
950
if tree_to is None and show_base:
951
raise errors.BzrCommandError("Need working tree for --show-base.")
997
953
if local and not branch_to.get_bound_location():
998
954
raise errors.LocalRequiresBoundBranch()
1030
986
branch_from = Branch.open(location,
1031
987
possible_transports=possible_transports)
1032
branch_from.lock_read()
1033
self.add_cleanup(branch_from.unlock)
988
self.add_cleanup(branch_from.lock_read().unlock)
1035
990
if branch_to.get_parent() is None or remember:
1036
991
branch_to.set_parent(branch_from.base)
1045
1000
view_info=view_info)
1046
1001
result = tree_to.pull(
1047
1002
branch_from, overwrite, revision_id, change_reporter,
1048
possible_transports=possible_transports, local=local)
1003
possible_transports=possible_transports, local=local,
1004
show_base=show_base)
1050
1006
result = branch_to.pull(
1051
1007
branch_from, overwrite, revision_id, local=local)
1088
1044
Option('create-prefix',
1089
1045
help='Create the path leading up to the branch '
1090
1046
'if it does not already exist.'),
1047
custom_help('directory',
1092
1048
help='Branch to push from, '
1093
'rather than the one containing the working directory.',
1049
'rather than the one containing the working directory.'),
1097
1050
Option('use-existing-dir',
1098
1051
help='By default push will fail if the target'
1099
1052
' directory exists, but does not already'
1189
1142
_see_also = ['checkout']
1190
1143
takes_args = ['from_location', 'to_location?']
1191
takes_options = ['revision', Option('hardlink',
1192
help='Hard-link working tree files where possible.'),
1144
takes_options = ['revision',
1145
Option('hardlink', help='Hard-link working tree files where possible.'),
1146
Option('files-from', type=str,
1147
help="Get file contents from this tree."),
1193
1148
Option('no-tree',
1194
1149
help="Create a branch without a working-tree."),
1195
1150
Option('switch',
1214
1169
def run(self, from_location, to_location=None, revision=None,
1215
1170
hardlink=False, stacked=False, standalone=False, no_tree=False,
1216
use_existing_dir=False, switch=False, bind=False):
1171
use_existing_dir=False, switch=False, bind=False,
1217
1173
from bzrlib import switch as _mod_switch
1218
1174
from bzrlib.tag import _merge_tags_if_possible
1219
1175
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1177
if not (hardlink or files_from):
1178
# accelerator_tree is usually slower because you have to read N
1179
# files (no readahead, lots of seeks, etc), but allow the user to
1180
# explicitly request it
1181
accelerator_tree = None
1182
if files_from is not None and files_from != from_location:
1183
accelerator_tree = WorkingTree.open(files_from)
1221
1184
revision = _get_one_revision('branch', revision)
1223
self.add_cleanup(br_from.unlock)
1185
self.add_cleanup(br_from.lock_read().unlock)
1224
1186
if revision is not None:
1225
1187
revision_id = revision.as_revision_id(br_from)
1331
1293
to_location = branch_location
1332
1294
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1333
1295
branch_location)
1296
if not (hardlink or files_from):
1297
# accelerator_tree is usually slower because you have to read N
1298
# files (no readahead, lots of seeks, etc), but allow the user to
1299
# explicitly request it
1300
accelerator_tree = None
1334
1301
revision = _get_one_revision('checkout', revision)
1335
if files_from is not None:
1302
if files_from is not None and files_from != branch_location:
1336
1303
accelerator_tree = WorkingTree.open(files_from)
1337
1304
if revision is not None:
1338
1305
revision_id = revision.as_revision_id(source)
1366
1333
@display_command
1367
1334
def run(self, dir=u'.'):
1368
1335
tree = WorkingTree.open_containing(dir)[0]
1370
self.add_cleanup(tree.unlock)
1336
self.add_cleanup(tree.lock_read().unlock)
1371
1337
new_inv = tree.inventory
1372
1338
old_tree = tree.basis_tree()
1373
old_tree.lock_read()
1374
self.add_cleanup(old_tree.unlock)
1339
self.add_cleanup(old_tree.lock_read().unlock)
1375
1340
old_inv = old_tree.inventory
1377
1342
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1403
1368
_see_also = ['pull', 'working-trees', 'status-flags']
1404
1369
takes_args = ['dir?']
1405
takes_options = ['revision']
1370
takes_options = ['revision',
1372
help="Show base revision text in conflicts."),
1406
1374
aliases = ['up']
1408
def run(self, dir='.', revision=None):
1376
def run(self, dir='.', revision=None,show_base=None):
1409
1377
if revision is not None and len(revision) != 1:
1410
1378
raise errors.BzrCommandError(
1411
1379
"bzr update --revision takes exactly one revision")
1415
1383
master = branch.get_master_branch(
1416
1384
possible_transports=possible_transports)
1417
1385
if master is not None:
1419
1386
branch_location = master.base
1389
branch_location = tree.branch.base
1421
1390
tree.lock_tree_write()
1422
branch_location = tree.branch.base
1423
1391
self.add_cleanup(tree.unlock)
1424
1392
# get rid of the final '/' and be ready for display
1425
1393
branch_location = urlutils.unescape_for_display(
1451
1419
change_reporter,
1452
1420
possible_transports=possible_transports,
1453
1421
revision=revision_id,
1423
show_base=show_base)
1455
1424
except errors.NoSuchRevision, e:
1456
1425
raise errors.BzrCommandError(
1457
1426
"branch has no revision %s\n"
1519
1488
class cmd_remove(Command):
1520
1489
__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.
1491
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1492
delete them if they can easily be recovered using revert otherwise they
1493
will be backed up (adding an extention of the form .~#~). If no options or
1494
parameters are given Bazaar will scan for files that are being tracked by
1495
Bazaar but missing in your tree and stop tracking them for you.
1527
1497
takes_args = ['file*']
1528
1498
takes_options = ['verbose',
1530
1500
RegistryOption.from_kwargs('file-deletion-strategy',
1531
1501
'The file deletion mode to be used.',
1532
1502
title='Deletion Strategy', value_switches=True, enum_switch=False,
1533
safe='Only delete files if they can be'
1534
' safely recovered (default).',
1503
safe='Backup changed files (default).',
1535
1504
keep='Delete from bzr but leave the working copy.',
1536
1505
force='Delete all the specified files, even if they can not be '
1537
1506
'recovered and even if they are non-empty directories.')]
1541
1510
def run(self, file_list, verbose=False, new=False,
1542
1511
file_deletion_strategy='safe'):
1543
tree, file_list = tree_files(file_list)
1512
tree, file_list = WorkingTree.open_containing_paths(file_list)
1545
1514
if file_list is not None:
1546
1515
file_list = [f for f in file_list]
1549
self.add_cleanup(tree.unlock)
1517
self.add_cleanup(tree.lock_write().unlock)
1550
1518
# Heuristics should probably all move into tree.remove_smart or
1636
1604
_see_also = ['check']
1637
1605
takes_args = ['branch?']
1607
Option('canonicalize-chks',
1608
help='Make sure CHKs are in canonical form (repairs '
1639
def run(self, branch="."):
1613
def run(self, branch=".", canonicalize_chks=False):
1640
1614
from bzrlib.reconcile import reconcile
1641
1615
dir = bzrdir.BzrDir.open(branch)
1616
reconcile(dir, canonicalize_chks=canonicalize_chks)
1645
1619
class cmd_revision_history(Command):
1985
1963
old_branch, new_branch,
1986
1964
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1987
1965
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1966
# GNU diff on Windows uses ANSI encoding for filenames
1967
path_encoding = osutils.get_diff_header_encoding()
1988
1968
return show_diff_trees(old_tree, new_tree, sys.stdout,
1989
1969
specific_files=specific_files,
1990
1970
external_diff_options=diff_options,
1991
1971
old_label=old_label, new_label=new_label,
1992
extra_trees=extra_trees, using=using,
1972
extra_trees=extra_trees,
1973
path_encoding=path_encoding,
1993
1975
format_cls=format)
2003
1985
# level of effort but possibly much less IO. (Or possibly not,
2004
1986
# if the directories are very large...)
2005
1987
_see_also = ['status', 'ls']
2006
takes_options = ['show-ids']
1988
takes_options = ['directory', 'show-ids']
2008
1990
@display_command
2009
def run(self, show_ids=False):
2010
tree = WorkingTree.open_containing(u'.')[0]
2012
self.add_cleanup(tree.unlock)
1991
def run(self, show_ids=False, directory=u'.'):
1992
tree = WorkingTree.open_containing(directory)[0]
1993
self.add_cleanup(tree.lock_read().unlock)
2013
1994
old = tree.basis_tree()
2015
self.add_cleanup(old.unlock)
1995
self.add_cleanup(old.lock_read().unlock)
2016
1996
for path, ie in old.inventory.iter_entries():
2017
1997
if not tree.has_id(ie.file_id):
2018
1998
self.outf.write(path)
2030
2010
_see_also = ['status', 'ls']
2033
help='Write an ascii NUL (\\0) separator '
2034
'between files rather than a newline.')
2011
takes_options = ['directory', 'null']
2037
2013
@display_command
2038
def run(self, null=False):
2039
tree = WorkingTree.open_containing(u'.')[0]
2014
def run(self, null=False, directory=u'.'):
2015
tree = WorkingTree.open_containing(directory)[0]
2040
2016
td = tree.changes_from(tree.basis_tree())
2041
2017
for path, id, kind, text_modified, meta_modified in td.modified:
2053
2029
_see_also = ['status', 'ls']
2056
help='Write an ascii NUL (\\0) separator '
2057
'between files rather than a newline.')
2030
takes_options = ['directory', 'null']
2060
2032
@display_command
2061
def run(self, null=False):
2062
wt = WorkingTree.open_containing(u'.')[0]
2064
self.add_cleanup(wt.unlock)
2033
def run(self, null=False, directory=u'.'):
2034
wt = WorkingTree.open_containing(directory)[0]
2035
self.add_cleanup(wt.lock_read().unlock)
2065
2036
basis = wt.basis_tree()
2067
self.add_cleanup(basis.unlock)
2037
self.add_cleanup(basis.lock_read().unlock)
2068
2038
basis_inv = basis.inventory
2069
2039
inv = wt.inventory
2070
2040
for file_id in inv:
2073
2043
if inv.is_root(file_id) and len(basis_inv) == 0:
2075
2045
path = inv.id2path(file_id)
2076
if not os.access(osutils.abspath(path), os.F_OK):
2046
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2079
2049
self.outf.write(path + '\0')
2279
2249
help='Show just the specified revision.'
2280
2250
' See also "help revisionspec".'),
2252
RegistryOption('authors',
2253
'What names to list as authors - first, all or committer.',
2255
lazy_registry=('bzrlib.log', 'author_list_registry'),
2282
2257
Option('levels',
2283
2258
short_name='n',
2284
2259
help='Number of levels to display - 0 for all, 1 for flat.',
2353
2329
# find the file ids to log and check for directory filtering
2354
2330
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2355
revision, file_list)
2356
self.add_cleanup(b.unlock)
2331
revision, file_list, self.add_cleanup)
2357
2332
for relpath, file_id, kind in file_info_list:
2358
2333
if file_id is None:
2359
2334
raise errors.BzrCommandError(
2378
2353
dir, relpath = bzrdir.BzrDir.open_containing(location)
2379
2354
b = dir.open_branch()
2381
self.add_cleanup(b.unlock)
2355
self.add_cleanup(b.lock_read().unlock)
2382
2356
rev1, rev2 = _get_revision_range(revision, b, self.name())
2384
2358
# Decide on the type of delta & diff filtering to use
2404
2378
show_timezone=timezone,
2405
2379
delta_format=get_verbosity_level(),
2407
show_advice=levels is None)
2381
show_advice=levels is None,
2382
author_list_handler=authors)
2409
2384
# Choose the algorithm for doing the logging. It's annoying
2410
2385
# having multiple code paths like this but necessary until
2508
2483
tree, relpath = WorkingTree.open_containing(filename)
2509
2484
file_id = tree.path2id(relpath)
2510
2485
b = tree.branch
2512
self.add_cleanup(b.unlock)
2486
self.add_cleanup(b.lock_read().unlock)
2513
2487
touching_revs = log.find_touching_revisions(b, file_id)
2514
2488
for revno, revision_id, what in touching_revs:
2515
2489
self.outf.write("%6d %s\n" % (revno, what))
2528
2502
help='Recurse into subdirectories.'),
2529
2503
Option('from-root',
2530
2504
help='Print paths relative to the root of the branch.'),
2531
Option('unknown', help='Print unknown files.'),
2505
Option('unknown', short_name='u',
2506
help='Print unknown files.'),
2532
2507
Option('versioned', help='Print versioned files.',
2533
2508
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.'),
2509
Option('ignored', short_name='i',
2510
help='Print ignored files.'),
2511
Option('kind', short_name='k',
2539
2512
help='List entries of a particular kind: file, directory, symlink.',
2543
2518
@display_command
2544
2519
def run(self, revision=None, verbose=False,
2545
2520
recursive=False, from_root=False,
2546
2521
unknown=False, versioned=False, ignored=False,
2547
null=False, kind=None, show_ids=False, path=None):
2522
null=False, kind=None, show_ids=False, path=None, directory=None):
2549
2524
if kind and kind not in ('file', 'directory', 'symlink'):
2550
2525
raise errors.BzrCommandError('invalid kind specified')
2562
2537
raise errors.BzrCommandError('cannot specify both --from-root'
2565
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2540
tree, branch, relpath = \
2541
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2568
2543
# Calculate the prefix to use
2584
2559
view_str = views.view_display_str(view_files)
2585
2560
note("Ignoring files outside view. View is %s" % view_str)
2588
self.add_cleanup(tree.unlock)
2562
self.add_cleanup(tree.lock_read().unlock)
2589
2563
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2590
2564
from_dir=relpath, recursive=recursive):
2591
2565
# Apply additional masking
2640
2614
_see_also = ['ls']
2615
takes_options = ['directory']
2642
2617
@display_command
2644
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2618
def run(self, directory=u'.'):
2619
for f in WorkingTree.open_containing(directory)[0].unknowns():
2645
2620
self.outf.write(osutils.quotefn(f) + '\n')
2713
2688
_see_also = ['status', 'ignored', 'patterns']
2714
2689
takes_args = ['name_pattern*']
2690
takes_options = ['directory',
2716
2691
Option('default-rules',
2717
2692
help='Display the default ignore rules that bzr uses.')
2720
def run(self, name_pattern_list=None, default_rules=None):
2695
def run(self, name_pattern_list=None, default_rules=None,
2721
2697
from bzrlib import ignores
2722
2698
if default_rules is not None:
2723
2699
# dump the default rules and exit
2729
2705
"NAME_PATTERN or --default-rules.")
2730
2706
name_pattern_list = [globbing.normalize_pattern(p)
2731
2707
for p in name_pattern_list]
2709
for p in name_pattern_list:
2710
if not globbing.Globster.is_pattern_valid(p):
2711
bad_patterns += ('\n %s' % p)
2713
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2714
ui.ui_factory.show_error(msg)
2715
raise errors.InvalidPattern('')
2732
2716
for name_pattern in name_pattern_list:
2733
2717
if (name_pattern[0] == '/' or
2734
2718
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2735
2719
raise errors.BzrCommandError(
2736
2720
"NAME_PATTERN should not be an absolute path")
2737
tree, relpath = WorkingTree.open_containing(u'.')
2721
tree, relpath = WorkingTree.open_containing(directory)
2738
2722
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2739
2723
ignored = globbing.Globster(name_pattern_list)
2725
self.add_cleanup(tree.lock_read().unlock)
2742
2726
for entry in tree.list_files():
2744
2728
if id is not None:
2745
2729
filename = entry[0]
2746
2730
if ignored.match(filename):
2747
2731
matches.append(filename)
2749
2732
if len(matches) > 0:
2750
2733
self.outf.write("Warning: the following files are version controlled and"
2751
2734
" match your ignore pattern:\n%s"
2767
2750
encoding_type = 'replace'
2768
2751
_see_also = ['ignore', 'ls']
2752
takes_options = ['directory']
2770
2754
@display_command
2772
tree = WorkingTree.open_containing(u'.')[0]
2774
self.add_cleanup(tree.unlock)
2755
def run(self, directory=u'.'):
2756
tree = WorkingTree.open_containing(directory)[0]
2757
self.add_cleanup(tree.lock_read().unlock)
2775
2758
for path, file_class, kind, file_id, entry in tree.list_files():
2776
2759
if file_class != 'I':
2790
2773
takes_args = ['revno']
2774
takes_options = ['directory']
2792
2776
@display_command
2793
def run(self, revno):
2777
def run(self, revno, directory=u'.'):
2795
2779
revno = int(revno)
2796
2780
except ValueError:
2797
2781
raise errors.BzrCommandError("not a valid revision-number: %r"
2799
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2783
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2800
2784
self.outf.write("%s\n" % revid)
2829
2813
================= =========================
2831
2815
takes_args = ['dest', 'branch_or_subdir?']
2816
takes_options = ['directory',
2833
2817
Option('format',
2834
2818
help="Type of file to export to.",
2844
2828
'revision in which it was changed.'),
2846
2830
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2847
root=None, filters=False, per_file_timestamps=False):
2831
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2848
2832
from bzrlib.export import export
2850
2834
if branch_or_subdir is None:
2851
tree = WorkingTree.open_containing(u'.')[0]
2835
tree = WorkingTree.open_containing(directory)[0]
2852
2836
b = tree.branch
2875
2859
_see_also = ['ls']
2860
takes_options = ['directory',
2877
2861
Option('name-from-revision', help='The path name in the old tree.'),
2878
2862
Option('filters', help='Apply content filters to display the '
2879
2863
'convenience form.'),
2885
2869
@display_command
2886
2870
def run(self, filename, revision=None, name_from_revision=False,
2871
filters=False, directory=None):
2888
2872
if revision is not None and len(revision) != 1:
2889
2873
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2890
2874
" one revision specifier")
2891
2875
tree, branch, relpath = \
2892
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2894
self.add_cleanup(branch.unlock)
2876
_open_directory_or_containing_tree_or_branch(filename, directory)
2877
self.add_cleanup(branch.lock_read().unlock)
2895
2878
return self._run(tree, branch, relpath, filename, revision,
2896
2879
name_from_revision, filters)
2900
2883
if tree is None:
2901
2884
tree = b.basis_tree()
2902
2885
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2903
rev_tree.lock_read()
2904
self.add_cleanup(rev_tree.unlock)
2886
self.add_cleanup(rev_tree.lock_read().unlock)
2906
2888
old_file_id = rev_tree.path2id(relpath)
3129
3111
properties = {}
3131
tree, selected_list = tree_files(selected_list)
3113
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3132
3114
if selected_list == ['']:
3133
3115
# workaround - commit of root of tree should be exactly the same
3134
3116
# as just default commit in that tree, and succeed even though
3169
3151
def get_message(commit_obj):
3170
3152
"""Callback to get commit message"""
3172
my_message = codecs.open(
3173
file, 'rt', osutils.get_user_encoding()).read()
3156
my_message = f.read().decode(osutils.get_user_encoding())
3174
3159
elif message is not None:
3175
3160
my_message = message
3205
3190
reporter=None, verbose=verbose, revprops=properties,
3206
3191
authors=author, timestamp=commit_stamp,
3207
3192
timezone=offset,
3208
exclude=safe_relpath_files(tree, exclude))
3193
exclude=tree.safe_relpath_files(exclude))
3209
3194
except PointlessCommit:
3210
3195
raise errors.BzrCommandError("No changes to commit."
3211
3196
" Use --unchanged to commit anyhow.")
3331
3316
bzr whoami "Frank Chu <fchu@example.com>"
3333
takes_options = [ Option('email',
3318
takes_options = [ 'directory',
3334
3320
help='Display email address only.'),
3335
3321
Option('branch',
3336
3322
help='Set identity for the current branch instead of '
3340
3326
encoding_type = 'replace'
3342
3328
@display_command
3343
def run(self, email=False, branch=False, name=None):
3329
def run(self, email=False, branch=False, name=None, directory=None):
3344
3330
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()
3331
if directory is None:
3332
# use branch if we're inside one; otherwise global config
3334
c = Branch.open_containing(u'.')[0].get_config()
3335
except errors.NotBranchError:
3336
c = _mod_config.GlobalConfig()
3338
c = Branch.open(directory).get_config()
3351
3340
self.outf.write(c.user_email() + '\n')
3356
3345
# display a warning if an email address isn't included in the given name.
3358
config.extract_email_address(name)
3347
_mod_config.extract_email_address(name)
3359
3348
except errors.NoEmailInUsername, e:
3360
3349
warning('"%s" does not seem to contain an email address. '
3361
3350
'This is allowed, but not recommended.', name)
3363
3352
# use global config unless --branch given
3365
c = Branch.open_containing('.')[0].get_config()
3354
if directory is None:
3355
c = Branch.open_containing(u'.')[0].get_config()
3357
c = Branch.open(directory).get_config()
3367
c = config.GlobalConfig()
3359
c = _mod_config.GlobalConfig()
3368
3360
c.set_user_option('email', name)
3381
3373
_see_also = ['info']
3382
3374
takes_args = ['nickname?']
3383
def run(self, nickname=None):
3384
branch = Branch.open_containing(u'.')[0]
3375
takes_options = ['directory']
3376
def run(self, nickname=None, directory=u'.'):
3377
branch = Branch.open_containing(directory)[0]
3385
3378
if nickname is None:
3386
3379
self.printme(branch)
3436
3429
'bzr alias --remove expects an alias to remove.')
3437
3430
# If alias is not found, print something like:
3438
3431
# unalias: foo: not found
3439
c = config.GlobalConfig()
3432
c = _mod_config.GlobalConfig()
3440
3433
c.unset_alias(alias_name)
3442
3435
@display_command
3443
3436
def print_aliases(self):
3444
3437
"""Print out the defined aliases in a similar format to bash."""
3445
aliases = config.GlobalConfig().get_aliases()
3438
aliases = _mod_config.GlobalConfig().get_aliases()
3446
3439
for key, value in sorted(aliases.iteritems()):
3447
3440
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3459
3452
def set_alias(self, alias_name, alias_command):
3460
3453
"""Save the alias in the global config."""
3461
c = config.GlobalConfig()
3454
c = _mod_config.GlobalConfig()
3462
3455
c.set_alias(alias_name, alias_command)
3499
3492
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3500
3493
into a pdb postmortem session.
3495
The --coverage=DIRNAME global option produces a report with covered code
3503
3499
Run only tests relating to 'ignore'::
3537
3533
'throughout the test suite.',
3538
3534
type=get_transport_type),
3539
3535
Option('benchmark',
3540
help='Run the benchmarks rather than selftests.'),
3536
help='Run the benchmarks rather than selftests.',
3541
3538
Option('lsprof-timed',
3542
3539
help='Generate lsprof output for benchmarked'
3543
3540
' sections of code.'),
3544
3541
Option('lsprof-tests',
3545
3542
help='Generate lsprof output for each test.'),
3546
Option('cache-dir', type=str,
3547
help='Cache intermediate benchmark output in this '
3549
3543
Option('first',
3550
3544
help='Run all tests, but run specified tests first.',
3551
3545
short_name='f',
3586
3580
def run(self, testspecs_list=None, verbose=False, one=False,
3587
3581
transport=None, benchmark=None,
3588
lsprof_timed=None, cache_dir=None,
3589
3583
first=False, list_only=False,
3590
3584
randomize=None, exclude=None, strict=False,
3591
3585
load_list=None, debugflag=None, starting_with=None, subunit=False,
3592
3586
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)
3587
from bzrlib import tests
3602
3589
if testspecs_list is not None:
3603
3590
pattern = '|'.join(testspecs_list)
3612
3599
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3613
3600
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3614
3601
# stdout, which would corrupt the subunit stream.
3615
if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3602
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3603
# following code can be deleted when it's sufficiently deployed
3604
# -- vila/mgz 20100514
3605
if (sys.platform == "win32"
3606
and getattr(sys.stdout, 'fileno', None) is not None):
3617
3608
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3619
3610
self.additional_selftest_args.setdefault(
3620
3611
'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
3613
raise errors.BzrCommandError(
3614
"--benchmark is no longer supported from bzr 2.2; "
3615
"use bzr-usertest instead")
3616
test_suite_factory = None
3631
3617
selftest_kwargs = {"verbose": verbose,
3632
3618
"pattern": pattern,
3633
3619
"stop_on_failure": one,
3635
3621
"test_suite_factory": test_suite_factory,
3636
3622
"lsprof_timed": lsprof_timed,
3637
3623
"lsprof_tests": lsprof_tests,
3638
"bench_history": benchfile,
3639
3624
"matching_tests_first": first,
3640
3625
"list_only": list_only,
3641
3626
"random_seed": randomize,
3646
3631
"starting_with": starting_with
3648
3633
selftest_kwargs.update(self.additional_selftest_args)
3649
result = selftest(**selftest_kwargs)
3635
# Make deprecation warnings visible, unless -Werror is set
3636
cleanup = symbol_versioning.activate_deprecation_warnings(
3639
result = tests.selftest(**selftest_kwargs)
3650
3642
return int(not result)
3691
3683
branch1 = Branch.open_containing(branch)[0]
3692
3684
branch2 = Branch.open_containing(other)[0]
3694
self.add_cleanup(branch1.unlock)
3696
self.add_cleanup(branch2.unlock)
3685
self.add_cleanup(branch1.lock_read().unlock)
3686
self.add_cleanup(branch2.lock_read().unlock)
3697
3687
last1 = ensure_null(branch1.last_revision())
3698
3688
last2 = ensure_null(branch2.last_revision())
3793
3783
' completely merged into the source, pull from the'
3794
3784
' source rather than merging. When this happens,'
3795
3785
' you do not need to commit the result.'),
3786
custom_help('directory',
3797
3787
help='Branch to merge into, '
3798
'rather than the one containing the working directory.',
3788
'rather than the one containing the working directory.'),
3802
3789
Option('preview', help='Instead of merging, show a diff of the'
3804
3791
Option('interactive', help='Select changes interactively.',
3837
3824
unversioned_filter=tree.is_ignored, view_info=view_info)
3838
3825
pb = ui.ui_factory.nested_progress_bar()
3839
3826
self.add_cleanup(pb.finished)
3841
self.add_cleanup(tree.unlock)
3827
self.add_cleanup(tree.lock_write().unlock)
3842
3828
if location is not None:
3844
3830
mergeable = bundle.read_mergeable_from_url(location,
3905
3891
def _do_preview(self, merger):
3906
3892
from bzrlib.diff import show_diff_trees
3907
3893
result_tree = self._get_preview(merger)
3894
path_encoding = osutils.get_diff_header_encoding()
3908
3895
show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
old_label='', new_label='')
3896
old_label='', new_label='',
3897
path_encoding=path_encoding)
3911
3899
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
3900
merger.change_reporter = change_reporter
4099
4087
from bzrlib.conflicts import restore
4100
4088
if merge_type is None:
4101
4089
merge_type = _mod_merge.Merge3Merger
4102
tree, file_list = tree_files(file_list)
4104
self.add_cleanup(tree.unlock)
4090
tree, file_list = WorkingTree.open_containing_paths(file_list)
4091
self.add_cleanup(tree.lock_write().unlock)
4105
4092
parents = tree.get_parent_ids()
4106
4093
if len(parents) != 2:
4107
4094
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4217
4204
def run(self, revision=None, no_backup=False, file_list=None,
4218
4205
forget_merges=None):
4219
tree, file_list = tree_files(file_list)
4220
tree.lock_tree_write()
4221
self.add_cleanup(tree.unlock)
4206
tree, file_list = WorkingTree.open_containing_paths(file_list)
4207
self.add_cleanup(tree.lock_tree_write().unlock)
4222
4208
if forget_merges:
4223
4209
tree.set_parent_ids(tree.get_parent_ids()[:1])
4313
4299
_see_also = ['merge', 'pull']
4314
4300
takes_args = ['other_branch?']
4315
4301
takes_options = [
4316
4303
Option('reverse', 'Reverse the order of revisions.'),
4317
4304
Option('mine-only',
4318
4305
'Display changes in the local branch only.'),
4340
4327
theirs_only=False,
4341
4328
log_format=None, long=False, short=False, line=False,
4342
4329
show_ids=False, verbose=False, this=False, other=False,
4343
include_merges=False, revision=None, my_revision=None):
4330
include_merges=False, revision=None, my_revision=None,
4344
4332
from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4333
def message(s):
4346
4334
if not is_quiet():
4359
4347
elif theirs_only:
4360
4348
restrict = 'remote'
4362
local_branch = Branch.open_containing(u".")[0]
4363
local_branch.lock_read()
4364
self.add_cleanup(local_branch.unlock)
4350
local_branch = Branch.open_containing(directory)[0]
4351
self.add_cleanup(local_branch.lock_read().unlock)
4366
4353
parent = local_branch.get_parent()
4367
4354
if other_branch is None:
4378
4365
if remote_branch.base == local_branch.base:
4379
4366
remote_branch = local_branch
4381
remote_branch.lock_read()
4382
self.add_cleanup(remote_branch.unlock)
4368
self.add_cleanup(remote_branch.lock_read().unlock)
4384
4370
local_revid_range = _revision_range_to_revid_range(
4385
4371
_get_revision_range(my_revision, local_branch,
4440
4426
message("Branches are up to date.\n")
4441
4427
self.cleanup_now()
4442
4428
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)
4429
self.add_cleanup(local_branch.lock_write().unlock)
4445
4430
# handle race conditions - a parent might be set while we run.
4446
4431
if local_branch.get_parent() is None:
4447
4432
local_branch.set_parent(remote_branch.base)
4578
4562
Option('long', help='Show commit date in annotations.'),
4582
4567
encoding_type = 'exact'
4584
4569
@display_command
4585
4570
def run(self, filename, all=False, long=False, revision=None,
4571
show_ids=False, directory=None):
4587
4572
from bzrlib.annotate import annotate_file, annotate_file_tree
4588
4573
wt, branch, relpath = \
4589
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4574
_open_directory_or_containing_tree_or_branch(filename, directory)
4590
4575
if wt is not None:
4592
self.add_cleanup(wt.unlock)
4576
self.add_cleanup(wt.lock_read().unlock)
4595
self.add_cleanup(branch.unlock)
4578
self.add_cleanup(branch.lock_read().unlock)
4596
4579
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4598
self.add_cleanup(tree.unlock)
4580
self.add_cleanup(tree.lock_read().unlock)
4599
4581
if wt is not None:
4600
4582
file_id = wt.path2id(relpath)
4620
4602
hidden = True # is this right ?
4621
4603
takes_args = ['revision_id*']
4622
takes_options = ['revision']
4604
takes_options = ['directory', 'revision']
4624
def run(self, revision_id_list=None, revision=None):
4606
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4607
if revision_id_list is not None and revision is not None:
4626
4608
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4609
if revision_id_list is None and revision is None:
4628
4610
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)
4611
b = WorkingTree.open_containing(directory)[0].branch
4612
self.add_cleanup(b.lock_write().unlock)
4632
4613
return self._run(b, revision_id_list, revision)
4634
4615
def _run(self, b, revision_id_list, revision):
4694
4675
_see_also = ['checkouts', 'unbind']
4695
4676
takes_args = ['location?']
4677
takes_options = ['directory']
4698
def run(self, location=None):
4699
b, relpath = Branch.open_containing(u'.')
4679
def run(self, location=None, directory=u'.'):
4680
b, relpath = Branch.open_containing(directory)
4700
4681
if location is None:
4702
4683
location = b.get_old_bound_location()
4730
4711
_see_also = ['checkouts', 'bind']
4731
4712
takes_args = []
4713
takes_options = ['directory']
4735
b, relpath = Branch.open_containing(u'.')
4715
def run(self, directory=u'.'):
4716
b, relpath = Branch.open_containing(directory)
4736
4717
if not b.unbind():
4737
4718
raise errors.BzrCommandError('Local branch is not bound')
4784
4765
b = control.open_branch()
4786
4767
if tree is not None:
4788
self.add_cleanup(tree.unlock)
4768
self.add_cleanup(tree.lock_write().unlock)
4791
self.add_cleanup(b.unlock)
4770
self.add_cleanup(b.lock_write().unlock)
4792
4771
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4794
4773
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4833
4812
self.outf.write('The above revision(s) will be removed.\n')
4836
if not ui.ui_factory.get_boolean('Are you sure'):
4837
self.outf.write('Canceled')
4815
if not ui.ui_factory.confirm_action(
4816
'Uncommit these revisions',
4817
'bzrlib.builtins.uncommit',
4819
self.outf.write('Canceled\n')
4840
4822
mutter('Uncommitting from {%s} to {%s}',
4848
4830
class cmd_break_lock(Command):
4849
__doc__ = """Break a dead lock on a repository, branch or working directory.
4831
__doc__ = """Break a dead lock.
4833
This command breaks a lock on a repository, branch, working directory or
4851
4836
CAUTION: Locks should only be broken when you are sure that the process
4852
4837
holding the lock has been stopped.
4859
4844
bzr break-lock bzr+ssh://example.com/bzr/foo
4845
bzr break-lock --conf ~/.bazaar
4861
4848
takes_args = ['location?']
4851
help='LOCATION is the directory where the config lock is.'),
4863
def run(self, location=None, show=False):
4854
def run(self, location=None, config=False):
4864
4855
if location is None:
4865
4856
location = u'.'
4866
control, relpath = bzrdir.BzrDir.open_containing(location)
4868
control.break_lock()
4869
except NotImplementedError:
4858
conf = _mod_config.LockableConfig(file_name=location)
4861
control, relpath = bzrdir.BzrDir.open_containing(location)
4863
control.break_lock()
4864
except NotImplementedError:
4873
4868
class cmd_wait_until_signalled(Command):
4902
4897
'result in a dynamically allocated port. The default port '
4903
4898
'depends on the protocol.',
4906
help='Serve contents of this directory.',
4900
custom_help('directory',
4901
help='Serve contents of this directory.'),
4908
4902
Option('allow-writes',
4909
4903
help='By default the server is a readonly server. Supplying '
4910
4904
'--allow-writes enables write access to the contents of '
4938
4932
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
4933
protocol=None):
4940
from bzrlib.transport import get_transport, transport_server_registry
4934
from bzrlib import transport
4941
4935
if directory is None:
4942
4936
directory = os.getcwd()
4943
4937
if protocol is None:
4944
protocol = transport_server_registry.get()
4938
protocol = transport.transport_server_registry.get()
4945
4939
host, port = self.get_host_and_port(port)
4946
4940
url = urlutils.local_path_to_url(directory)
4947
4941
if not allow_writes:
4948
4942
url = 'readonly+' + url
4949
transport = get_transport(url)
4950
protocol(transport, host, port, inet)
4943
t = transport.get_transport(url)
4944
protocol(t, host, port, inet)
4953
4947
class cmd_join(Command):
5064
5059
encoding_type = 'exact'
5066
5061
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
sign=False, revision=None, mail_to=None, message=None):
5062
sign=False, revision=None, mail_to=None, message=None,
5068
5064
from bzrlib.revision import ensure_null, NULL_REVISION
5069
5065
include_patch, include_bundle = {
5070
5066
'plain': (False, False),
5071
5067
'diff': (True, False),
5072
5068
'bundle': (True, True),
5074
branch = Branch.open('.')
5070
branch = Branch.open(directory)
5075
5071
stored_submit_branch = branch.get_submit_branch()
5076
5072
if submit_branch is None:
5077
5073
submit_branch = stored_submit_branch
5162
5158
given, in which case it is sent to a file.
5164
5160
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.
5161
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5166
5162
If the preferred client can't be found (or used), your editor will be used.
5168
5164
To use a specific mail program, set the mail_client configuration option.
5339
5335
Option('delete',
5340
5336
help='Delete this tag rather than placing it.',
5343
help='Branch in which to place the tag.',
5338
custom_help('directory',
5339
help='Branch in which to place the tag.'),
5347
5340
Option('force',
5348
5341
help='Replace existing tags.',
5359
5352
branch, relpath = Branch.open_containing(directory)
5361
self.add_cleanup(branch.unlock)
5353
self.add_cleanup(branch.lock_write().unlock)
5363
5355
if tag_name is None:
5364
5356
raise errors.BzrCommandError("No tag specified to delete.")
5393
5385
_see_also = ['tag']
5394
5386
takes_options = [
5396
help='Branch whose tags should be displayed.',
5387
custom_help('directory',
5388
help='Branch whose tags should be displayed.'),
5400
5389
RegistryOption.from_kwargs('sort',
5401
5390
'Sort tags by different criteria.', title='Sorting',
5402
5391
alpha='Sort tags lexicographically (default).',
5423
self.add_cleanup(branch.unlock)
5411
self.add_cleanup(branch.lock_read().unlock)
5425
5413
graph = branch.repository.get_graph()
5426
5414
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5575
5563
takes_args = ['to_location?']
5576
takes_options = [Option('force',
5564
takes_options = ['directory',
5577
5566
help='Switch even if local commits will be lost.'),
5579
5568
Option('create-branch', short_name='b',
5584
5573
def run(self, to_location=None, force=False, create_branch=False,
5574
revision=None, directory=u'.'):
5586
5575
from bzrlib import switch
5576
tree_location = directory
5588
5577
revision = _get_one_revision('switch', revision)
5589
5578
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5579
if to_location is None:
5591
5580
if revision is None:
5592
5581
raise errors.BzrCommandError('You must supply either a'
5593
5582
' revision or a location')
5583
to_location = tree_location
5596
5585
branch = control_dir.open_branch()
5597
5586
had_explicit_nick = branch.get_config().has_explicit_nickname()
5735
tree, file_list = tree_files(file_list, apply_view=False)
5724
tree, file_list = WorkingTree.open_containing_paths(file_list,
5736
5726
current_view, view_dict = tree.views.get_view_info()
5737
5727
if name is None:
5738
5728
name = current_view
5886
5877
_see_also = ['unshelve']
5888
5879
def run(self, revision=None, all=False, file_list=None, message=None,
5889
writer=None, list=False, destroy=False):
5880
writer=None, list=False, destroy=False, directory=u'.'):
5891
5882
return self.run_for_list()
5892
5883
from bzrlib.shelf_ui import Shelver
5894
5885
writer = bzrlib.option.diff_writer_registry.get()
5896
5887
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
file_list, message, destroy=destroy)
5888
file_list, message, destroy=destroy, directory=directory)
5905
5896
def run_for_list(self):
5906
5897
tree = WorkingTree.open_containing('.')[0]
5908
self.add_cleanup(tree.unlock)
5898
self.add_cleanup(tree.lock_read().unlock)
5909
5899
manager = tree.get_shelf_manager()
5910
5900
shelves = manager.active_shelves()
5911
5901
if len(shelves) == 0:
5930
5920
takes_args = ['shelf_id?']
5931
5921
takes_options = [
5932
5923
RegistryOption.from_kwargs(
5933
5924
'action', help="The action to perform.",
5934
5925
enum_switch=False, value_switches=True,
5943
5934
_see_also = ['shelve']
5945
def run(self, shelf_id=None, action='apply'):
5936
def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
5937
from bzrlib.shelf_ui import Unshelver
5947
unshelver = Unshelver.from_args(shelf_id, action)
5938
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5949
5940
unshelver.run()
5967
5958
To check what clean-tree will do, use --dry-run.
5969
takes_options = [Option('ignored', help='Delete all ignored files.'),
5960
takes_options = ['directory',
5961
Option('ignored', help='Delete all ignored files.'),
5970
5962
Option('detritus', help='Delete conflict files, merge'
5971
5963
' backups, and failed selftest dirs.'),
5972
5964
Option('unknown',
5975
5967
' deleting them.'),
5976
5968
Option('force', help='Do not prompt before deleting.')]
5977
5969
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5970
force=False, directory=u'.'):
5979
5971
from bzrlib.clean_tree import clean_tree
5980
5972
if not (unknown or ignored or detritus):
5984
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
dry_run=dry_run, no_prompt=force)
5976
clean_tree(directory, unknown=unknown, ignored=ignored,
5977
detritus=detritus, dry_run=dry_run, no_prompt=force)
5988
5980
class cmd_reference(Command):
added
removed
bzrlib/builtins.py
