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)
1396
1361
If you want to discard your local changes, you can just do a
1397
1362
'bzr revert' instead of 'bzr commit' after the update.
1364
If you want to restore a file that has been removed locally, use
1365
'bzr revert' instead of 'bzr update'.
1399
1367
If the tree's branch is bound to a master branch, it will also update
1400
1368
the branch from the master.
1403
1371
_see_also = ['pull', 'working-trees', 'status-flags']
1404
1372
takes_args = ['dir?']
1405
takes_options = ['revision']
1373
takes_options = ['revision',
1375
help="Show base revision text in conflicts."),
1406
1377
aliases = ['up']
1408
def run(self, dir='.', revision=None):
1379
def run(self, dir='.', revision=None, show_base=None):
1409
1380
if revision is not None and len(revision) != 1:
1410
1381
raise errors.BzrCommandError(
1411
1382
"bzr update --revision takes exactly one revision")
1415
1386
master = branch.get_master_branch(
1416
1387
possible_transports=possible_transports)
1417
1388
if master is not None:
1419
1389
branch_location = master.base
1392
branch_location = tree.branch.base
1421
1393
tree.lock_tree_write()
1422
branch_location = tree.branch.base
1423
1394
self.add_cleanup(tree.unlock)
1424
1395
# get rid of the final '/' and be ready for display
1425
1396
branch_location = urlutils.unescape_for_display(
1451
1422
change_reporter,
1452
1423
possible_transports=possible_transports,
1453
1424
revision=revision_id,
1426
show_base=show_base)
1455
1427
except errors.NoSuchRevision, e:
1456
1428
raise errors.BzrCommandError(
1457
1429
"branch has no revision %s\n"
1519
1491
class cmd_remove(Command):
1520
1492
__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.
1494
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1495
delete them if they can easily be recovered using revert otherwise they
1496
will be backed up (adding an extention of the form .~#~). If no options or
1497
parameters are given Bazaar will scan for files that are being tracked by
1498
Bazaar but missing in your tree and stop tracking them for you.
1527
1500
takes_args = ['file*']
1528
1501
takes_options = ['verbose',
1530
1503
RegistryOption.from_kwargs('file-deletion-strategy',
1531
1504
'The file deletion mode to be used.',
1532
1505
title='Deletion Strategy', value_switches=True, enum_switch=False,
1533
safe='Only delete files if they can be'
1534
' safely recovered (default).',
1506
safe='Backup changed files (default).',
1535
1507
keep='Delete from bzr but leave the working copy.',
1536
1508
force='Delete all the specified files, even if they can not be '
1537
1509
'recovered and even if they are non-empty directories.')]
1541
1513
def run(self, file_list, verbose=False, new=False,
1542
1514
file_deletion_strategy='safe'):
1543
tree, file_list = tree_files(file_list)
1515
tree, file_list = WorkingTree.open_containing_paths(file_list)
1545
1517
if file_list is not None:
1546
1518
file_list = [f for f in file_list]
1549
self.add_cleanup(tree.unlock)
1520
self.add_cleanup(tree.lock_write().unlock)
1550
1521
# Heuristics should probably all move into tree.remove_smart or
1636
1607
_see_also = ['check']
1637
1608
takes_args = ['branch?']
1610
Option('canonicalize-chks',
1611
help='Make sure CHKs are in canonical form (repairs '
1639
def run(self, branch="."):
1616
def run(self, branch=".", canonicalize_chks=False):
1640
1617
from bzrlib.reconcile import reconcile
1641
1618
dir = bzrdir.BzrDir.open(branch)
1619
reconcile(dir, canonicalize_chks=canonicalize_chks)
1645
1622
class cmd_revision_history(Command):
1985
1966
old_branch, new_branch,
1986
1967
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1987
1968
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1969
# GNU diff on Windows uses ANSI encoding for filenames
1970
path_encoding = osutils.get_diff_header_encoding()
1988
1971
return show_diff_trees(old_tree, new_tree, sys.stdout,
1989
1972
specific_files=specific_files,
1990
1973
external_diff_options=diff_options,
1991
1974
old_label=old_label, new_label=new_label,
1992
extra_trees=extra_trees, using=using,
1975
extra_trees=extra_trees,
1976
path_encoding=path_encoding,
1993
1978
format_cls=format)
2003
1988
# level of effort but possibly much less IO. (Or possibly not,
2004
1989
# if the directories are very large...)
2005
1990
_see_also = ['status', 'ls']
2006
takes_options = ['show-ids']
1991
takes_options = ['directory', 'show-ids']
2008
1993
@display_command
2009
def run(self, show_ids=False):
2010
tree = WorkingTree.open_containing(u'.')[0]
2012
self.add_cleanup(tree.unlock)
1994
def run(self, show_ids=False, directory=u'.'):
1995
tree = WorkingTree.open_containing(directory)[0]
1996
self.add_cleanup(tree.lock_read().unlock)
2013
1997
old = tree.basis_tree()
2015
self.add_cleanup(old.unlock)
1998
self.add_cleanup(old.lock_read().unlock)
2016
1999
for path, ie in old.inventory.iter_entries():
2017
2000
if not tree.has_id(ie.file_id):
2018
2001
self.outf.write(path)
2030
2013
_see_also = ['status', 'ls']
2033
help='Write an ascii NUL (\\0) separator '
2034
'between files rather than a newline.')
2014
takes_options = ['directory', 'null']
2037
2016
@display_command
2038
def run(self, null=False):
2039
tree = WorkingTree.open_containing(u'.')[0]
2017
def run(self, null=False, directory=u'.'):
2018
tree = WorkingTree.open_containing(directory)[0]
2040
2019
td = tree.changes_from(tree.basis_tree())
2041
2020
for path, id, kind, text_modified, meta_modified in td.modified:
2053
2032
_see_also = ['status', 'ls']
2056
help='Write an ascii NUL (\\0) separator '
2057
'between files rather than a newline.')
2033
takes_options = ['directory', 'null']
2060
2035
@display_command
2061
def run(self, null=False):
2062
wt = WorkingTree.open_containing(u'.')[0]
2064
self.add_cleanup(wt.unlock)
2036
def run(self, null=False, directory=u'.'):
2037
wt = WorkingTree.open_containing(directory)[0]
2038
self.add_cleanup(wt.lock_read().unlock)
2065
2039
basis = wt.basis_tree()
2067
self.add_cleanup(basis.unlock)
2040
self.add_cleanup(basis.lock_read().unlock)
2068
2041
basis_inv = basis.inventory
2069
2042
inv = wt.inventory
2070
2043
for file_id in inv:
2073
2046
if inv.is_root(file_id) and len(basis_inv) == 0:
2075
2048
path = inv.id2path(file_id)
2076
if not os.access(osutils.abspath(path), os.F_OK):
2049
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2079
2052
self.outf.write(path + '\0')
2279
2252
help='Show just the specified revision.'
2280
2253
' See also "help revisionspec".'),
2255
RegistryOption('authors',
2256
'What names to list as authors - first, all or committer.',
2258
lazy_registry=('bzrlib.log', 'author_list_registry'),
2282
2260
Option('levels',
2283
2261
short_name='n',
2284
2262
help='Number of levels to display - 0 for all, 1 for flat.',
2353
2332
# find the file ids to log and check for directory filtering
2354
2333
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2355
revision, file_list)
2356
self.add_cleanup(b.unlock)
2334
revision, file_list, self.add_cleanup)
2357
2335
for relpath, file_id, kind in file_info_list:
2358
2336
if file_id is None:
2359
2337
raise errors.BzrCommandError(
2378
2356
dir, relpath = bzrdir.BzrDir.open_containing(location)
2379
2357
b = dir.open_branch()
2381
self.add_cleanup(b.unlock)
2358
self.add_cleanup(b.lock_read().unlock)
2382
2359
rev1, rev2 = _get_revision_range(revision, b, self.name())
2384
2361
# Decide on the type of delta & diff filtering to use
2404
2381
show_timezone=timezone,
2405
2382
delta_format=get_verbosity_level(),
2407
show_advice=levels is None)
2384
show_advice=levels is None,
2385
author_list_handler=authors)
2409
2387
# Choose the algorithm for doing the logging. It's annoying
2410
2388
# having multiple code paths like this but necessary until
2508
2486
tree, relpath = WorkingTree.open_containing(filename)
2509
2487
file_id = tree.path2id(relpath)
2510
2488
b = tree.branch
2512
self.add_cleanup(b.unlock)
2489
self.add_cleanup(b.lock_read().unlock)
2513
2490
touching_revs = log.find_touching_revisions(b, file_id)
2514
2491
for revno, revision_id, what in touching_revs:
2515
2492
self.outf.write("%6d %s\n" % (revno, what))
2528
2505
help='Recurse into subdirectories.'),
2529
2506
Option('from-root',
2530
2507
help='Print paths relative to the root of the branch.'),
2531
Option('unknown', help='Print unknown files.'),
2508
Option('unknown', short_name='u',
2509
help='Print unknown files.'),
2532
2510
Option('versioned', help='Print versioned files.',
2533
2511
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.'),
2512
Option('ignored', short_name='i',
2513
help='Print ignored files.'),
2514
Option('kind', short_name='k',
2539
2515
help='List entries of a particular kind: file, directory, symlink.',
2543
2521
@display_command
2544
2522
def run(self, revision=None, verbose=False,
2545
2523
recursive=False, from_root=False,
2546
2524
unknown=False, versioned=False, ignored=False,
2547
null=False, kind=None, show_ids=False, path=None):
2525
null=False, kind=None, show_ids=False, path=None, directory=None):
2549
2527
if kind and kind not in ('file', 'directory', 'symlink'):
2550
2528
raise errors.BzrCommandError('invalid kind specified')
2562
2540
raise errors.BzrCommandError('cannot specify both --from-root'
2565
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2543
tree, branch, relpath = \
2544
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2568
2546
# Calculate the prefix to use
2584
2562
view_str = views.view_display_str(view_files)
2585
2563
note("Ignoring files outside view. View is %s" % view_str)
2588
self.add_cleanup(tree.unlock)
2565
self.add_cleanup(tree.lock_read().unlock)
2589
2566
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2590
2567
from_dir=relpath, recursive=recursive):
2591
2568
# Apply additional masking
2640
2617
_see_also = ['ls']
2618
takes_options = ['directory']
2642
2620
@display_command
2644
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2621
def run(self, directory=u'.'):
2622
for f in WorkingTree.open_containing(directory)[0].unknowns():
2645
2623
self.outf.write(osutils.quotefn(f) + '\n')
2713
2691
_see_also = ['status', 'ignored', 'patterns']
2714
2692
takes_args = ['name_pattern*']
2693
takes_options = ['directory',
2716
2694
Option('default-rules',
2717
2695
help='Display the default ignore rules that bzr uses.')
2720
def run(self, name_pattern_list=None, default_rules=None):
2698
def run(self, name_pattern_list=None, default_rules=None,
2721
2700
from bzrlib import ignores
2722
2701
if default_rules is not None:
2723
2702
# dump the default rules and exit
2729
2708
"NAME_PATTERN or --default-rules.")
2730
2709
name_pattern_list = [globbing.normalize_pattern(p)
2731
2710
for p in name_pattern_list]
2712
for p in name_pattern_list:
2713
if not globbing.Globster.is_pattern_valid(p):
2714
bad_patterns += ('\n %s' % p)
2716
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2717
ui.ui_factory.show_error(msg)
2718
raise errors.InvalidPattern('')
2732
2719
for name_pattern in name_pattern_list:
2733
2720
if (name_pattern[0] == '/' or
2734
2721
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2735
2722
raise errors.BzrCommandError(
2736
2723
"NAME_PATTERN should not be an absolute path")
2737
tree, relpath = WorkingTree.open_containing(u'.')
2724
tree, relpath = WorkingTree.open_containing(directory)
2738
2725
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2739
2726
ignored = globbing.Globster(name_pattern_list)
2728
self.add_cleanup(tree.lock_read().unlock)
2742
2729
for entry in tree.list_files():
2744
2731
if id is not None:
2745
2732
filename = entry[0]
2746
2733
if ignored.match(filename):
2747
2734
matches.append(filename)
2749
2735
if len(matches) > 0:
2750
2736
self.outf.write("Warning: the following files are version controlled and"
2751
2737
" match your ignore pattern:\n%s"
2767
2753
encoding_type = 'replace'
2768
2754
_see_also = ['ignore', 'ls']
2755
takes_options = ['directory']
2770
2757
@display_command
2772
tree = WorkingTree.open_containing(u'.')[0]
2774
self.add_cleanup(tree.unlock)
2758
def run(self, directory=u'.'):
2759
tree = WorkingTree.open_containing(directory)[0]
2760
self.add_cleanup(tree.lock_read().unlock)
2775
2761
for path, file_class, kind, file_id, entry in tree.list_files():
2776
2762
if file_class != 'I':
2790
2776
takes_args = ['revno']
2777
takes_options = ['directory']
2792
2779
@display_command
2793
def run(self, revno):
2780
def run(self, revno, directory=u'.'):
2795
2782
revno = int(revno)
2796
2783
except ValueError:
2797
2784
raise errors.BzrCommandError("not a valid revision-number: %r"
2799
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2786
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2800
2787
self.outf.write("%s\n" % revid)
2829
2816
================= =========================
2831
2818
takes_args = ['dest', 'branch_or_subdir?']
2819
takes_options = ['directory',
2833
2820
Option('format',
2834
2821
help="Type of file to export to.",
2844
2831
'revision in which it was changed.'),
2846
2833
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2847
root=None, filters=False, per_file_timestamps=False):
2834
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2848
2835
from bzrlib.export import export
2850
2837
if branch_or_subdir is None:
2851
tree = WorkingTree.open_containing(u'.')[0]
2838
tree = WorkingTree.open_containing(directory)[0]
2852
2839
b = tree.branch
2875
2862
_see_also = ['ls']
2863
takes_options = ['directory',
2877
2864
Option('name-from-revision', help='The path name in the old tree.'),
2878
2865
Option('filters', help='Apply content filters to display the '
2879
2866
'convenience form.'),
2885
2872
@display_command
2886
2873
def run(self, filename, revision=None, name_from_revision=False,
2874
filters=False, directory=None):
2888
2875
if revision is not None and len(revision) != 1:
2889
2876
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2890
2877
" one revision specifier")
2891
2878
tree, branch, relpath = \
2892
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2894
self.add_cleanup(branch.unlock)
2879
_open_directory_or_containing_tree_or_branch(filename, directory)
2880
self.add_cleanup(branch.lock_read().unlock)
2895
2881
return self._run(tree, branch, relpath, filename, revision,
2896
2882
name_from_revision, filters)
2900
2886
if tree is None:
2901
2887
tree = b.basis_tree()
2902
2888
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2903
rev_tree.lock_read()
2904
self.add_cleanup(rev_tree.unlock)
2889
self.add_cleanup(rev_tree.lock_read().unlock)
2906
2891
old_file_id = rev_tree.path2id(relpath)
3129
3114
properties = {}
3131
tree, selected_list = tree_files(selected_list)
3116
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3132
3117
if selected_list == ['']:
3133
3118
# workaround - commit of root of tree should be exactly the same
3134
3119
# as just default commit in that tree, and succeed even though
3169
3154
def get_message(commit_obj):
3170
3155
"""Callback to get commit message"""
3172
my_message = codecs.open(
3173
file, 'rt', osutils.get_user_encoding()).read()
3159
my_message = f.read().decode(osutils.get_user_encoding())
3174
3162
elif message is not None:
3175
3163
my_message = message
3205
3193
reporter=None, verbose=verbose, revprops=properties,
3206
3194
authors=author, timestamp=commit_stamp,
3207
3195
timezone=offset,
3208
exclude=safe_relpath_files(tree, exclude))
3196
exclude=tree.safe_relpath_files(exclude))
3209
3197
except PointlessCommit:
3210
3198
raise errors.BzrCommandError("No changes to commit."
3211
3199
" Use --unchanged to commit anyhow.")
3331
3319
bzr whoami "Frank Chu <fchu@example.com>"
3333
takes_options = [ Option('email',
3321
takes_options = [ 'directory',
3334
3323
help='Display email address only.'),
3335
3324
Option('branch',
3336
3325
help='Set identity for the current branch instead of '
3340
3329
encoding_type = 'replace'
3342
3331
@display_command
3343
def run(self, email=False, branch=False, name=None):
3332
def run(self, email=False, branch=False, name=None, directory=None):
3344
3333
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()
3334
if directory is None:
3335
# use branch if we're inside one; otherwise global config
3337
c = Branch.open_containing(u'.')[0].get_config()
3338
except errors.NotBranchError:
3339
c = _mod_config.GlobalConfig()
3341
c = Branch.open(directory).get_config()
3351
3343
self.outf.write(c.user_email() + '\n')
3356
3348
# display a warning if an email address isn't included in the given name.
3358
config.extract_email_address(name)
3350
_mod_config.extract_email_address(name)
3359
3351
except errors.NoEmailInUsername, e:
3360
3352
warning('"%s" does not seem to contain an email address. '
3361
3353
'This is allowed, but not recommended.', name)
3363
3355
# use global config unless --branch given
3365
c = Branch.open_containing('.')[0].get_config()
3357
if directory is None:
3358
c = Branch.open_containing(u'.')[0].get_config()
3360
c = Branch.open(directory).get_config()
3367
c = config.GlobalConfig()
3362
c = _mod_config.GlobalConfig()
3368
3363
c.set_user_option('email', name)
3381
3376
_see_also = ['info']
3382
3377
takes_args = ['nickname?']
3383
def run(self, nickname=None):
3384
branch = Branch.open_containing(u'.')[0]
3378
takes_options = ['directory']
3379
def run(self, nickname=None, directory=u'.'):
3380
branch = Branch.open_containing(directory)[0]
3385
3381
if nickname is None:
3386
3382
self.printme(branch)
3436
3432
'bzr alias --remove expects an alias to remove.')
3437
3433
# If alias is not found, print something like:
3438
3434
# unalias: foo: not found
3439
c = config.GlobalConfig()
3435
c = _mod_config.GlobalConfig()
3440
3436
c.unset_alias(alias_name)
3442
3438
@display_command
3443
3439
def print_aliases(self):
3444
3440
"""Print out the defined aliases in a similar format to bash."""
3445
aliases = config.GlobalConfig().get_aliases()
3441
aliases = _mod_config.GlobalConfig().get_aliases()
3446
3442
for key, value in sorted(aliases.iteritems()):
3447
3443
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3459
3455
def set_alias(self, alias_name, alias_command):
3460
3456
"""Save the alias in the global config."""
3461
c = config.GlobalConfig()
3457
c = _mod_config.GlobalConfig()
3462
3458
c.set_alias(alias_name, alias_command)
3499
3495
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3500
3496
into a pdb postmortem session.
3498
The --coverage=DIRNAME global option produces a report with covered code
3503
3502
Run only tests relating to 'ignore'::
3537
3536
'throughout the test suite.',
3538
3537
type=get_transport_type),
3539
3538
Option('benchmark',
3540
help='Run the benchmarks rather than selftests.'),
3539
help='Run the benchmarks rather than selftests.',
3541
3541
Option('lsprof-timed',
3542
3542
help='Generate lsprof output for benchmarked'
3543
3543
' sections of code.'),
3544
3544
Option('lsprof-tests',
3545
3545
help='Generate lsprof output for each test.'),
3546
Option('cache-dir', type=str,
3547
help='Cache intermediate benchmark output in this '
3549
3546
Option('first',
3550
3547
help='Run all tests, but run specified tests first.',
3551
3548
short_name='f',
3586
3583
def run(self, testspecs_list=None, verbose=False, one=False,
3587
3584
transport=None, benchmark=None,
3588
lsprof_timed=None, cache_dir=None,
3589
3586
first=False, list_only=False,
3590
3587
randomize=None, exclude=None, strict=False,
3591
3588
load_list=None, debugflag=None, starting_with=None, subunit=False,
3592
3589
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)
3590
from bzrlib import tests
3602
3592
if testspecs_list is not None:
3603
3593
pattern = '|'.join(testspecs_list)
3612
3602
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3613
3603
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3614
3604
# stdout, which would corrupt the subunit stream.
3615
if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3605
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3606
# following code can be deleted when it's sufficiently deployed
3607
# -- vila/mgz 20100514
3608
if (sys.platform == "win32"
3609
and getattr(sys.stdout, 'fileno', None) is not None):
3617
3611
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3619
3613
self.additional_selftest_args.setdefault(
3620
3614
'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
3616
raise errors.BzrCommandError(
3617
"--benchmark is no longer supported from bzr 2.2; "
3618
"use bzr-usertest instead")
3619
test_suite_factory = None
3631
3620
selftest_kwargs = {"verbose": verbose,
3632
3621
"pattern": pattern,
3633
3622
"stop_on_failure": one,
3635
3624
"test_suite_factory": test_suite_factory,
3636
3625
"lsprof_timed": lsprof_timed,
3637
3626
"lsprof_tests": lsprof_tests,
3638
"bench_history": benchfile,
3639
3627
"matching_tests_first": first,
3640
3628
"list_only": list_only,
3641
3629
"random_seed": randomize,
3646
3634
"starting_with": starting_with
3648
3636
selftest_kwargs.update(self.additional_selftest_args)
3649
result = selftest(**selftest_kwargs)
3638
# Make deprecation warnings visible, unless -Werror is set
3639
cleanup = symbol_versioning.activate_deprecation_warnings(
3642
result = tests.selftest(**selftest_kwargs)
3650
3645
return int(not result)
3691
3686
branch1 = Branch.open_containing(branch)[0]
3692
3687
branch2 = Branch.open_containing(other)[0]
3694
self.add_cleanup(branch1.unlock)
3696
self.add_cleanup(branch2.unlock)
3688
self.add_cleanup(branch1.lock_read().unlock)
3689
self.add_cleanup(branch2.lock_read().unlock)
3697
3690
last1 = ensure_null(branch1.last_revision())
3698
3691
last2 = ensure_null(branch2.last_revision())
3793
3786
' completely merged into the source, pull from the'
3794
3787
' source rather than merging. When this happens,'
3795
3788
' you do not need to commit the result.'),
3789
custom_help('directory',
3797
3790
help='Branch to merge into, '
3798
'rather than the one containing the working directory.',
3791
'rather than the one containing the working directory.'),
3802
3792
Option('preview', help='Instead of merging, show a diff of the'
3804
3794
Option('interactive', help='Select changes interactively.',
3837
3827
unversioned_filter=tree.is_ignored, view_info=view_info)
3838
3828
pb = ui.ui_factory.nested_progress_bar()
3839
3829
self.add_cleanup(pb.finished)
3841
self.add_cleanup(tree.unlock)
3830
self.add_cleanup(tree.lock_write().unlock)
3842
3831
if location is not None:
3844
3833
mergeable = bundle.read_mergeable_from_url(location,
3905
3894
def _do_preview(self, merger):
3906
3895
from bzrlib.diff import show_diff_trees
3907
3896
result_tree = self._get_preview(merger)
3897
path_encoding = osutils.get_diff_header_encoding()
3908
3898
show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
old_label='', new_label='')
3899
old_label='', new_label='',
3900
path_encoding=path_encoding)
3911
3902
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
3903
merger.change_reporter = change_reporter
4099
4090
from bzrlib.conflicts import restore
4100
4091
if merge_type is None:
4101
4092
merge_type = _mod_merge.Merge3Merger
4102
tree, file_list = tree_files(file_list)
4104
self.add_cleanup(tree.unlock)
4093
tree, file_list = WorkingTree.open_containing_paths(file_list)
4094
self.add_cleanup(tree.lock_write().unlock)
4105
4095
parents = tree.get_parent_ids()
4106
4096
if len(parents) != 2:
4107
4097
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4217
4207
def run(self, revision=None, no_backup=False, file_list=None,
4218
4208
forget_merges=None):
4219
tree, file_list = tree_files(file_list)
4220
tree.lock_tree_write()
4221
self.add_cleanup(tree.unlock)
4209
tree, file_list = WorkingTree.open_containing_paths(file_list)
4210
self.add_cleanup(tree.lock_tree_write().unlock)
4222
4211
if forget_merges:
4223
4212
tree.set_parent_ids(tree.get_parent_ids()[:1])
4313
4302
_see_also = ['merge', 'pull']
4314
4303
takes_args = ['other_branch?']
4315
4304
takes_options = [
4316
4306
Option('reverse', 'Reverse the order of revisions.'),
4317
4307
Option('mine-only',
4318
4308
'Display changes in the local branch only.'),
4340
4330
theirs_only=False,
4341
4331
log_format=None, long=False, short=False, line=False,
4342
4332
show_ids=False, verbose=False, this=False, other=False,
4343
include_merges=False, revision=None, my_revision=None):
4333
include_merges=False, revision=None, my_revision=None,
4344
4335
from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4336
def message(s):
4346
4337
if not is_quiet():
4359
4350
elif theirs_only:
4360
4351
restrict = 'remote'
4362
local_branch = Branch.open_containing(u".")[0]
4363
local_branch.lock_read()
4364
self.add_cleanup(local_branch.unlock)
4353
local_branch = Branch.open_containing(directory)[0]
4354
self.add_cleanup(local_branch.lock_read().unlock)
4366
4356
parent = local_branch.get_parent()
4367
4357
if other_branch is None:
4378
4368
if remote_branch.base == local_branch.base:
4379
4369
remote_branch = local_branch
4381
remote_branch.lock_read()
4382
self.add_cleanup(remote_branch.unlock)
4371
self.add_cleanup(remote_branch.lock_read().unlock)
4384
4373
local_revid_range = _revision_range_to_revid_range(
4385
4374
_get_revision_range(my_revision, local_branch,
4440
4429
message("Branches are up to date.\n")
4441
4430
self.cleanup_now()
4442
4431
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)
4432
self.add_cleanup(local_branch.lock_write().unlock)
4445
4433
# handle race conditions - a parent might be set while we run.
4446
4434
if local_branch.get_parent() is None:
4447
4435
local_branch.set_parent(remote_branch.base)
4578
4565
Option('long', help='Show commit date in annotations.'),
4582
4570
encoding_type = 'exact'
4584
4572
@display_command
4585
4573
def run(self, filename, all=False, long=False, revision=None,
4574
show_ids=False, directory=None):
4587
4575
from bzrlib.annotate import annotate_file, annotate_file_tree
4588
4576
wt, branch, relpath = \
4589
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4577
_open_directory_or_containing_tree_or_branch(filename, directory)
4590
4578
if wt is not None:
4592
self.add_cleanup(wt.unlock)
4579
self.add_cleanup(wt.lock_read().unlock)
4595
self.add_cleanup(branch.unlock)
4581
self.add_cleanup(branch.lock_read().unlock)
4596
4582
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4598
self.add_cleanup(tree.unlock)
4583
self.add_cleanup(tree.lock_read().unlock)
4599
4584
if wt is not None:
4600
4585
file_id = wt.path2id(relpath)
4620
4605
hidden = True # is this right ?
4621
4606
takes_args = ['revision_id*']
4622
takes_options = ['revision']
4607
takes_options = ['directory', 'revision']
4624
def run(self, revision_id_list=None, revision=None):
4609
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4610
if revision_id_list is not None and revision is not None:
4626
4611
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4612
if revision_id_list is None and revision is None:
4628
4613
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)
4614
b = WorkingTree.open_containing(directory)[0].branch
4615
self.add_cleanup(b.lock_write().unlock)
4632
4616
return self._run(b, revision_id_list, revision)
4634
4618
def _run(self, b, revision_id_list, revision):
4694
4678
_see_also = ['checkouts', 'unbind']
4695
4679
takes_args = ['location?']
4680
takes_options = ['directory']
4698
def run(self, location=None):
4699
b, relpath = Branch.open_containing(u'.')
4682
def run(self, location=None, directory=u'.'):
4683
b, relpath = Branch.open_containing(directory)
4700
4684
if location is None:
4702
4686
location = b.get_old_bound_location()
4730
4714
_see_also = ['checkouts', 'bind']
4731
4715
takes_args = []
4716
takes_options = ['directory']
4735
b, relpath = Branch.open_containing(u'.')
4718
def run(self, directory=u'.'):
4719
b, relpath = Branch.open_containing(directory)
4736
4720
if not b.unbind():
4737
4721
raise errors.BzrCommandError('Local branch is not bound')
4784
4768
b = control.open_branch()
4786
4770
if tree is not None:
4788
self.add_cleanup(tree.unlock)
4771
self.add_cleanup(tree.lock_write().unlock)
4791
self.add_cleanup(b.unlock)
4773
self.add_cleanup(b.lock_write().unlock)
4792
4774
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4794
4776
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4833
4815
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')
4818
if not ui.ui_factory.confirm_action(
4819
'Uncommit these revisions',
4820
'bzrlib.builtins.uncommit',
4822
self.outf.write('Canceled\n')
4840
4825
mutter('Uncommitting from {%s} to {%s}',
4848
4833
class cmd_break_lock(Command):
4849
__doc__ = """Break a dead lock on a repository, branch or working directory.
4834
__doc__ = """Break a dead lock.
4836
This command breaks a lock on a repository, branch, working directory or
4851
4839
CAUTION: Locks should only be broken when you are sure that the process
4852
4840
holding the lock has been stopped.
4859
4847
bzr break-lock bzr+ssh://example.com/bzr/foo
4848
bzr break-lock --conf ~/.bazaar
4861
4851
takes_args = ['location?']
4854
help='LOCATION is the directory where the config lock is.'),
4856
help='Do not ask for confirmation before breaking the lock.'),
4863
def run(self, location=None, show=False):
4859
def run(self, location=None, config=False, force=False):
4864
4860
if location is None:
4865
4861
location = u'.'
4866
control, relpath = bzrdir.BzrDir.open_containing(location)
4868
control.break_lock()
4869
except NotImplementedError:
4863
ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
4865
{'bzrlib.lockdir.break': True})
4867
conf = _mod_config.LockableConfig(file_name=location)
4870
control, relpath = bzrdir.BzrDir.open_containing(location)
4872
control.break_lock()
4873
except NotImplementedError:
4873
4877
class cmd_wait_until_signalled(Command):
4902
4906
'result in a dynamically allocated port. The default port '
4903
4907
'depends on the protocol.',
4906
help='Serve contents of this directory.',
4909
custom_help('directory',
4910
help='Serve contents of this directory.'),
4908
4911
Option('allow-writes',
4909
4912
help='By default the server is a readonly server. Supplying '
4910
4913
'--allow-writes enables write access to the contents of '
4938
4941
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
4942
protocol=None):
4940
from bzrlib.transport import get_transport, transport_server_registry
4943
from bzrlib import transport
4941
4944
if directory is None:
4942
4945
directory = os.getcwd()
4943
4946
if protocol is None:
4944
protocol = transport_server_registry.get()
4947
protocol = transport.transport_server_registry.get()
4945
4948
host, port = self.get_host_and_port(port)
4946
4949
url = urlutils.local_path_to_url(directory)
4947
4950
if not allow_writes:
4948
4951
url = 'readonly+' + url
4949
transport = get_transport(url)
4950
protocol(transport, host, port, inet)
4952
t = transport.get_transport(url)
4953
protocol(t, host, port, inet)
4953
4956
class cmd_join(Command):
4959
4962
not part of it. (Such trees can be produced by "bzr split", but also by
4960
4963
running "bzr branch" with the target inside a tree.)
4962
The result is a combined tree, with the subtree no longer an independant
4965
The result is a combined tree, with the subtree no longer an independent
4963
4966
part. This is marked as a merge of the subtree into the containing tree,
4964
4967
and all history is preserved.
5064
5068
encoding_type = 'exact'
5066
5070
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
sign=False, revision=None, mail_to=None, message=None):
5071
sign=False, revision=None, mail_to=None, message=None,
5068
5073
from bzrlib.revision import ensure_null, NULL_REVISION
5069
5074
include_patch, include_bundle = {
5070
5075
'plain': (False, False),
5071
5076
'diff': (True, False),
5072
5077
'bundle': (True, True),
5074
branch = Branch.open('.')
5079
branch = Branch.open(directory)
5075
5080
stored_submit_branch = branch.get_submit_branch()
5076
5081
if submit_branch is None:
5077
5082
submit_branch = stored_submit_branch
5162
5167
given, in which case it is sent to a file.
5164
5169
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.
5170
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5166
5171
If the preferred client can't be found (or used), your editor will be used.
5168
5173
To use a specific mail program, set the mail_client configuration option.
5339
5344
Option('delete',
5340
5345
help='Delete this tag rather than placing it.',
5343
help='Branch in which to place the tag.',
5347
custom_help('directory',
5348
help='Branch in which to place the tag.'),
5347
5349
Option('force',
5348
5350
help='Replace existing tags.',
5359
5361
branch, relpath = Branch.open_containing(directory)
5361
self.add_cleanup(branch.unlock)
5362
self.add_cleanup(branch.lock_write().unlock)
5363
5364
if tag_name is None:
5364
5365
raise errors.BzrCommandError("No tag specified to delete.")
5393
5394
_see_also = ['tag']
5394
5395
takes_options = [
5396
help='Branch whose tags should be displayed.',
5396
custom_help('directory',
5397
help='Branch whose tags should be displayed.'),
5400
5398
RegistryOption.from_kwargs('sort',
5401
5399
'Sort tags by different criteria.', title='Sorting',
5402
5400
alpha='Sort tags lexicographically (default).',
5423
self.add_cleanup(branch.unlock)
5420
self.add_cleanup(branch.lock_read().unlock)
5425
5422
graph = branch.repository.get_graph()
5426
5423
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5575
5572
takes_args = ['to_location?']
5576
takes_options = [Option('force',
5573
takes_options = ['directory',
5577
5575
help='Switch even if local commits will be lost.'),
5579
5577
Option('create-branch', short_name='b',
5584
5582
def run(self, to_location=None, force=False, create_branch=False,
5583
revision=None, directory=u'.'):
5586
5584
from bzrlib import switch
5585
tree_location = directory
5588
5586
revision = _get_one_revision('switch', revision)
5589
5587
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5588
if to_location is None:
5591
5589
if revision is None:
5592
5590
raise errors.BzrCommandError('You must supply either a'
5593
5591
' revision or a location')
5592
to_location = tree_location
5596
5594
branch = control_dir.open_branch()
5597
5595
had_explicit_nick = branch.get_config().has_explicit_nickname()
5735
tree, file_list = tree_files(file_list, apply_view=False)
5733
tree, file_list = WorkingTree.open_containing_paths(file_list,
5736
5735
current_view, view_dict = tree.views.get_view_info()
5737
5736
if name is None:
5738
5737
name = current_view
5886
5886
_see_also = ['unshelve']
5888
5888
def run(self, revision=None, all=False, file_list=None, message=None,
5889
writer=None, list=False, destroy=False):
5889
writer=None, list=False, destroy=False, directory=u'.'):
5891
5891
return self.run_for_list()
5892
5892
from bzrlib.shelf_ui import Shelver
5894
5894
writer = bzrlib.option.diff_writer_registry.get()
5896
5896
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
file_list, message, destroy=destroy)
5897
file_list, message, destroy=destroy, directory=directory)
5905
5905
def run_for_list(self):
5906
5906
tree = WorkingTree.open_containing('.')[0]
5908
self.add_cleanup(tree.unlock)
5907
self.add_cleanup(tree.lock_read().unlock)
5909
5908
manager = tree.get_shelf_manager()
5910
5909
shelves = manager.active_shelves()
5911
5910
if len(shelves) == 0:
5930
5929
takes_args = ['shelf_id?']
5931
5930
takes_options = [
5932
5932
RegistryOption.from_kwargs(
5933
5933
'action', help="The action to perform.",
5934
5934
enum_switch=False, value_switches=True,
5943
5943
_see_also = ['shelve']
5945
def run(self, shelf_id=None, action='apply'):
5945
def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
5946
from bzrlib.shelf_ui import Unshelver
5947
unshelver = Unshelver.from_args(shelf_id, action)
5947
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5949
5949
unshelver.run()
5967
5967
To check what clean-tree will do, use --dry-run.
5969
takes_options = [Option('ignored', help='Delete all ignored files.'),
5969
takes_options = ['directory',
5970
Option('ignored', help='Delete all ignored files.'),
5970
5971
Option('detritus', help='Delete conflict files, merge'
5971
5972
' backups, and failed selftest dirs.'),
5972
5973
Option('unknown',
5975
5976
' deleting them.'),
5976
5977
Option('force', help='Do not prompt before deleting.')]
5977
5978
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5979
force=False, directory=u'.'):
5979
5980
from bzrlib.clean_tree import clean_tree
5980
5981
if not (unknown or ignored or detritus):
5984
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
dry_run=dry_run, no_prompt=force)
5985
clean_tree(directory, unknown=unknown, ignored=ignored,
5986
detritus=detritus, dry_run=dry_run, no_prompt=force)
5988
5989
class cmd_reference(Command):
added
removed
bzrlib/builtins.py
