74
75
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,
80
return internal_tree_files(file_list, default_branch, canonicalize,
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]))
84
88
def tree_files_for_add(file_list):
149
153
# XXX: Bad function name; should possibly also be a class method of
150
154
# WorkingTree rather than a function.
151
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
152
155
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
153
156
apply_view=True):
154
157
"""Convert command-line paths to a WorkingTree and relative paths.
156
Deprecated: use WorkingTree.open_containing_paths instead.
158
159
This is typically used for command-line processors that take one or
159
160
more filenames, and infer the workingtree that contains them.
171
172
:return: workingtree, [relative_paths]
173
return WorkingTree.open_containing_paths(
174
file_list, default_directory='.',
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)
179
223
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)
199
235
# TODO: Make sure no commands unconditionally use the working directory as a
200
236
# branch. If a filename argument is used, the first of them should be used to
201
237
# specify the branch. (Perhaps this can be factored out into some kind of
279
315
raise errors.BzrCommandError('bzr status --revision takes exactly'
280
316
' one or two revision specifiers')
282
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
318
tree, relfile_list = tree_files(file_list)
283
319
# Avoid asking for specific files when that is not needed.
284
320
if relfile_list == ['']:
285
321
relfile_list = None
317
353
self.outf.write(revtext.decode('utf-8'))
320
def run(self, revision_id=None, revision=None, directory=u'.'):
356
def run(self, revision_id=None, revision=None):
321
357
if revision_id is not None and revision is not None:
322
358
raise errors.BzrCommandError('You can only supply one of'
323
359
' revision_id or --revision')
324
360
if revision_id is None and revision is None:
325
361
raise errors.BzrCommandError('You must supply either'
326
362
' --revision or a revision_id')
327
b = WorkingTree.open_containing(directory)[0].branch
363
b = WorkingTree.open_containing(u'.')[0].branch
329
365
revisions = b.repository.revisions
330
366
if revisions is None:
468
504
if (working.has_changes()):
469
505
raise errors.UncommittedChanges(working)
470
if working.get_shelf_manager().last_shelf() is not None:
471
raise errors.ShelvedChanges(working)
473
if working.user_url != working.branch.user_url:
507
working_path = working.bzrdir.root_transport.base
508
branch_path = working.branch.bzrdir.root_transport.base
509
if working_path != branch_path:
474
510
raise errors.BzrCommandError("You cannot remove the working tree"
475
511
" from a lightweight checkout")
496
532
wt = WorkingTree.open_containing(location)[0]
497
self.add_cleanup(wt.lock_read().unlock)
498
534
except (errors.NoWorkingTree, errors.NotLocalUrl):
499
535
raise errors.NoWorkingTree(location)
536
self.add_cleanup(wt.unlock)
500
537
revid = wt.last_revision()
502
539
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
505
542
revno = ".".join(str(n) for n in revno_t)
507
544
b = Branch.open_containing(location)[0]
508
self.add_cleanup(b.lock_read().unlock)
546
self.add_cleanup(b.unlock)
509
547
revno = b.revno()
510
548
self.cleanup_now()
511
549
self.outf.write(str(revno) + '\n')
518
556
takes_args = ['revision_info*']
519
557
takes_options = [
521
custom_help('directory',
522
560
help='Branch to examine, '
523
'rather than the one containing the working directory.'),
561
'rather than the one containing the working directory.',
524
565
Option('tree', help='Show revno of working tree'),
532
573
wt = WorkingTree.open_containing(directory)[0]
534
self.add_cleanup(wt.lock_read().unlock)
576
self.add_cleanup(wt.unlock)
535
577
except (errors.NoWorkingTree, errors.NotLocalUrl):
537
579
b = Branch.open_containing(directory)[0]
538
self.add_cleanup(b.lock_read().unlock)
581
self.add_cleanup(b.unlock)
539
582
revision_ids = []
540
583
if revision is not None:
541
584
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
640
683
should_print=(not is_quiet()))
643
self.add_cleanup(base_tree.lock_read().unlock)
686
base_tree.lock_read()
687
self.add_cleanup(base_tree.unlock)
644
688
tree, file_list = tree_files_for_add(file_list)
645
689
added, ignored = tree.smart_add(file_list, not
646
690
no_recurse, action=action, save=not dry_run)
717
761
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
719
763
revision = _get_one_revision('inventory', revision)
720
work_tree, file_list = WorkingTree.open_containing_paths(file_list)
721
self.add_cleanup(work_tree.lock_read().unlock)
764
work_tree, file_list = tree_files(file_list)
765
work_tree.lock_read()
766
self.add_cleanup(work_tree.unlock)
722
767
if revision is not None:
723
768
tree = revision.as_tree(work_tree.branch)
725
770
extra_trees = [work_tree]
726
self.add_cleanup(tree.lock_read().unlock)
772
self.add_cleanup(tree.unlock)
789
835
if len(names_list) < 2:
790
836
raise errors.BzrCommandError("missing file argument")
791
tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
792
self.add_cleanup(tree.lock_tree_write().unlock)
837
tree, rel_names = tree_files(names_list, canonicalize=False)
838
tree.lock_tree_write()
839
self.add_cleanup(tree.unlock)
793
840
self._run(tree, names_list, rel_names, after)
795
842
def run_auto(self, names_list, after, dry_run):
800
847
raise errors.BzrCommandError('--after cannot be specified with'
802
work_tree, file_list = WorkingTree.open_containing_paths(
803
names_list, default_directory='.')
804
self.add_cleanup(work_tree.lock_tree_write().unlock)
849
work_tree, file_list = tree_files(names_list, default_branch='.')
850
work_tree.lock_tree_write()
851
self.add_cleanup(work_tree.unlock)
805
852
rename_map.RenameMap.guess_renames(work_tree, dry_run)
807
854
def _run(self, tree, names_list, rel_names, after):
915
962
takes_options = ['remember', 'overwrite', 'revision',
916
963
custom_help('verbose',
917
964
help='Show logs of pulled revisions.'),
918
custom_help('directory',
919
966
help='Branch to pull into, '
920
'rather than the one containing the working directory.'),
967
'rather than the one containing the working directory.',
922
972
help="Perform a local pull in a bound "
923
973
"branch. Local pulls are not applied to "
939
989
tree_to = WorkingTree.open_containing(directory)[0]
940
990
branch_to = tree_to.branch
941
self.add_cleanup(tree_to.lock_write().unlock)
992
self.add_cleanup(tree_to.unlock)
942
993
except errors.NoWorkingTree:
944
995
branch_to = Branch.open_containing(directory)[0]
945
self.add_cleanup(branch_to.lock_write().unlock)
996
branch_to.lock_write()
997
self.add_cleanup(branch_to.unlock)
947
999
if local and not branch_to.get_bound_location():
948
1000
raise errors.LocalRequiresBoundBranch()
980
1032
branch_from = Branch.open(location,
981
1033
possible_transports=possible_transports)
982
self.add_cleanup(branch_from.lock_read().unlock)
1034
branch_from.lock_read()
1035
self.add_cleanup(branch_from.unlock)
984
1037
if branch_to.get_parent() is None or remember:
985
1038
branch_to.set_parent(branch_from.base)
1037
1090
Option('create-prefix',
1038
1091
help='Create the path leading up to the branch '
1039
1092
'if it does not already exist.'),
1040
custom_help('directory',
1041
1094
help='Branch to push from, '
1042
'rather than the one containing the working directory.'),
1095
'rather than the one containing the working directory.',
1043
1099
Option('use-existing-dir',
1044
1100
help='By default push will fail if the target'
1045
1101
' directory exists, but does not already'
1079
1135
revision_id = None
1080
1136
if tree is not None and revision_id is None:
1081
tree.check_changed_or_out_of_date(
1082
strict, 'push_strict',
1083
more_error='Use --no-strict to force the push.',
1084
more_warning='Uncommitted changes will not be pushed.')
1137
tree.warn_if_changed_or_out_of_date(
1138
strict, 'push_strict', 'Use --no-strict to force the push.')
1085
1139
# Get the stacked_on branch, if any
1086
1140
if stacked_on is not None:
1087
1141
stacked_on = urlutils.normalize_url(stacked_on)
1135
1189
_see_also = ['checkout']
1136
1190
takes_args = ['from_location', 'to_location?']
1137
takes_options = ['revision',
1138
Option('hardlink', help='Hard-link working tree files where possible.'),
1139
Option('files-from', type=str,
1140
help="Get file contents from this tree."),
1191
takes_options = ['revision', Option('hardlink',
1192
help='Hard-link working tree files where possible.'),
1141
1193
Option('no-tree',
1142
1194
help="Create a branch without a working-tree."),
1143
1195
Option('switch',
1162
1214
def run(self, from_location, to_location=None, revision=None,
1163
1215
hardlink=False, stacked=False, standalone=False, no_tree=False,
1164
use_existing_dir=False, switch=False, bind=False,
1216
use_existing_dir=False, switch=False, bind=False):
1166
1217
from bzrlib import switch as _mod_switch
1167
1218
from bzrlib.tag import _merge_tags_if_possible
1168
1219
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1170
if not (hardlink or files_from):
1171
# accelerator_tree is usually slower because you have to read N
1172
# files (no readahead, lots of seeks, etc), but allow the user to
1173
# explicitly request it
1174
accelerator_tree = None
1175
if files_from is not None and files_from != from_location:
1176
accelerator_tree = WorkingTree.open(files_from)
1177
1221
revision = _get_one_revision('branch', revision)
1178
self.add_cleanup(br_from.lock_read().unlock)
1223
self.add_cleanup(br_from.unlock)
1179
1224
if revision is not None:
1180
1225
revision_id = revision.as_revision_id(br_from)
1286
1331
to_location = branch_location
1287
1332
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1288
1333
branch_location)
1289
if not (hardlink or files_from):
1290
# accelerator_tree is usually slower because you have to read N
1291
# files (no readahead, lots of seeks, etc), but allow the user to
1292
# explicitly request it
1293
accelerator_tree = None
1294
1334
revision = _get_one_revision('checkout', revision)
1295
if files_from is not None and files_from != branch_location:
1335
if files_from is not None:
1296
1336
accelerator_tree = WorkingTree.open(files_from)
1297
1337
if revision is not None:
1298
1338
revision_id = revision.as_revision_id(source)
1326
1366
@display_command
1327
1367
def run(self, dir=u'.'):
1328
1368
tree = WorkingTree.open_containing(dir)[0]
1329
self.add_cleanup(tree.lock_read().unlock)
1370
self.add_cleanup(tree.unlock)
1330
1371
new_inv = tree.inventory
1331
1372
old_tree = tree.basis_tree()
1332
self.add_cleanup(old_tree.lock_read().unlock)
1373
old_tree.lock_read()
1374
self.add_cleanup(old_tree.unlock)
1333
1375
old_inv = old_tree.inventory
1335
1377
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1354
1396
If you want to discard your local changes, you can just do a
1355
1397
'bzr revert' instead of 'bzr commit' after the update.
1357
If you want to restore a file that has been removed locally, use
1358
'bzr revert' instead of 'bzr update'.
1360
1399
If the tree's branch is bound to a master branch, it will also update
1361
1400
the branch from the master.
1376
1415
master = branch.get_master_branch(
1377
1416
possible_transports=possible_transports)
1378
1417
if master is not None:
1379
1419
branch_location = master.base
1421
tree.lock_tree_write()
1382
1422
branch_location = tree.branch.base
1383
tree.lock_tree_write()
1384
1423
self.add_cleanup(tree.unlock)
1385
1424
# get rid of the final '/' and be ready for display
1386
1425
branch_location = urlutils.unescape_for_display(
1480
1519
class cmd_remove(Command):
1481
1520
__doc__ = """Remove files or directories.
1483
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1484
delete them if they can easily be recovered using revert otherwise they
1485
will be backed up (adding an extention of the form .~#~). If no options or
1486
parameters are given Bazaar will scan for files that are being tracked by
1487
Bazaar but missing in your tree and stop tracking them for you.
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.
1489
1527
takes_args = ['file*']
1490
1528
takes_options = ['verbose',
1492
1530
RegistryOption.from_kwargs('file-deletion-strategy',
1493
1531
'The file deletion mode to be used.',
1494
1532
title='Deletion Strategy', value_switches=True, enum_switch=False,
1495
safe='Backup changed files (default).',
1533
safe='Only delete files if they can be'
1534
' safely recovered (default).',
1496
1535
keep='Delete from bzr but leave the working copy.',
1497
1536
force='Delete all the specified files, even if they can not be '
1498
1537
'recovered and even if they are non-empty directories.')]
1502
1541
def run(self, file_list, verbose=False, new=False,
1503
1542
file_deletion_strategy='safe'):
1504
tree, file_list = WorkingTree.open_containing_paths(file_list)
1543
tree, file_list = tree_files(file_list)
1506
1545
if file_list is not None:
1507
1546
file_list = [f for f in file_list]
1509
self.add_cleanup(tree.lock_write().unlock)
1549
self.add_cleanup(tree.unlock)
1510
1550
# Heuristics should probably all move into tree.remove_smart or
1596
1636
_see_also = ['check']
1597
1637
takes_args = ['branch?']
1599
Option('canonicalize-chks',
1600
help='Make sure CHKs are in canonical form (repairs '
1605
def run(self, branch=".", canonicalize_chks=False):
1639
def run(self, branch="."):
1606
1640
from bzrlib.reconcile import reconcile
1607
1641
dir = bzrdir.BzrDir.open(branch)
1608
reconcile(dir, canonicalize_chks=canonicalize_chks)
1611
1645
class cmd_revision_history(Command):
1955
1985
old_branch, new_branch,
1956
1986
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1957
1987
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1958
# GNU diff on Windows uses ANSI encoding for filenames
1959
path_encoding = osutils.get_diff_header_encoding()
1960
1988
return show_diff_trees(old_tree, new_tree, sys.stdout,
1961
1989
specific_files=specific_files,
1962
1990
external_diff_options=diff_options,
1963
1991
old_label=old_label, new_label=new_label,
1964
extra_trees=extra_trees,
1965
path_encoding=path_encoding,
1992
extra_trees=extra_trees, using=using,
1967
1993
format_cls=format)
1977
2003
# level of effort but possibly much less IO. (Or possibly not,
1978
2004
# if the directories are very large...)
1979
2005
_see_also = ['status', 'ls']
1980
takes_options = ['directory', 'show-ids']
2006
takes_options = ['show-ids']
1982
2008
@display_command
1983
def run(self, show_ids=False, directory=u'.'):
1984
tree = WorkingTree.open_containing(directory)[0]
1985
self.add_cleanup(tree.lock_read().unlock)
2009
def run(self, show_ids=False):
2010
tree = WorkingTree.open_containing(u'.')[0]
2012
self.add_cleanup(tree.unlock)
1986
2013
old = tree.basis_tree()
1987
self.add_cleanup(old.lock_read().unlock)
2015
self.add_cleanup(old.unlock)
1988
2016
for path, ie in old.inventory.iter_entries():
1989
2017
if not tree.has_id(ie.file_id):
1990
2018
self.outf.write(path)
2002
2030
_see_also = ['status', 'ls']
2003
takes_options = ['directory', 'null']
2033
help='Write an ascii NUL (\\0) separator '
2034
'between files rather than a newline.')
2005
2037
@display_command
2006
def run(self, null=False, directory=u'.'):
2007
tree = WorkingTree.open_containing(directory)[0]
2038
def run(self, null=False):
2039
tree = WorkingTree.open_containing(u'.')[0]
2008
2040
td = tree.changes_from(tree.basis_tree())
2009
2041
for path, id, kind, text_modified, meta_modified in td.modified:
2021
2053
_see_also = ['status', 'ls']
2022
takes_options = ['directory', 'null']
2056
help='Write an ascii NUL (\\0) separator '
2057
'between files rather than a newline.')
2024
2060
@display_command
2025
def run(self, null=False, directory=u'.'):
2026
wt = WorkingTree.open_containing(directory)[0]
2027
self.add_cleanup(wt.lock_read().unlock)
2061
def run(self, null=False):
2062
wt = WorkingTree.open_containing(u'.')[0]
2064
self.add_cleanup(wt.unlock)
2028
2065
basis = wt.basis_tree()
2029
self.add_cleanup(basis.lock_read().unlock)
2067
self.add_cleanup(basis.unlock)
2030
2068
basis_inv = basis.inventory
2031
2069
inv = wt.inventory
2032
2070
for file_id in inv:
2035
2073
if inv.is_root(file_id) and len(basis_inv) == 0:
2037
2075
path = inv.id2path(file_id)
2038
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2076
if not os.access(osutils.abspath(path), os.F_OK):
2041
2079
self.outf.write(path + '\0')
2241
2279
help='Show just the specified revision.'
2242
2280
' See also "help revisionspec".'),
2244
RegistryOption('authors',
2245
'What names to list as authors - first, all or committer.',
2247
lazy_registry=('bzrlib.log', 'author_list_registry'),
2249
2282
Option('levels',
2250
2283
short_name='n',
2251
2284
help='Number of levels to display - 0 for all, 1 for flat.',
2266
2299
help='Show changes made in each revision as a patch.'),
2267
2300
Option('include-merges',
2268
2301
help='Show merged revisions like --levels 0 does.'),
2269
Option('exclude-common-ancestry',
2270
help='Display only the revisions that are not part'
2271
' of both ancestries (require -rX..Y)'
2274
2303
encoding_type = 'replace'
2287
2316
show_diff=False,
2288
include_merges=False,
2290
exclude_common_ancestry=False,
2317
include_merges=False):
2292
2318
from bzrlib.log import (
2294
2320
make_log_request_dict,
2295
2321
_get_info_for_log_files,
2297
2323
direction = (forward and 'forward') or 'reverse'
2298
if (exclude_common_ancestry
2299
and (revision is None or len(revision) != 2)):
2300
raise errors.BzrCommandError(
2301
'--exclude-common-ancestry requires -r with two revisions')
2302
2324
if include_merges:
2303
2325
if levels is None:
2321
2343
# find the file ids to log and check for directory filtering
2322
2344
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2323
revision, file_list, self.add_cleanup)
2345
revision, file_list)
2346
self.add_cleanup(b.unlock)
2324
2347
for relpath, file_id, kind in file_info_list:
2325
2348
if file_id is None:
2326
2349
raise errors.BzrCommandError(
2345
2368
dir, relpath = bzrdir.BzrDir.open_containing(location)
2346
2369
b = dir.open_branch()
2347
self.add_cleanup(b.lock_read().unlock)
2371
self.add_cleanup(b.unlock)
2348
2372
rev1, rev2 = _get_revision_range(revision, b, self.name())
2350
2374
# Decide on the type of delta & diff filtering to use
2370
2394
show_timezone=timezone,
2371
2395
delta_format=get_verbosity_level(),
2373
show_advice=levels is None,
2374
author_list_handler=authors)
2397
show_advice=levels is None)
2376
2399
# Choose the algorithm for doing the logging. It's annoying
2377
2400
# having multiple code paths like this but necessary until
2396
2419
direction=direction, specific_fileids=file_ids,
2397
2420
start_revision=rev1, end_revision=rev2, limit=limit,
2398
2421
message_search=message, delta_type=delta_type,
2399
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2400
exclude_common_ancestry=exclude_common_ancestry,
2422
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2402
2423
Logger(b, rqst).show(lf)
2475
2496
tree, relpath = WorkingTree.open_containing(filename)
2476
2497
file_id = tree.path2id(relpath)
2477
2498
b = tree.branch
2478
self.add_cleanup(b.lock_read().unlock)
2500
self.add_cleanup(b.unlock)
2479
2501
touching_revs = log.find_touching_revisions(b, file_id)
2480
2502
for revno, revision_id, what in touching_revs:
2481
2503
self.outf.write("%6d %s\n" % (revno, what))
2494
2516
help='Recurse into subdirectories.'),
2495
2517
Option('from-root',
2496
2518
help='Print paths relative to the root of the branch.'),
2497
Option('unknown', short_name='u',
2498
help='Print unknown files.'),
2519
Option('unknown', help='Print unknown files.'),
2499
2520
Option('versioned', help='Print versioned files.',
2500
2521
short_name='V'),
2501
Option('ignored', short_name='i',
2502
help='Print ignored files.'),
2503
Option('kind', short_name='k',
2522
Option('ignored', help='Print ignored files.'),
2524
help='Write an ascii NUL (\\0) separator '
2525
'between files rather than a newline.'),
2504
2527
help='List entries of a particular kind: file, directory, symlink.',
2510
2531
@display_command
2511
2532
def run(self, revision=None, verbose=False,
2512
2533
recursive=False, from_root=False,
2513
2534
unknown=False, versioned=False, ignored=False,
2514
null=False, kind=None, show_ids=False, path=None, directory=None):
2535
null=False, kind=None, show_ids=False, path=None):
2516
2537
if kind and kind not in ('file', 'directory', 'symlink'):
2517
2538
raise errors.BzrCommandError('invalid kind specified')
2529
2550
raise errors.BzrCommandError('cannot specify both --from-root'
2532
tree, branch, relpath = \
2533
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2553
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2535
2556
# Calculate the prefix to use
2551
2572
view_str = views.view_display_str(view_files)
2552
2573
note("Ignoring files outside view. View is %s" % view_str)
2554
self.add_cleanup(tree.lock_read().unlock)
2576
self.add_cleanup(tree.unlock)
2555
2577
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2556
2578
from_dir=relpath, recursive=recursive):
2557
2579
# Apply additional masking
2606
2628
_see_also = ['ls']
2607
takes_options = ['directory']
2609
2630
@display_command
2610
def run(self, directory=u'.'):
2611
for f in WorkingTree.open_containing(directory)[0].unknowns():
2632
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2612
2633
self.outf.write(osutils.quotefn(f) + '\n')
2680
2701
_see_also = ['status', 'ignored', 'patterns']
2681
2702
takes_args = ['name_pattern*']
2682
takes_options = ['directory',
2683
2704
Option('default-rules',
2684
2705
help='Display the default ignore rules that bzr uses.')
2687
def run(self, name_pattern_list=None, default_rules=None,
2708
def run(self, name_pattern_list=None, default_rules=None):
2689
2709
from bzrlib import ignores
2690
2710
if default_rules is not None:
2691
2711
# dump the default rules and exit
2697
2717
"NAME_PATTERN or --default-rules.")
2698
2718
name_pattern_list = [globbing.normalize_pattern(p)
2699
2719
for p in name_pattern_list]
2701
for p in name_pattern_list:
2702
if not globbing.Globster.is_pattern_valid(p):
2703
bad_patterns += ('\n %s' % p)
2705
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2706
ui.ui_factory.show_error(msg)
2707
raise errors.InvalidPattern('')
2708
2720
for name_pattern in name_pattern_list:
2709
2721
if (name_pattern[0] == '/' or
2710
2722
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2711
2723
raise errors.BzrCommandError(
2712
2724
"NAME_PATTERN should not be an absolute path")
2713
tree, relpath = WorkingTree.open_containing(directory)
2725
tree, relpath = WorkingTree.open_containing(u'.')
2714
2726
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2715
2727
ignored = globbing.Globster(name_pattern_list)
2717
self.add_cleanup(tree.lock_read().unlock)
2718
2730
for entry in tree.list_files():
2720
2732
if id is not None:
2721
2733
filename = entry[0]
2722
2734
if ignored.match(filename):
2723
2735
matches.append(filename)
2724
2737
if len(matches) > 0:
2725
2738
self.outf.write("Warning: the following files are version controlled and"
2726
2739
" match your ignore pattern:\n%s"
2742
2755
encoding_type = 'replace'
2743
2756
_see_also = ['ignore', 'ls']
2744
takes_options = ['directory']
2746
2758
@display_command
2747
def run(self, directory=u'.'):
2748
tree = WorkingTree.open_containing(directory)[0]
2749
self.add_cleanup(tree.lock_read().unlock)
2760
tree = WorkingTree.open_containing(u'.')[0]
2762
self.add_cleanup(tree.unlock)
2750
2763
for path, file_class, kind, file_id, entry in tree.list_files():
2751
2764
if file_class != 'I':
2765
2778
takes_args = ['revno']
2766
takes_options = ['directory']
2768
2780
@display_command
2769
def run(self, revno, directory=u'.'):
2781
def run(self, revno):
2771
2783
revno = int(revno)
2772
2784
except ValueError:
2773
2785
raise errors.BzrCommandError("not a valid revision-number: %r"
2775
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2787
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2776
2788
self.outf.write("%s\n" % revid)
2805
2817
================= =========================
2807
2819
takes_args = ['dest', 'branch_or_subdir?']
2808
takes_options = ['directory',
2809
2821
Option('format',
2810
2822
help="Type of file to export to.",
2820
2832
'revision in which it was changed.'),
2822
2834
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2823
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2835
root=None, filters=False, per_file_timestamps=False):
2824
2836
from bzrlib.export import export
2826
2838
if branch_or_subdir is None:
2827
tree = WorkingTree.open_containing(directory)[0]
2839
tree = WorkingTree.open_containing(u'.')[0]
2828
2840
b = tree.branch
2851
2863
_see_also = ['ls']
2852
takes_options = ['directory',
2853
2865
Option('name-from-revision', help='The path name in the old tree.'),
2854
2866
Option('filters', help='Apply content filters to display the '
2855
2867
'convenience form.'),
2861
2873
@display_command
2862
2874
def run(self, filename, revision=None, name_from_revision=False,
2863
filters=False, directory=None):
2864
2876
if revision is not None and len(revision) != 1:
2865
2877
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2866
2878
" one revision specifier")
2867
2879
tree, branch, relpath = \
2868
_open_directory_or_containing_tree_or_branch(filename, directory)
2869
self.add_cleanup(branch.lock_read().unlock)
2880
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2882
self.add_cleanup(branch.unlock)
2870
2883
return self._run(tree, branch, relpath, filename, revision,
2871
2884
name_from_revision, filters)
2875
2888
if tree is None:
2876
2889
tree = b.basis_tree()
2877
2890
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2878
self.add_cleanup(rev_tree.lock_read().unlock)
2891
rev_tree.lock_read()
2892
self.add_cleanup(rev_tree.unlock)
2880
2894
old_file_id = rev_tree.path2id(relpath)
3047
3061
"the master branch until a normal commit "
3048
3062
"is performed."
3050
Option('show-diff', short_name='p',
3051
3065
help='When no message is supplied, show the diff along'
3052
3066
' with the status summary in the message editor.'),
3103
3117
properties = {}
3105
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3119
tree, selected_list = tree_files(selected_list)
3106
3120
if selected_list == ['']:
3107
3121
# workaround - commit of root of tree should be exactly the same
3108
3122
# as just default commit in that tree, and succeed even though
3143
3157
def get_message(commit_obj):
3144
3158
"""Callback to get commit message"""
3148
my_message = f.read().decode(osutils.get_user_encoding())
3160
my_message = codecs.open(
3161
file, 'rt', osutils.get_user_encoding()).read()
3151
3162
elif message is not None:
3152
3163
my_message = message
3182
3193
reporter=None, verbose=verbose, revprops=properties,
3183
3194
authors=author, timestamp=commit_stamp,
3184
3195
timezone=offset,
3185
exclude=tree.safe_relpath_files(exclude))
3196
exclude=safe_relpath_files(tree, exclude))
3186
3197
except PointlessCommit:
3187
3198
raise errors.BzrCommandError("No changes to commit."
3188
3199
" Use --unchanged to commit anyhow.")
3308
3319
bzr whoami "Frank Chu <fchu@example.com>"
3310
takes_options = [ 'directory',
3321
takes_options = [ Option('email',
3312
3322
help='Display email address only.'),
3313
3323
Option('branch',
3314
3324
help='Set identity for the current branch instead of '
3318
3328
encoding_type = 'replace'
3320
3330
@display_command
3321
def run(self, email=False, branch=False, name=None, directory=None):
3331
def run(self, email=False, branch=False, name=None):
3322
3332
if name is None:
3323
if directory is None:
3324
# use branch if we're inside one; otherwise global config
3326
c = Branch.open_containing(u'.')[0].get_config()
3327
except errors.NotBranchError:
3328
c = _mod_config.GlobalConfig()
3330
c = Branch.open(directory).get_config()
3333
# use branch if we're inside one; otherwise global config
3335
c = Branch.open_containing('.')[0].get_config()
3336
except errors.NotBranchError:
3337
c = config.GlobalConfig()
3332
3339
self.outf.write(c.user_email() + '\n')
3337
3344
# display a warning if an email address isn't included in the given name.
3339
_mod_config.extract_email_address(name)
3346
config.extract_email_address(name)
3340
3347
except errors.NoEmailInUsername, e:
3341
3348
warning('"%s" does not seem to contain an email address. '
3342
3349
'This is allowed, but not recommended.', name)
3344
3351
# use global config unless --branch given
3346
if directory is None:
3347
c = Branch.open_containing(u'.')[0].get_config()
3349
c = Branch.open(directory).get_config()
3353
c = Branch.open_containing('.')[0].get_config()
3351
c = _mod_config.GlobalConfig()
3355
c = config.GlobalConfig()
3352
3356
c.set_user_option('email', name)
3365
3369
_see_also = ['info']
3366
3370
takes_args = ['nickname?']
3367
takes_options = ['directory']
3368
def run(self, nickname=None, directory=u'.'):
3369
branch = Branch.open_containing(directory)[0]
3371
def run(self, nickname=None):
3372
branch = Branch.open_containing(u'.')[0]
3370
3373
if nickname is None:
3371
3374
self.printme(branch)
3421
3424
'bzr alias --remove expects an alias to remove.')
3422
3425
# If alias is not found, print something like:
3423
3426
# unalias: foo: not found
3424
c = _mod_config.GlobalConfig()
3427
c = config.GlobalConfig()
3425
3428
c.unset_alias(alias_name)
3427
3430
@display_command
3428
3431
def print_aliases(self):
3429
3432
"""Print out the defined aliases in a similar format to bash."""
3430
aliases = _mod_config.GlobalConfig().get_aliases()
3433
aliases = config.GlobalConfig().get_aliases()
3431
3434
for key, value in sorted(aliases.iteritems()):
3432
3435
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3444
3447
def set_alias(self, alias_name, alias_command):
3445
3448
"""Save the alias in the global config."""
3446
c = _mod_config.GlobalConfig()
3449
c = config.GlobalConfig()
3447
3450
c.set_alias(alias_name, alias_command)
3484
3487
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3485
3488
into a pdb postmortem session.
3487
The --coverage=DIRNAME global option produces a report with covered code
3491
3491
Run only tests relating to 'ignore'::
3525
3525
'throughout the test suite.',
3526
3526
type=get_transport_type),
3527
3527
Option('benchmark',
3528
help='Run the benchmarks rather than selftests.',
3528
help='Run the benchmarks rather than selftests.'),
3530
3529
Option('lsprof-timed',
3531
3530
help='Generate lsprof output for benchmarked'
3532
3531
' sections of code.'),
3533
3532
Option('lsprof-tests',
3534
3533
help='Generate lsprof output for each test.'),
3534
Option('cache-dir', type=str,
3535
help='Cache intermediate benchmark output in this '
3535
3537
Option('first',
3536
3538
help='Run all tests, but run specified tests first.',
3537
3539
short_name='f',
3572
3574
def run(self, testspecs_list=None, verbose=False, one=False,
3573
3575
transport=None, benchmark=None,
3576
lsprof_timed=None, cache_dir=None,
3575
3577
first=False, list_only=False,
3576
3578
randomize=None, exclude=None, strict=False,
3577
3579
load_list=None, debugflag=None, starting_with=None, subunit=False,
3578
3580
parallel=None, lsprof_tests=False):
3579
from bzrlib import tests
3581
from bzrlib.tests import selftest
3582
import bzrlib.benchmarks as benchmarks
3583
from bzrlib.benchmarks import tree_creator
3585
# Make deprecation warnings visible, unless -Werror is set
3586
symbol_versioning.activate_deprecation_warnings(override=False)
3588
if cache_dir is not None:
3589
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3581
3590
if testspecs_list is not None:
3582
3591
pattern = '|'.join(testspecs_list)
3591
3600
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3592
3601
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3593
3602
# stdout, which would corrupt the subunit stream.
3594
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3595
# following code can be deleted when it's sufficiently deployed
3596
# -- vila/mgz 20100514
3597
if (sys.platform == "win32"
3598
and getattr(sys.stdout, 'fileno', None) is not None):
3603
if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3600
3605
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3602
3607
self.additional_selftest_args.setdefault(
3603
3608
'suite_decorators', []).append(parallel)
3605
raise errors.BzrCommandError(
3606
"--benchmark is no longer supported from bzr 2.2; "
3607
"use bzr-usertest instead")
3608
test_suite_factory = None
3610
test_suite_factory = benchmarks.test_suite
3611
# Unless user explicitly asks for quiet, be verbose in benchmarks
3612
verbose = not is_quiet()
3613
# TODO: should possibly lock the history file...
3614
benchfile = open(".perf_history", "at", buffering=1)
3615
self.add_cleanup(benchfile.close)
3617
test_suite_factory = None
3609
3619
selftest_kwargs = {"verbose": verbose,
3610
3620
"pattern": pattern,
3611
3621
"stop_on_failure": one,
3613
3623
"test_suite_factory": test_suite_factory,
3614
3624
"lsprof_timed": lsprof_timed,
3615
3625
"lsprof_tests": lsprof_tests,
3626
"bench_history": benchfile,
3616
3627
"matching_tests_first": first,
3617
3628
"list_only": list_only,
3618
3629
"random_seed": randomize,
3623
3634
"starting_with": starting_with
3625
3636
selftest_kwargs.update(self.additional_selftest_args)
3627
# Make deprecation warnings visible, unless -Werror is set
3628
cleanup = symbol_versioning.activate_deprecation_warnings(
3631
result = tests.selftest(**selftest_kwargs)
3637
result = selftest(**selftest_kwargs)
3634
3638
return int(not result)
3675
3679
branch1 = Branch.open_containing(branch)[0]
3676
3680
branch2 = Branch.open_containing(other)[0]
3677
self.add_cleanup(branch1.lock_read().unlock)
3678
self.add_cleanup(branch2.lock_read().unlock)
3682
self.add_cleanup(branch1.unlock)
3684
self.add_cleanup(branch2.unlock)
3679
3685
last1 = ensure_null(branch1.last_revision())
3680
3686
last2 = ensure_null(branch2.last_revision())
3775
3781
' completely merged into the source, pull from the'
3776
3782
' source rather than merging. When this happens,'
3777
3783
' you do not need to commit the result.'),
3778
custom_help('directory',
3779
3785
help='Branch to merge into, '
3780
'rather than the one containing the working directory.'),
3786
'rather than the one containing the working directory.',
3781
3790
Option('preview', help='Instead of merging, show a diff of the'
3783
3792
Option('interactive', help='Select changes interactively.',
3816
3825
unversioned_filter=tree.is_ignored, view_info=view_info)
3817
3826
pb = ui.ui_factory.nested_progress_bar()
3818
3827
self.add_cleanup(pb.finished)
3819
self.add_cleanup(tree.lock_write().unlock)
3829
self.add_cleanup(tree.unlock)
3820
3830
if location is not None:
3822
3832
mergeable = bundle.read_mergeable_from_url(location,
3883
3893
def _do_preview(self, merger):
3884
3894
from bzrlib.diff import show_diff_trees
3885
3895
result_tree = self._get_preview(merger)
3886
path_encoding = osutils.get_diff_header_encoding()
3887
3896
show_diff_trees(merger.this_tree, result_tree, self.outf,
3888
old_label='', new_label='',
3889
path_encoding=path_encoding)
3897
old_label='', new_label='')
3891
3899
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3892
3900
merger.change_reporter = change_reporter
4079
4087
from bzrlib.conflicts import restore
4080
4088
if merge_type is None:
4081
4089
merge_type = _mod_merge.Merge3Merger
4082
tree, file_list = WorkingTree.open_containing_paths(file_list)
4083
self.add_cleanup(tree.lock_write().unlock)
4090
tree, file_list = tree_files(file_list)
4092
self.add_cleanup(tree.unlock)
4084
4093
parents = tree.get_parent_ids()
4085
4094
if len(parents) != 2:
4086
4095
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4196
4205
def run(self, revision=None, no_backup=False, file_list=None,
4197
4206
forget_merges=None):
4198
tree, file_list = WorkingTree.open_containing_paths(file_list)
4199
self.add_cleanup(tree.lock_tree_write().unlock)
4207
tree, file_list = tree_files(file_list)
4208
tree.lock_tree_write()
4209
self.add_cleanup(tree.unlock)
4200
4210
if forget_merges:
4201
4211
tree.set_parent_ids(tree.get_parent_ids()[:1])
4291
4301
_see_also = ['merge', 'pull']
4292
4302
takes_args = ['other_branch?']
4293
4303
takes_options = [
4295
4304
Option('reverse', 'Reverse the order of revisions.'),
4296
4305
Option('mine-only',
4297
4306
'Display changes in the local branch only.'),
4319
4328
theirs_only=False,
4320
4329
log_format=None, long=False, short=False, line=False,
4321
4330
show_ids=False, verbose=False, this=False, other=False,
4322
include_merges=False, revision=None, my_revision=None,
4331
include_merges=False, revision=None, my_revision=None):
4324
4332
from bzrlib.missing import find_unmerged, iter_log_revisions
4325
4333
def message(s):
4326
4334
if not is_quiet():
4339
4347
elif theirs_only:
4340
4348
restrict = 'remote'
4342
local_branch = Branch.open_containing(directory)[0]
4343
self.add_cleanup(local_branch.lock_read().unlock)
4350
local_branch = Branch.open_containing(u".")[0]
4351
local_branch.lock_read()
4352
self.add_cleanup(local_branch.unlock)
4345
4354
parent = local_branch.get_parent()
4346
4355
if other_branch is None:
4357
4366
if remote_branch.base == local_branch.base:
4358
4367
remote_branch = local_branch
4360
self.add_cleanup(remote_branch.lock_read().unlock)
4369
remote_branch.lock_read()
4370
self.add_cleanup(remote_branch.unlock)
4362
4372
local_revid_range = _revision_range_to_revid_range(
4363
4373
_get_revision_range(my_revision, local_branch,
4418
4428
message("Branches are up to date.\n")
4419
4429
self.cleanup_now()
4420
4430
if not status_code and parent is None and other_branch is not None:
4421
self.add_cleanup(local_branch.lock_write().unlock)
4431
local_branch.lock_write()
4432
self.add_cleanup(local_branch.unlock)
4422
4433
# handle race conditions - a parent might be set while we run.
4423
4434
if local_branch.get_parent() is None:
4424
4435
local_branch.set_parent(remote_branch.base)
4554
4566
Option('long', help='Show commit date in annotations.'),
4559
4570
encoding_type = 'exact'
4561
4572
@display_command
4562
4573
def run(self, filename, all=False, long=False, revision=None,
4563
show_ids=False, directory=None):
4564
4575
from bzrlib.annotate import annotate_file, annotate_file_tree
4565
4576
wt, branch, relpath = \
4566
_open_directory_or_containing_tree_or_branch(filename, directory)
4577
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4567
4578
if wt is not None:
4568
self.add_cleanup(wt.lock_read().unlock)
4580
self.add_cleanup(wt.unlock)
4570
self.add_cleanup(branch.lock_read().unlock)
4583
self.add_cleanup(branch.unlock)
4571
4584
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4572
self.add_cleanup(tree.lock_read().unlock)
4586
self.add_cleanup(tree.unlock)
4573
4587
if wt is not None:
4574
4588
file_id = wt.path2id(relpath)
4594
4608
hidden = True # is this right ?
4595
4609
takes_args = ['revision_id*']
4596
takes_options = ['directory', 'revision']
4610
takes_options = ['revision']
4598
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4612
def run(self, revision_id_list=None, revision=None):
4599
4613
if revision_id_list is not None and revision is not None:
4600
4614
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4601
4615
if revision_id_list is None and revision is None:
4602
4616
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4603
b = WorkingTree.open_containing(directory)[0].branch
4604
self.add_cleanup(b.lock_write().unlock)
4617
b = WorkingTree.open_containing(u'.')[0].branch
4619
self.add_cleanup(b.unlock)
4605
4620
return self._run(b, revision_id_list, revision)
4607
4622
def _run(self, b, revision_id_list, revision):
4655
4670
class cmd_bind(Command):
4656
4671
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4657
If no branch is supplied, rebind to the last bound location.
4659
4673
Once converted into a checkout, commits must succeed on the master branch
4660
4674
before they will be applied to the local branch.
4667
4681
_see_also = ['checkouts', 'unbind']
4668
4682
takes_args = ['location?']
4669
takes_options = ['directory']
4671
def run(self, location=None, directory=u'.'):
4672
b, relpath = Branch.open_containing(directory)
4685
def run(self, location=None):
4686
b, relpath = Branch.open_containing(u'.')
4673
4687
if location is None:
4675
4689
location = b.get_old_bound_location()
4703
4717
_see_also = ['checkouts', 'bind']
4704
4718
takes_args = []
4705
takes_options = ['directory']
4707
def run(self, directory=u'.'):
4708
b, relpath = Branch.open_containing(directory)
4722
b, relpath = Branch.open_containing(u'.')
4709
4723
if not b.unbind():
4710
4724
raise errors.BzrCommandError('Local branch is not bound')
4757
4771
b = control.open_branch()
4759
4773
if tree is not None:
4760
self.add_cleanup(tree.lock_write().unlock)
4775
self.add_cleanup(tree.unlock)
4762
self.add_cleanup(b.lock_write().unlock)
4778
self.add_cleanup(b.unlock)
4763
4779
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4765
4781
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4804
4820
self.outf.write('The above revision(s) will be removed.\n')
4807
if not ui.ui_factory.confirm_action(
4808
'Uncommit these revisions',
4809
'bzrlib.builtins.uncommit',
4811
self.outf.write('Canceled\n')
4823
if not ui.ui_factory.get_boolean('Are you sure'):
4824
self.outf.write('Canceled')
4814
4827
mutter('Uncommitting from {%s} to {%s}',
4822
4835
class cmd_break_lock(Command):
4823
__doc__ = """Break a dead lock.
4825
This command breaks a lock on a repository, branch, working directory or
4836
__doc__ = """Break a dead lock on a repository, branch or working directory.
4828
4838
CAUTION: Locks should only be broken when you are sure that the process
4829
4839
holding the lock has been stopped.
4836
4846
bzr break-lock bzr+ssh://example.com/bzr/foo
4837
bzr break-lock --conf ~/.bazaar
4840
4848
takes_args = ['location?']
4843
help='LOCATION is the directory where the config lock is.'),
4845
help='Do not ask for confirmation before breaking the lock.'),
4848
def run(self, location=None, config=False, force=False):
4850
def run(self, location=None, show=False):
4849
4851
if location is None:
4850
4852
location = u'.'
4852
ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
4854
{'bzrlib.lockdir.break': True})
4856
conf = _mod_config.LockableConfig(file_name=location)
4859
control, relpath = bzrdir.BzrDir.open_containing(location)
4861
control.break_lock()
4862
except NotImplementedError:
4853
control, relpath = bzrdir.BzrDir.open_containing(location)
4855
control.break_lock()
4856
except NotImplementedError:
4866
4860
class cmd_wait_until_signalled(Command):
4895
4889
'result in a dynamically allocated port. The default port '
4896
4890
'depends on the protocol.',
4898
custom_help('directory',
4899
help='Serve contents of this directory.'),
4893
help='Serve contents of this directory.',
4900
4895
Option('allow-writes',
4901
4896
help='By default the server is a readonly server. Supplying '
4902
4897
'--allow-writes enables write access to the contents of '
4930
4925
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4931
4926
protocol=None):
4932
from bzrlib import transport
4927
from bzrlib.transport import get_transport, transport_server_registry
4933
4928
if directory is None:
4934
4929
directory = os.getcwd()
4935
4930
if protocol is None:
4936
protocol = transport.transport_server_registry.get()
4931
protocol = transport_server_registry.get()
4937
4932
host, port = self.get_host_and_port(port)
4938
4933
url = urlutils.local_path_to_url(directory)
4939
4934
if not allow_writes:
4940
4935
url = 'readonly+' + url
4941
t = transport.get_transport(url)
4942
protocol(t, host, port, inet)
4936
transport = get_transport(url)
4937
protocol(transport, host, port, inet)
4945
4940
class cmd_join(Command):
4951
4946
not part of it. (Such trees can be produced by "bzr split", but also by
4952
4947
running "bzr branch" with the target inside a tree.)
4954
The result is a combined tree, with the subtree no longer an independent
4949
The result is a combined tree, with the subtree no longer an independant
4955
4950
part. This is marked as a merge of the subtree into the containing tree,
4956
4951
and all history is preserved.
5057
5051
encoding_type = 'exact'
5059
5053
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5060
sign=False, revision=None, mail_to=None, message=None,
5054
sign=False, revision=None, mail_to=None, message=None):
5062
5055
from bzrlib.revision import ensure_null, NULL_REVISION
5063
5056
include_patch, include_bundle = {
5064
5057
'plain': (False, False),
5065
5058
'diff': (True, False),
5066
5059
'bundle': (True, True),
5068
branch = Branch.open(directory)
5061
branch = Branch.open('.')
5069
5062
stored_submit_branch = branch.get_submit_branch()
5070
5063
if submit_branch is None:
5071
5064
submit_branch = stored_submit_branch
5156
5149
given, in which case it is sent to a file.
5158
5151
Mail is sent using your preferred mail program. This should be transparent
5159
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5152
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5160
5153
If the preferred client can't be found (or used), your editor will be used.
5162
5155
To use a specific mail program, set the mail_client configuration option.
5333
5326
Option('delete',
5334
5327
help='Delete this tag rather than placing it.',
5336
custom_help('directory',
5337
help='Branch in which to place the tag.'),
5330
help='Branch in which to place the tag.',
5338
5334
Option('force',
5339
5335
help='Replace existing tags.',
5350
5346
branch, relpath = Branch.open_containing(directory)
5351
self.add_cleanup(branch.lock_write().unlock)
5348
self.add_cleanup(branch.unlock)
5353
5350
if tag_name is None:
5354
5351
raise errors.BzrCommandError("No tag specified to delete.")
5383
5380
_see_also = ['tag']
5384
5381
takes_options = [
5385
custom_help('directory',
5386
help='Branch whose tags should be displayed.'),
5383
help='Branch whose tags should be displayed.',
5387
5387
RegistryOption.from_kwargs('sort',
5388
5388
'Sort tags by different criteria.', title='Sorting',
5389
5389
alpha='Sort tags lexicographically (default).',
5409
self.add_cleanup(branch.lock_read().unlock)
5410
self.add_cleanup(branch.unlock)
5411
5412
graph = branch.repository.get_graph()
5412
5413
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5561
5562
takes_args = ['to_location?']
5562
takes_options = ['directory',
5563
takes_options = [Option('force',
5564
5564
help='Switch even if local commits will be lost.'),
5566
5566
Option('create-branch', short_name='b',
5571
5571
def run(self, to_location=None, force=False, create_branch=False,
5572
revision=None, directory=u'.'):
5573
5573
from bzrlib import switch
5574
tree_location = directory
5575
5575
revision = _get_one_revision('switch', revision)
5576
5576
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5577
5577
if to_location is None:
5578
5578
if revision is None:
5579
5579
raise errors.BzrCommandError('You must supply either a'
5580
5580
' revision or a location')
5581
to_location = tree_location
5583
5583
branch = control_dir.open_branch()
5584
5584
had_explicit_nick = branch.get_config().has_explicit_nickname()
5722
tree, file_list = WorkingTree.open_containing_paths(file_list,
5722
tree, file_list = tree_files(file_list, apply_view=False)
5724
5723
current_view, view_dict = tree.views.get_view_info()
5725
5724
if name is None:
5726
5725
name = current_view
5875
5873
_see_also = ['unshelve']
5877
5875
def run(self, revision=None, all=False, file_list=None, message=None,
5878
writer=None, list=False, destroy=False, directory=u'.'):
5876
writer=None, list=False, destroy=False):
5880
5878
return self.run_for_list()
5881
5879
from bzrlib.shelf_ui import Shelver
5883
5881
writer = bzrlib.option.diff_writer_registry.get()
5885
5883
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5886
file_list, message, destroy=destroy, directory=directory)
5884
file_list, message, destroy=destroy)
5894
5892
def run_for_list(self):
5895
5893
tree = WorkingTree.open_containing('.')[0]
5896
self.add_cleanup(tree.lock_read().unlock)
5895
self.add_cleanup(tree.unlock)
5897
5896
manager = tree.get_shelf_manager()
5898
5897
shelves = manager.active_shelves()
5899
5898
if len(shelves) == 0:
5918
5917
takes_args = ['shelf_id?']
5919
5918
takes_options = [
5921
5919
RegistryOption.from_kwargs(
5922
5920
'action', help="The action to perform.",
5923
5921
enum_switch=False, value_switches=True,
5932
5930
_see_also = ['shelve']
5934
def run(self, shelf_id=None, action='apply', directory=u'.'):
5932
def run(self, shelf_id=None, action='apply'):
5935
5933
from bzrlib.shelf_ui import Unshelver
5936
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5934
unshelver = Unshelver.from_args(shelf_id, action)
5938
5936
unshelver.run()
5956
5954
To check what clean-tree will do, use --dry-run.
5958
takes_options = ['directory',
5959
Option('ignored', help='Delete all ignored files.'),
5956
takes_options = [Option('ignored', help='Delete all ignored files.'),
5960
5957
Option('detritus', help='Delete conflict files, merge'
5961
5958
' backups, and failed selftest dirs.'),
5962
5959
Option('unknown',
5965
5962
' deleting them.'),
5966
5963
Option('force', help='Do not prompt before deleting.')]
5967
5964
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5968
force=False, directory=u'.'):
5969
5966
from bzrlib.clean_tree import clean_tree
5970
5967
if not (unknown or ignored or detritus):
5974
clean_tree(directory, unknown=unknown, ignored=ignored,
5975
detritus=detritus, dry_run=dry_run, no_prompt=force)
5971
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5972
dry_run=dry_run, no_prompt=force)
5978
5975
class cmd_reference(Command):
added
removed
bzrlib/builtins.py
